Prev

Next

Index-> contents reference index search external

Up-> CppAD _index

CppAD-> Install Introduction AD ADFun multi_thread library cppad_ipopt_nlp Example preprocessor Appendix

_index

Headings-> A B C D E F G H I J K L M N O P Q R S T U V W Z

Keyword Index !=
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
*
     AD example AD Binary Multiplication: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
*=
     AD example AD Computed Assignment Multiplication: Example and Test
+
     AD example AD Binary Addition: Example and Test
     AD unary operator AD Unary Plus Operator
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
+=
     AD example AD Computed Assignment Addition: Example and Test
-
     AD example AD Binary Subtraction: Example and Test
     AD unary operator AD Unary Minus Operator
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
-=
     AD example AD Computed Assignment Subtraction: Example and Test
/
     AD example AD Binary Division: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
/=
     AD example AD Computed Assignment Division: Example and Test
<
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
<<
     AD example AD Output Operator: Example and Test
     AD output AD Output Stream Operator
<=
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
==
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
>
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
>=
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
[]
     CppAD vector The CppAD::vector Template Class: Element Access
     vector Definition of a Simple Vector: Element Access
A
A.1.1c
     boost thread example A Simple Boost Thread Example and Test
     OpenMP example A Simple Parallel Pthread Example and Test
     OpenMP example A Simple OpenMP Example and Test
AD cppad-20120207: A Package for Differentiation of C++ Algorithms
     arithmetic operator AD Arithmetic Operators and Computed Assignments
     assignment AD Copy Constructor and Assignment Operator
     binary compare operator AD Binary Comparison Operators
     bthread team Boost Thread Implementation of a Team of AD Threads
     computed assignment AD Arithmetic Operators and Computed Assignments
     convert from Conversion and Printing of AD Objects
     convert to Base Convert From an AD Type to its Base Type
     convert to integer Convert From AD to Integer
     copy AD Copy Constructor and Assignment Operator
     default construct Default AD Constructor: Example and Test
     default construct AD Default Constructor
     epsilon Machine Epsilon For AD Types
     Ipopt Nonlinear Programming Using the CppAD Interface to Ipopt
     introduction An Introduction by Example to Algorithmic Differentiation
     level Glossary: AD Levels Above Base
     multiple level Multiple Tapes: Example and Test
     multiple level Using Multiple Levels of AD
     object AD Objects
     openmp team OpenMP Implementation of a Team of AD Threads
     other math Other AD Math Functions
     pthread team Pthread Implementation of a Team of AD Threads
     simple multi_thread Simple Multi-Threading AD: Example and Test
     speed multi_thread Newton Timing Test of Multi-Threaded Newton Method
     stream output AD Output Stream Operator
     thread team Specifications for A Team of AD Threads
     unary minus operator AD Unary Minus Operator
     unary plus operator AD Unary Plus Operator
AD<double>
     compile speed The CppAD Wish List: Library
ADFun
     assignment example ADFun Assignment: Example and Test
     assignment operator Construct an ADFun Object and Stop Recording: Assignment Operator
     CompareChange Comparison Changes During Zero Order Forward Mode
     check Check an ADFun Sequence of Operations
     construct Construct an ADFun Object and Stop Recording
     copy constructor Construct an ADFun Object and Stop Recording: Copy Constructor
     Dependent ADFun Object Deprecated Member Functions: Dependent
     Domain ADFun Sequence Properties: Domain
     default constructor Construct an ADFun Object and Stop Recording: Default Constructor
     evaluate Evaluate ADFun Functions, Derivatives, and Sparsity Patterns
     example Creating Your Own Interface to an ADFun Object
     example ADFun Check and Re-Tape: Example and Test
     Memory ADFun Object Deprecated Member Functions: Memory
     Order ADFun Object Deprecated Member Functions: Order
     object ADFun Objects
     operation sequence Stop Recording and Store Operation Sequence
     Parameter ADFun Sequence Properties: Parameter
     parallel Construct an ADFun Object and Stop Recording: Parallel Mode
     Range ADFun Sequence Properties: Range
     Size ADFun Object Deprecated Member Functions: Size
     sequence constructor Construct an ADFun Object and Stop Recording: Sequence Constructor
     size_par ADFun Sequence Properties: size_par
     size_VecAD ADFun Sequence Properties: size_VecAD
     size_var ADFun Sequence Properties: size_var
     taylor_size ADFun Object Deprecated Member Functions: taylor_size
     use_VecAD ADFun Object Deprecated Member Functions: use_VecAD
Adolc
     adouble as Base Enable use of AD<Base> where Base is Adolc's adouble Type
     multiple level Using Adolc with Multiple Levels of Taping: Example and Test
     ODE Using Adolc with Taylor's Ode Solver: An Example and Test
     unix Unix Download, Test and Installation: AdolcDir
Algorithmic Differentiation
     introduction An Introduction by Example to Algorithmic Differentiation
Automatic Differentiation
     introduction An Introduction by Example to Algorithmic Differentiation
abort
     example Abort Current Recording: Example and Test
     operation sequence Abort Recording of an Operation Sequence
     recording Abort Current Recording: Example and Test
above Glossary: AD Levels Above Base
abs
     AD AD Absolute Value Function
     example AD Absolute Value Function: Example and Test
absolute
     AD value AD Absolute Value Function
     difference Determine if Two Values Are Nearly Equal
aclocal Changes and Additions to CppAD During 2006: 01-08
acos
     AD AD Standard Math Unary Functions
     AD example The AD acos Function: Example and Test
     forward theory Arccosine Function Forward Taylor Polynomial Theory
     reverse theory Arccosine Function Reverse Mode Theory
active Glossary: Tape.Active
ad Glossary: AD Levels Above Base
   Glossary: AD of Base
   Glossary: AD Function
add
     *= example AD Computed Assignment Multiplication: Example and Test
     += example AD Computed Assignment Addition: Example and Test
     -= example AD Computed Assignment Subtraction: Example and Test
     /= example AD Computed Assignment Division: Example and Test
     AD example AD Binary Addition: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
adolc
     link_det_lu Adolc Speed: Gradient of Determinant Using Lu Factorization: Implementation
     speed lu Adolc Speed: Gradient of Determinant Using Lu Factorization
     speed minor Adolc Speed: Gradient of Determinant by Minor Expansion
     speed polynomial Adolc Speed: Second Derivative of a Polynomial
     speed sparse Hessian Adolc Speed: Sparse Hessian
     speed test Speed Test of Derivatives Using Adolc
adouble
     as Base Enable use of AD<Base> where Base is Adolc's adouble Type
algorithm
     example An Epsilon Accurate Exponential Approximation
     example Second Order Exponential Approximation
algorithmic
     C differentiation Example and Test Linking CppAD to Languages Other than C++
algorithmic differentiation cppad-20120207: A Package for Differentiation of C++ Algorithms
allocate
     array Deallocate An Array and Call Destructor for its Elements
     array Allocate An Array and Call Default Constructor for its Elements
     memory Get At Least A Specified Amount of Memory
allocation
     multi-threading A Quick OpenMP Memory Allocator Used by CppAD
     multi-threading A Fast Multi-Threading Memory Allocator
any
     order reverse mode Any Order Reverse Mode
arc_tan
     multi_thread example Two Argument Inverse Tangent Function
arithmetic
     AD operator AD Arithmetic Operators and Computed Assignments
array
     allocate Deallocate An Array and Call Destructor for its Elements
     allocate Allocate An Array and Call Default Constructor for its Elements
     tape index operation Taping Array Index Operation: Example and Test
asin
     AD AD Standard Math Unary Functions
     AD example The AD asin Function: Example and Test
     forward theory Arcsine Function Forward Taylor Polynomial Theory
     reverse theory Arcsine Function Reverse Mode Theory
assert
     error handler Replacing the CppAD Error Handler
     error macro CppAD Assertions During Execution
assign
     *= example AD Computed Assignment Multiplication: Example and Test
     += example AD Computed Assignment Addition: Example and Test
     -= example AD Computed Assignment Subtraction: Example and Test
     /= example AD Computed Assignment Division: Example and Test
     conditional AD Conditional Expressions
assignment
     AD AD Assignment Operator: Example and Test
     AD AD Copy Constructor and Assignment Operator
     AD computed AD Arithmetic Operators and Computed Assignments
     AD computed add example AD Computed Assignment Addition: Example and Test
     AD computed divide example AD Computed Assignment Division: Example and Test
     AD computed multiply example AD Computed Assignment Multiplication: Example and Test
     AD computed subtract example AD Computed Assignment Subtraction: Example and Test
     ADFun example ADFun Assignment: Example and Test
     ADFun operator Construct an ADFun Object and Stop Recording: Assignment Operator
     CppAD vector The CppAD::vector Template Class: Assignment
     multiple AD Computed Assignment Operators: Result
     operator Frequently Asked Questions and Answers: Assignment and Independent
     operator AD Computed Assignment Operators
     vector Definition of a Simple Vector: Assignment
atan
     AD AD Standard Math Unary Functions
     AD example The AD atan Function: Example and Test
     forward theory Arctangent Function Forward Taylor Polynomial Theory
     reverse theory Arctangent Function Reverse Mode Theory
atan2 The CppAD Wish List: Atan2
     AD AD Two Argument Inverse Tangent Function
     AD example The AD atan2 Function: Example and Test
atomic Glossary: Operation.Atomic
     tan Tan and Tanh as User Atomic Operations: Example and Test
     user function User Defined Atomic AD Functions
automatic
     C differentiation Example and Test Linking CppAD to Languages Other than C++
automatic differentiation cppad-20120207: A Package for Differentiation of C++ Algorithms
available
     free Free Memory Currently Available for Quick Use by a Thread
     memory Return Memory to thread_alloc
     omp_alloc Amount of Memory Available for Quick Use by a Thread: Deprecated
     thread_alloc Amount of Memory Available for Quick Use by a Thread
B
Base
     Adolc's adouble Enable use of AD<Base> where Base is Adolc's adouble Type
     convert to AD AD Copy Constructor and Assignment Operator
     double Enable use of AD<Base> where Base is double
     double complex Enable use of AD<Base> where Base is std::complex<double>
     float Enable use of AD<Base> where Base is float
     from AD Convert From an AD Type to its Base Type
     require AD<Base> Requirements for Base Type
     require AD Objects: Base Type Requirements
BenderQuad Computing Jacobian and Hessian of Bender's Reduced Objective
     example BenderQuad: Example and Test
base Glossary: Base Type
     Glossary: Base Function
     Glossary: AD Levels Above Base
     Glossary: AD of Base
     CondExp require Base Type Requirements for Conditional Expressions
     convert to AD AD Constructor From Base Type: Example and Test
     EqualOpSeq require Base Type Requirements for Identically Equal Comparisons: EqualOpSeq
     Integer require AD<Base> Requirements for Base Type: Integer
     identical require Base Type Requirements for Identically Equal Comparisons: Identical
     machine epsilon AD<Base> Requirements for Base Type: epsilon
     math require Base Type Requirements for Standard Math Functions
     pow require Base Type Requirements for Standard Math Functions: pow
     sign require Base Type Requirements for Standard Math Functions: sign
     unary math Base Type Requirements for Standard Math Functions: Unary Standard Math
binary
     AD bool AD Boolean Functions
     AD compare operator AD Binary Comparison Operators
     operator AD Binary Arithmetic Operators
bool
     AD function AD Boolean Functions
     CppAD::vector CppAD::vectorBool Class: Example and Test
boolean Glossary: Sparsity Pattern.Vector of Boolean
boost
     multi-thread memory allocation Fast Multi-Threading Memory Allocator: Example and Test
     unix Unix Download, Test and Installation: BoostDir
     vector Unix Download, Test and Installation: --with-boostvector
boost thread
     example A.1.1c A Simple Boost Thread Example and Test
bthread
     AD team Boost Thread Implementation of a Team of AD Threads
     run tests Run Multi-Threading Examples and Speed Tests: Running Tests.threading
bug
     cygwin pthread_exit Pthread Implementation of a Team of AD Threads: Bug in Cygwin
     gcc 3.4.4 Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2
bugs
     reporting Frequently Asked Questions and Answers: Bugs
     using CppAD Know Bugs and Problems Using CppAD
C
C
     AD Example and Test Linking CppAD to Languages Other than C++
     algorithmic differentiation Example and Test Linking CppAD to Languages Other than C++
     interface to Interfacing to C: Example and Test
C++
     algorithm derivative cppad-20120207: A Package for Differentiation of C++ Algorithms
     numerical template library The CppAD General Purpose Library
CheckNumericType The CheckNumericType Function: Example and Test
     parallel Check NumericType Class Concept: Parallel Mode
CheckSimpleVector The CheckSimpleVector Function: Example and Test
     parallel Check Simple Vector Concept: Parallel Mode
CompareChange Frequently Asked Questions and Answers: CompareChange
     ADFun Comparison Changes During Zero Order Forward Mode
CondExp The CppAD Wish List: CondExp
        Conditional Expressions: Example and Test
     base require Base Type Requirements for Conditional Expressions
CPPAD_
     preprocessor symbol CppAD API Preprocessor Symbols
CPPAD_ASSERT_KNOWN CppAD Assertions During Execution: Restriction.Known
CPPAD_ASSERT_UNKNOWN CppAD Assertions During Execution: Restriction.Unknown
CPPAD_BOOL_BINARY AD Boolean Functions: Create Binary
CPPAD_BOOL_UNARY AD Boolean Functions: Create Unary
CPPAD_COND_EXP_REL Base Type Requirements for Conditional Expressions: CondExpRel
CPPAD_DISCRETE_FUNCTION Discrete AD Functions: Create AD Version
CPPAD_MAX_NUM_THREADS Using CppAD in a Multi-Threading Environment: CPPAD_MAX_NUM_THREADS
CPPAD_NULL CppAD API Preprocessor Symbols: Documented Here.CPPAD_NULL
CPPAD_STANDARD_MATH_UNARY Base Type Requirements for Standard Math Functions: CPPAD_STANDARD_MATH_UNARY
CPPAD_TEST_VECTOR Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol
                  Choosing The Vector Testing Template Class
CPPAD_TRACK_COUNT Routines That Track Use of New and Delete: TrackCount.Macro
CPPAD_TRACK_DEL_VEC Routines That Track Use of New and Delete: TrackDelVec.Macro
CPPAD_TRACK_EXTEND Routines That Track Use of New and Delete: TrackExtend.Macro
CPPAD_TRACK_NEW_VEC Routines That Track Use of New and Delete: TrackNewVec.Macro
CPPAD_USER_ATOMIC User Defined Atomic AD Functions: CPPAD_USER_ATOMIC
                  User Defined Atomic AD Functions
CppAD cppad-20120207: A Package for Differentiation of C++ Algorithms
     install windows Windows Download and Test
     namespace cppad-20120207: A Package for Differentiation of C++ Algorithms: Namespace
     nonlinear programming Nonlinear Programming Using the CppAD Interface to Ipopt
     preprocessor symbol cppad-20120207: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols
     tar file Unix Download, Test and Installation: Download.Unix Tar Files
     unix install Unix Download, Test and Installation
     zip file Windows Download and Test: Download
CppAD::vector
     example CppAD::vector Template Class: Example and Test
CppAD::vectorBool
     example CppAD::vectorBool Class: Example and Test
CppADCreateDiscrete
     deprecated Discrete AD Functions: Deprecated
CppADTrackDelVec Routines That Track Use of New and Delete: TrackDelVec.Previously Deprecated
CppADTrackExtend Routines That Track Use of New and Delete: TrackExtend.Previously Deprecated
CppADTrackNewVec Routines That Track Use of New and Delete: TrackCount.Previously Deprecated
                 Routines That Track Use of New and Delete: TrackNewVec.Previously Deprecated
CppADvector
     deprecated Choosing The Vector Testing Template Class: Deprecated
calculate
     forward mode Any Order Forward Mode
capacity
     Forward Controlling Taylor Coefficients Memory Allocation
capacity_taylor Controlling Taylor Coefficients Memory Allocation
central difference Interfacing to C: Example and Test
change
     constant Computing a Jacobian With Constants that Change
check
     ADFun Check an ADFun Sequence of Operations
     determinant correct Check Gradient of Determinant of 3 by 3 matrix
     determinant correct Check Determinant of 3 by 3 matrix
     memory leak Memory Leak Detection
     numeric Check NumericType Class Concept
     simple vector Check Simple Vector Concept
checkpoint
     example Checkpoint and Function Composition: Example and Test
class
     simple vector Definition of a Simple Vector
     template CppAD vector The CppAD::vector Template Class
coefficient Glossary: Taylor Coefficient
combine
     harmonic Multi-threading Sum of 1/i Utility Routines
     multi_newton Multi-threading Newton Method Utility Routines
compare
     AD binary operator AD Binary Comparison Operators
     AD example AD Binary Comparison Operators: Example and Test
     change CompareChange and Re-Tape: Example and Test
compile
     OpenMP flags Unix Download, Test and Installation: OpenmpFlags
     speed AD<double> The CppAD Wish List: Library
     unix flags Unix Download, Test and Installation: CompilerFlags
complex
     double Base Enable use of AD<Base> where Base is std::complex<double>
     faq Frequently Asked Questions and Answers: Complex Types
     LuSolve LuSolve With Complex Arguments: Example and Test
     polynomial Not Complex Differentiable: Example and Test
     polynomial Complex Polynomial: Example and Test
composition
     example Reverse Mode General Case: Example and Test
computed
     *= example AD Computed Assignment Multiplication: Example and Test
     += example AD Computed Assignment Addition: Example and Test
     -= example AD Computed Assignment Subtraction: Example and Test
     /= example AD Computed Assignment Division: Example and Test
     AD assignment AD Arithmetic Operators and Computed Assignments
     AD assignment add example AD Computed Assignment Addition: Example and Test
     AD assignment divide example AD Computed Assignment Division: Example and Test
     AD assignment multiply example AD Computed Assignment Multiplication: Example and Test
     AD assignment subtract example AD Computed Assignment Subtraction: Example and Test
concept
     C++ The CppAD General Purpose Library: C++ Concepts
     check numeric Check NumericType Class Concept
     check simple vector Check Simple Vector Concept
conditional
     expression AD Conditional Expressions
configure Unix Download, Test and Installation: Configure
     postfix directory Unix Download, Test and Installation: PostfixDir
     prefix directory Unix Download, Test and Installation: PrefixDir
conjugate
     gradient Differentiate Conjugate Gradient Algorithm: Example and Test
constant
     that change Computing a Jacobian With Constants that Change
construct
     , AD default Default AD Constructor: Example and Test
     ADFun Construct an ADFun Object and Stop Recording
     default AD Default Constructor
     from base type AD Constructor From Base Type: Example and Test
constructor
     AD AD Copy Constructor and Assignment Operator
     ADFun constructor Construct an ADFun Object and Stop Recording: Default Constructor
     ADFun copy Construct an ADFun Object and Stop Recording: Copy Constructor
     ADFun sequence Construct an ADFun Object and Stop Recording: Sequence Constructor
     copy vector Definition of a Simple Vector: Copy Constructor
     element Definition of a Simple Vector: Element Constructor and Destructor
     numeric Definition of a Numeric Type: Constructor From Integer
     numeric Definition of a Numeric Type: Default Constructor
     numeric copy Definition of a Numeric Type: Copy Constructor
     size vector Definition of a Simple Vector: Sizing Constructor
     vector default Definition of a Simple Vector: Default Constructor
control
     ODE error An Error Controller for ODE Solvers
     Ode Gear An Error Controller for Gear's Ode Solvers
convert
     AD to Base Convert From an AD Type to its Base Type
     AD to integer Convert From AD to Integer
     from AD Conversion and Printing of AD Objects
     to AD AD Copy Constructor and Assignment Operator
copy
     AD object AD Copy Constructor: Example and Test
     ADFun constructor Construct an ADFun Object and Stop Recording: Copy Constructor
     numeric constructor Definition of a Numeric Type: Copy Constructor
     vector constructor Definition of a Simple Vector: Copy Constructor
correct
     determinant check Check Gradient of Determinant of 3 by 3 matrix
     determinant check Check Determinant of 3 by 3 matrix
cos
     AD AD Standard Math Unary Functions
     AD example The AD cos Function: Example and Test
     forward Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     reverse Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
cosh
     AD AD Standard Math Unary Functions
     AD example The AD cosh Function: Example and Test
     forward Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     reverse Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
cppad
     link_det_lu CppAD Speed: Gradient of Determinant Using Lu Factorization: Implementation
     link_mat_mul CppAD Speed: Matrix Multiplication: Implementation
     link_mat_mul CppAD Speed: Matrix Multiplication (Double Version): Implementation
     profile speed Unix Download, Test and Installation: Profiling CppAD
     speed lu CppAD Speed: Gradient of Determinant Using Lu Factorization
     speed matrix multiply CppAD Speed: Matrix Multiplication
     speed matrix multiply CppAD Speed: Matrix Multiplication (Double Version)
     speed minor CppAD Speed: Gradient of Determinant by Minor Expansion
     speed minor Double Speed: Determinant by Minor Expansion
     speed ode jacobian CppAD Speed: Gradient of Ode Solution
     speed polynomial CppAD Speed: Second Derivative of a Polynomial
     speed polynomial Double Speed: Evaluate a Polynomial
     speed sparse Hessian CppAD Speed: Sparse Hessian
     speed sparse Jacobian CppAD Speed: Sparse Jacobian
     speed test Speed Test Derivatives Using CppAD
     speed test Speed Testing Main Program
     test speed Windows Download and Test: CppAD Speed Test
cppad.hpp
     include cppad-20120207: A Package for Differentiation of C++ Algorithms: Include File
cppad.spec Unix Download, Test and Installation: RPM
cppad_ipopt_nlp The CppAD Wish List: Ipopt
     ode example source ODE Fitting Using Fast Representation
     ode example source ODE Fitting Using Simple Representation
     ode representation ODE Fitting Using Fast Representation
     ode simple representation ODE Fitting Using Simple Representation
create_array
     omp_alloc Allocate Memory and Create A Raw Array: Deprecated
     thread_alloc Allocate An Array and Call Default Constructor for its Elements
current
     thread Get the Current Thread Number
cygwin
     bug in pthread_exit Pthread Implementation of a Team of AD Threads: Bug in Cygwin
D
Dependent Stop Recording and Store Operation Sequence
     ADFun ADFun Object Deprecated Member Functions: Dependent
     example ADFun Check and Re-Tape: Example and Test
     parallel Stop Recording and Store Operation Sequence: Parallel Mode
Domain
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties: Domain
debug
     forward mode Printing AD Values During Forward Mode
default
     ADFun constructor Construct an ADFun Object and Stop Recording: Default Constructor
     constructor AD Default Constructor
     numeric constructor Definition of a Numeric Type: Default Constructor
     vector constructor Definition of a Simple Vector: Default Constructor
delete
     example Tracking Use of New and Delete: Example and Test
     track Routines That Track Use of New and Delete
delete_array
     omp_alloc Return A Raw Array to The Available Memory for a Thread: Deprecated
     thread_alloc Deallocate An Array and Call Destructor for its Elements
dependent Glossary: Tape.Dependent Variables
          Glossary: Operation.Dependent
deprecated
     CppADCreateDiscrete Discrete AD Functions: Deprecated
     CppADvector Choosing The Vector Testing Template Class: Deprecated
     include file Deprecated Include Files
     track memory Routines That Track Use of New and Delete: Deprecated
depreciated
     omp_max_thread OpenMP Parallel Setup: Deprecated
derivative
     directional example AD Absolute Value Function: Example and Test
     easy First Order Derivative: Driver Routine
     example First Order Derivative Driver: Example and Test
     first order driver First Order Derivative: Driver Routine
     forward mode Any Order Forward Mode
     polynomial template Evaluate a Polynomial or its Derivative
     reverse mode Any Order Reverse Mode
     reverse mode Second Order Reverse Mode
     reverse mode First Order Reverse Mode
destructor
     element Definition of a Simple Vector: Element Constructor and Destructor
det_33 Check Determinant of 3 by 3 matrix
     source Source: det_33
det_by_lu Determinant Using Expansion by Lu Factorization
     source Source: det_by_lu
det_by_minor
     source Source: det_by_minor
det_grad_33 Check Gradient of Determinant of 3 by 3 matrix
     source Source: det_grad_33
det_lu
     speed test Speed Testing Gradient of Determinant Using Lu Factorization
det_minor
     speed test Speed Testing Gradient of Determinant by Minor Expansion
det_of_minor Determinant of a Minor
     example Determinant of a Minor: Example and Test
     source Source: det_of_minor
determinant LU Factorization of A Square Matrix and Stability Calculation: LU.Determinant
            LU Factorization of A Square Matrix: LU.Determinant
            Compute Determinants and Solve Equations by LU Factorization
     by minors Determinant Using Lu Factorization: Example and Test
     by minors Determinant Using Expansion by Minors: Example and Test
     check correct Check Gradient of Determinant of 3 by 3 matrix
     check correct Check Determinant of 3 by 3 matrix
     Lu Lu Factor and Solve with Recorded Pivoting
     Lu Compute Determinant and Solve Linear Equations
     Lu factor LU Factorization of A Square Matrix and Stability Calculation
     Lu factor LU Factorization of A Square Matrix
     lu factor Determinant Using Expansion by Lu Factorization
     matrix minor Determinant of a Minor
     minor expansion Determinant Using Expansion by Minors
difference
     absolute Determine if Two Values Are Nearly Equal
     central Interfacing to C: Example and Test
     relative Determine if Two Values Are Nearly Equal
differential
     equation An Arbitrary Order Gear Method
     equation A 3rd and 4th Order Rosenbrock ODE Solver
     equation An Embedded 4th and 5th Order Runge-Kutta ODE Solver
     ODE error control An Error Controller for ODE Solvers
     Ode Gear control An Error Controller for Gear's Ode Solvers
dimension
     multi Romberg integration Multi-dimensional Romberg Integration
direction
     times Hessian Hessian Times Direction: Example and Test
directional
     derivative example AD Absolute Value Function: Example and Test
directory
     configure postfix Unix Download, Test and Installation: PostfixDir
     configure prefix Unix Download, Test and Installation: PrefixDir
discrete
     AD function Discrete AD Functions
     parallel Discrete AD Functions: Parallel Mode
disk
     tape Frequently Asked Questions and Answers: Tape Storage: Disk or Memory
divide
     AD example AD Binary Division: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
documentation
     install Unix Download, Test and Installation: --with-Documentation
double
     Base Enable use of AD<Base> where Base is double
     Base Enable use of AD<Base> where Base is double
     complex Base Enable use of AD<Base> where Base is std::complex<double>
     convert to AD AD Copy Constructor and Assignment Operator
     link_det_lu Double Speed: Determinant Using Lu Factorization: Implementation
     speed lu Double Speed: Determinant Using Lu Factorization
     speed ode Double Speed: Ode Solution
     speed sparse hessian Double Speed: Sparse Hessian
     speed sparse jacobian Double Speed: Sparse Jacobian
     speed test Speed Test of Functions in Double
     test speed Windows Download and Test: Double Speed Test
download
     subversion Using Subversion To Download Source Code
     unix Unix Download, Test and Installation: Download
     windows Windows Download and Test: Download
driver
     easy First and Second Derivatives: Easy Drivers
     easy derivative First Order Derivative: Driver Routine
     easy partial Reverse Mode Second Partial Derivative Driver
     easy partial Forward Mode Second Partial Derivative Driver
     easy partial First Order Partial Derivative: Driver Routine
     first order derivative First Order Derivative: Driver Routine
     first order partial First Order Partial Derivative: Driver Routine
     Hessian Hessian: Easy Driver
     Jacobian Jacobian: Driver Routine
     second order partial Reverse Mode Second Partial Derivative Driver
     second order partial Forward Mode Second Partial Derivative Driver
E
EqualOpSeq Check if Two Value are Identically Equal
     base require Base Type Requirements for Identically Equal Comparisons: EqualOpSeq
     example EqualOpSeq: Example and Test
ErrorHandler Frequently Asked Questions and Answers: Exceptions
     parallel Replacing the CppAD Error Handler: Constructor.Parallel Mode
easy
     derivative First Order Derivative: Driver Routine
     driver First and Second Derivatives: Easy Drivers
     partial Reverse Mode Second Partial Derivative Driver
     partial Forward Mode Second Partial Derivative Driver
     partial First Order Partial Derivative: Driver Routine
efficient
     omp_alloc Check If A Memory Allocation is Efficient for Another Use: Removed
     sparsity Glossary: Sparsity Pattern
elapsed
     seconds Elapsed Seconds: Example and Test
elapsed_seconds Returns Elapsed Number of Seconds
elementary Glossary: Elementary Vector
epsilon Machine Epsilon: Example and Test
     AD Machine Epsilon For AD Types
     machine base AD<Base> Requirements for Base Type: epsilon
equal
     near Determine if Two Values Are Nearly Equal
     operation sequence Check if Two Value are Identically Equal
equation
     differential An Arbitrary Order Gear Method
     differential A 3rd and 4th Order Rosenbrock ODE Solver
     differential An Embedded 4th and 5th Order Runge-Kutta ODE Solver
     Lu factor LU Factorization of A Square Matrix and Stability Calculation
     Lu factor LU Factorization of A Square Matrix
     Lu invert Invert an LU Factored Equation
     linear Compute Determinant and Solve Linear Equations
     linear Compute Determinants and Solve Equations by LU Factorization
     ODE error control An Error Controller for ODE Solvers
     Ode Gear control An Error Controller for Gear's Ode Solvers
     solve linear Lu Factor and Solve with Recorded Pivoting
erf Changes and Additions to CppAD During 2008: 11-20
     AD function The AD Error Function
     example The AD erf Function: Example and Test
error
     AD function The AD Error Function
     assert macro CppAD Assertions During Execution
     control ODE An Error Controller for ODE Solvers
     Gear Ode An Error Controller for Gear's Ode Solvers
     handler Replacing The CppAD Error Handler: Example and Test
     handler Replacing the CppAD Error Handler
evaluate
     ADFun Evaluate ADFun Functions, Derivatives, and Sparsity Patterns
example Examples
     AD acos The AD acos Function: Example and Test
     AD add AD Binary Addition: Example and Test
     AD asin The AD asin Function: Example and Test
     AD assignment AD Assignment Operator: Example and Test
     AD atan The AD atan Function: Example and Test
     AD atan2 The AD atan2 Function: Example and Test
     AD bool AD Boolean Functions: Example and Test
     AD compare AD Binary Comparison Operators: Example and Test
     AD computed assignment add AD Computed Assignment Addition: Example and Test
     AD computed assignment divide AD Computed Assignment Division: Example and Test
     AD computed assignment multiply AD Computed Assignment Multiplication: Example and Test
     AD computed assignment subtract AD Computed Assignment Subtraction: Example and Test
     AD cos The AD cos Function: Example and Test
     AD cosh The AD cosh Function: Example and Test
     AD divide AD Binary Division: Example and Test
     AD exp The AD exp Function: Example and Test
     AD log The AD log Function: Example and Test
     AD log10 The AD log10 Function: Example and Test
     AD multiply AD Binary Multiplication: Example and Test
     AD output AD Output Operator: Example and Test
     AD pow The AD Power Function: Example and Test
     AD sin The AD sin Function: Example and Test
     AD sinh The AD sinh Function: Example and Test
     AD sqrt The AD sqrt Function: Example and Test
     ADFun Creating Your Own Interface to an ADFun Object
     ADFun ADFun Check and Re-Tape: Example and Test
     ADFun assignment ADFun Assignment: Example and Test
     ADFun default constructor Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     abort Abort Current Recording: Example and Test
     abs AD Absolute Value Function: Example and Test
     algorithm An Epsilon Accurate Exponential Approximation
     algorithm Second Order Exponential Approximation
     arc_tan multi_thread Two Argument Inverse Tangent Function
     BenderQuad BenderQuad: Example and Test
     boost thread A.1.1c A Simple Boost Thread Example and Test
     C AD Example and Test Linking CppAD to Languages Other than C++
     CompareChange CompareChange and Re-Tape: Example and Test
     CondExp Conditional Expressions: Example and Test
     CppAD CppAD Examples and Tests
     CppAD::vector CppAD::vector Template Class: Example and Test
     CppAD::vectorBool CppAD::vectorBool Class: Example and Test
     check NumericType The CheckNumericType Function: Example and Test
     check SimpleVector The CheckSimpleVector Function: Example and Test
     checkpoint Checkpoint and Function Composition: Example and Test
     complex LuSolve With Complex Arguments: Example and Test
     complex polynomial Complex Polynomial: Example and Test
     composition Reverse Mode General Case: Example and Test
     conjugate gradient Differentiate Conjugate Gradient Algorithm: Example and Test
     construct from base AD Constructor From Base Type: Example and Test
     copy AD object AD Copy Constructor: Example and Test
     cppad_ipopt_nlp ode source ODE Fitting Using Fast Representation
     cppad_ipopt_nlp ode source ODE Fitting Using Simple Representation
     Dependent ADFun Check and Re-Tape: Example and Test
     Domain ADFun Sequence Properties: Example and Test
     default AD construct Default AD Constructor: Example and Test
     delete Tracking Use of New and Delete: Example and Test
     derivative First Order Derivative Driver: Example and Test
     det_of_minor Determinant of a Minor: Example and Test
     determinant by minors Determinant Using Lu Factorization: Example and Test
     determinant by minors Determinant Using Expansion by Minors: Example and Test
     EqualOpSeq EqualOpSeq: Example and Test
     epsilon Machine Epsilon: Example and Test
     erf The AD erf Function: Example and Test
     error handler Replacing The CppAD Error Handler: Example and Test
     Forward Forward Mode: Example and Test
     FunCheck ADFun Check and Re-Tape: Example and Test
     first order reverse First Order Reverse Mode: Example and Test
     forward mode exp_eps: Second Order Forward Mode
     forward mode exp_2: Second Order Forward Mode
     forward mode exp_2: First Order Forward Mode
     general General Examples
     general reverse Reverse Mode General Case: Example and Test
     gradient Gradient of Determinant Using Lu Factorization: Example and Test
     gradient Gradient of Determinant Using Expansion by Minors: Example and Test
     gradient Gradient of Determinant Using LU Factorization: Example and Test
     gradient Gradient of Determinant Using Expansion by Minors: Example and Test
     Hessian Hessian: Example and Test
     Hessian of Lagrangian Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     Independent Independent and ADFun Constructor: Example and Test
     Integer Convert From AD to Integer: Example and Test
     interpreter Example Differentiating a Stack Machine Interpreter
     Jacobian Jacobian: Example and Test
     LU Gradient of Determinant Using LU Factorization: Example and Test
     Lu Gradient of Determinant Using Lu Factorization: Example and Test
     Lu record pivot Lu Factor and Solve With Recorded Pivoting: Example and Test
     LuFactor LuFactor: Example and Test
     LuInvert LuInvert: Example and Test
     LuRatio LuRatio: Example and Test
     LuSolve LuSolve With Complex Arguments: Example and Test
     mat_sum_sq Sum of the Elements of the Square of a Matrix: Example and Test
     memory allocation OpenMP Memory Allocator: Example and Test
     memory allocation Fast Multi-Threading Memory Allocator: Example and Test
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     NearEqual NearEqual Function: Example and Test
     NearEqualExt Compare AD with Base Objects: Example and Test
     NumericType The NumericType: Example and Test
     nan nan: Example and Test
     new Tracking Use of New and Delete: Example and Test
     nonlinear, programming Nonlinear Programming Using CppAD and Ipopt: Example and Test
     not complex differentiable Not Complex Differentiable: Example and Test
     ODE Taylor's Ode Solver: An Example and Test
     OdeErrControl OdeErrControl: Example and Test Using Maxabs Argument
     OdeErrControl OdeErrControl: Example and Test
     OdeGear OdeGear: Example and Test
     OdeGearControl OdeGearControl: Example and Test
     OpenMP A.1.1c A Simple Parallel Pthread Example and Test
     OpenMP A.1.1c A Simple OpenMP Example and Test
     ode inverse ODE Inverse Problem Definitions: Source Code
     ode inverse An ODE Inverse Problem Example
     ode_evaluate ode_evaluate: Example and test
     operation sequence exp_eps: Operation Sequence and Zero Order Forward Sweep
     operation sequence exp_2: Operation Sequence and Zero Order Forward Mode
     opt_val_hes opt_val_hes: Example and Test
     optimize ADFun Operation Sequence Optimization: Example and Test
     Parameter ADFun Sequence Properties: Example and Test
     Parameter AD Parameter and Variable Functions: Example and Test
     partial First Order Partial Driver: Example and Test
     polynomial Polynomial Evaluation: Example and Test
     pow int The Pow Integer Exponent: Example and Test
     print forward mode Printing During Forward Mode: Example and Test
     Range ADFun Sequence Properties: Example and Test
     Romberg One Dimensional Romberg Integration: Example and Test
     Romberg One Dimensional Romberg Integration: Example and Test
     Rosen34 Rosen34: Example and Test
     Runge45 Runge45: Example and Test
     Runge45 Runge45: Example and Test
     re-tape CompareChange and Re-Tape: Example and Test
     reverse mode exp_eps: Second Order Reverse Sweep
     reverse mode exp_eps: First Order Reverse Sweep
     reverse mode exp_2: Second Order Reverse Mode
     reverse mode exp_2: First Order Reverse Mode
     reverse third order Third Order Reverse Mode: Example and Test
     SpeedTest Example Use of SpeedTest
     second order reverse Second Order Reverse ModeExample and Test
     second partial Second Partials Reverse Driver: Example and Test
     second partial Subset of Second Order Partials: Example and Test
     sign Sign Function: Example and Test
     simple Getting Started Using CppAD to Compute Derivatives
     simple vector Simple Vector Template Class: Example and Test
     size_op ADFun Sequence Properties: Example and Test
     size_op_arg ADFun Sequence Properties: Example and Test
     size_par ADFun Sequence Properties: Example and Test
     size_VecAD ADFun Sequence Properties: Example and Test
     size_var ADFun Sequence Properties: Example and Test
     sparse Hessian Sparse Hessian: Example and Test
     sparse Jacobian Sparse Jacobian: Example and Test
     sparse_evaluate sparse_evaluate: Example and test
     sparsity forward Forward Mode Jacobian Sparsity: Example and Test
     sparsity Hessian Reverse Mode Hessian Sparsity: Example and Test
     sparsity reverse Reverse Mode Jacobian Sparsity: Example and Test
     speed program Run the Speed Examples
     speed utility Windows Download and Test: Speed Utility Example
     speed_test speed_test: Example and test
     stiff ode A Stiff Ode: Example and Test
     subtract AD Binary Subtraction: Example and Test
     tan The AD tan Function: Example and Test
     tanh The AD tanh Function: Example and Test
     thread_test Run Multi-Threading Examples and Speed Tests
     time_test time_test: Example and test
     timer Elapsed Seconds: Example and Test
     unary minus AD Unary Minus Operator: Example and Test
     unary plus AD Unary Plus Operator: Example and Test
     user_atomic Define Matrix Multiply as a User Atomic Operation
     user_atomic Tan and Tanh as User Atomic Operations: Example and Test
     Value Convert From AD to its Base Type: Example and Test
     Var2Par Convert an AD Variable to a Parameter: Example and Test
     Variable AD Parameter and Variable Functions: Example and Test
     VecAD AD Vectors that Record Index Operations: Example and Test
     windows Windows Download and Test: Examples and Testing
exception
     error handler Replacing the CppAD Error Handler
     test Frequently Asked Questions and Answers: Exceptions
execution
     parallel Is The Current Execution in Parallel Mode
     parallel Using CppAD in a Multi-Threading Environment
exercise
     CppAD::vector The CppAD::vector Template Class: Exercise
     NearEqual Determine if Two Values Are Nearly Equal: Exercise
     numeric type Definition of a Numeric Type: Exercise
     simple vector Definition of a Simple Vector: Exercise
exp
     AD AD Standard Math Unary Functions
     AD example The AD exp Function: Example and Test
     example An Epsilon Accurate Exponential Approximation
     example Second Order Exponential Approximation
     forward theory Exponential Function Forward Taylor Polynomial Theory
     reverse theory Exponential Function Reverse Mode Theory
exp_2 Second Order Exponential Approximation
     first order exp_eps: Verify Second Order Forward Sweep
     first order exp_eps: Verify First Order Forward Sweep
     first order exp_2: Verify First Order Forward Sweep
     forward mode exp_2: Second Order Forward Mode
     forward mode exp_2: First Order Forward Mode
     implementation exp_2: Implementation
     operation sequence exp_2: Operation Sequence and Zero Order Forward Mode
     reverse mode exp_2: Verify Second Order Reverse Sweep
     reverse mode exp_2: Verify First Order Reverse Sweep
     reverse mode exp_2: Second Order Reverse Mode
     reverse mode exp_2: First Order Reverse Mode
     second order exp_2: Verify Second Order Forward Sweep
     test exp_2: Test
     zero order exp_2: Verify Zero Order Forward Sweep
exp_apx
     main test Correctness Tests For Exponential Approximation in Introduction
exp_eps An Epsilon Accurate Exponential Approximation
     forward mode exp_eps: Second Order Forward Mode
     implementation exp_eps: Implementation
     operation sequence exp_eps: Operation Sequence and Zero Order Forward Sweep
     reverse exp_eps: Verify Second Order Reverse Sweep
     reverse exp_eps: Verify First Order Reverse Sweep
     reverse mode exp_eps: Second Order Reverse Sweep
     reverse mode exp_eps: First Order Reverse Sweep
     test exp_eps: Test of exp_eps
     zero order exp_eps: Verify Zero Order Forward Sweep
expansion Gradient of Determinant Using Expansion by Minors: Example and Test
          Gradient of Determinant Using Expansion by Minors: Example and Test
     first order exp_eps: First Order Forward Sweep: First Order Expansion
     first order exp_2: First Order Forward Mode: First Order Expansion
     minor determinant Determinant Using Expansion by Minors
     second order exp_eps: Second Order Forward Mode: Second Order Expansion
     second order exp_2: Second Order Forward Mode: Second Order Expansion
     zero order exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion
exponent
     AD function The AD Power Function
     integer The Integer Power Function
expression
     conditional AD Conditional Expressions
F
FAQ Frequently Asked Questions and Answers
Fadbad
     unix Unix Download, Test and Installation: FadbadDir
Fedora
     install Unix Download, Test and Installation: Fedora
ForSparseJac Forward Mode Jacobian Sparsity: Example and Test
             Jacobian Sparsity Pattern: Forward Mode
Forward Forward Mode: Example and Test
     capacity Controlling Taylor Coefficients Memory Allocation
     order one First Order Forward Mode: Derivative Values
     order zero Zero Order Forward Mode: Function Values
FunCheck Check an ADFun Sequence of Operations
     example ADFun Check and Re-Tape: Example and Test
factor
     lu determinant Determinant Using Expansion by Lu Factorization
     matrix Compute Determinants and Solve Equations by LU Factorization
fadbad
     link_det_lu Fadbad Speed: Gradient of Determinant Using Lu Factorization: Implementation
     speed lu Fadbad Speed: Gradient of Determinant Using Lu Factorization
     speed minor Fadbad Speed: Gradient of Determinant by Minor Expansion
     speed polynomial Fadbad Speed: Second Derivative of a Polynomial
     speed test Speed Test Derivatives Using Fadbad
features
     new The CppAD Wish List
file
     deprecated include Deprecated Include Files
files
     pkg-config CppAD pkg-config Files
first
     derivative Jacobian: Driver Routine
     order derivative driver First Order Derivative: Driver Routine
     order exp_2 exp_eps: Verify Second Order Forward Sweep
     order exp_2 exp_eps: Verify First Order Forward Sweep
     order exp_2 exp_2: Verify First Order Forward Sweep
     order expansion exp_eps: First Order Forward Sweep: First Order Expansion
     order expansion exp_2: First Order Forward Mode: First Order Expansion
     order forward exp_eps: First Order Forward Sweep
     order partial driver First Order Partial Derivative: Driver Routine
     order reverse exp_eps: First Order Reverse Sweep
     order reverse exp_2: First Order Reverse Mode
     order reverse mode First Order Reverse Mode
flags
     OpenMP compile Unix Download, Test and Installation: OpenmpFlags
     unix compile Unix Download, Test and Installation: CompilerFlags
float
     Base Enable use of AD<Base> where Base is float
     Base Enable use of AD<Base> where Base is float
forward Frequently Asked Questions and Answers: Mode: Forward or Reverse
     acos theory Arccosine Function Forward Taylor Polynomial Theory
     asin theory Arcsine Function Forward Taylor Polynomial Theory
     atan theory Arctangent Function Forward Taylor Polynomial Theory
     cos Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     cosh Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     debug Printing AD Values During Forward Mode
     easy driver First and Second Derivatives: Easy Drivers
     exp theory Exponential Function Forward Taylor Polynomial Theory
     first order exp_eps: First Order Forward Sweep
     first order exp_2: First Order Forward Mode
     log theory Logarithm Function Forward Taylor Polynomial Theory
     mode Any Order Forward Mode
     mode example exp_eps: Second Order Forward Mode
     mode example exp_2: Second Order Forward Mode
     mode example exp_2: First Order Forward Mode
     mode print Printing During Forward Mode: Example and Test
     mode print Printing AD Values During Forward Mode
     print Windows Download and Test: Printing During Forward Mode
     second order exp_eps: Second Order Forward Mode
     second order exp_2: Second Order Forward Mode
     sin Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     sinh Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     sparsity Jacobian Jacobian Sparsity Pattern: Forward Mode
     sqrt theory Square Root Function Forward Taylor Polynomial Theory
     tan theory Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory
     zero order Comparison Changes During Zero Order Forward Mode
     zero order exp_eps: Operation Sequence and Zero Order Forward Sweep
     zero order exp_2: Operation Sequence and Zero Order Forward Mode
     zero order print Print During Zero Order Forward Mode: Example and Test
free
     available Free Memory Currently Available for Quick Use by a Thread
     install CppAD Windows Download and Test
     unix install Unix Download, Test and Installation
free_available
     omp_alloc Free Memory Currently Available for Quick Use by a Thread: Deprecated
     thread_alloc Free Memory Currently Available for Quick Use by a Thread
function Glossary: Base Function
         Glossary: AD Function
     AD Bool valued Bool Valued Operations and Functions with AD Arguments
     AD bool AD Boolean Functions
     AD valued AD Valued Operations and Functions
     discrete AD Discrete AD Functions
     error AD The AD Error Function
     math Frequently Asked Questions and Answers: Math Functions
     ode_evaluate Evaluate a Function Defined in Terms of an ODE
     sparse_evaluate Evaluate a Function That Has a Sparse Hessian
     user atomic User Defined Atomic AD Functions
G
Gear
     Ode An Arbitrary Order Gear Method
GetStarted
     windows Windows Download and Test: Getting Started
gcc 3.4.4
     bug Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2
general
     example General Examples
     reverse example Reverse Mode General Case: Example and Test
get_max_num_threads
     omp_alloc Set and Get Maximum Number of Threads for omp_alloc Allocator: Deprecated
get_thread_num
     omp_alloc Get At Least A Specified Amount of Memory: Deprecated
     omp_alloc Get the Current OpenMP Thread Number: Deprecated
getting
     started Getting Started Using CppAD to Compute Derivatives
gradient Gradient of Determinant Using Lu Factorization: Example and Test
         Gradient of Determinant Using Expansion by Minors: Example and Test
         Gradient of Determinant Using LU Factorization: Example and Test
         Gradient of Determinant Using Expansion by Minors: Example and Test
     conjugate Differentiate Conjugate Gradient Algorithm: Example and Test
     ode speed sacado Sacado Speed: Gradient of Ode Solution
H
HesLagrangian Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
Hessian Jacobian and Hessian of Optimal Values
        Hessian: Example and Test
     Bender Computing Jacobian and Hessian of Bender's Reduced Objective
     driver Hessian: Easy Driver
     sparse Sparse Hessian: Example and Test
     sparse speed adolc Adolc Speed: Sparse Hessian
     sparse speed cppad CppAD Speed: Sparse Hessian
     times direction Hessian Times Direction: Example and Test
handler
     error Replacing The CppAD Error Handler: Example and Test
     error Replacing the CppAD Error Handler
harmonic Multi-Threaded Implementation of Summation of 1/i
     multi_thread Multi-Threaded Implementation of Summation of 1/i
harmonic_combine Multi-threading Sum of 1/i Utility Routines
harmonic_setup Multi-threading Sum of 1/i Utility Routines
harmonic_time Timing Test of Multi-Threaded Summation of 1/i
harmonic_work Multi-threading Sum of 1/i Utility Routines
harmonic_worker Multi-threading Sum of 1/i Utility Routines
hasnan Obtain Nan or Determine if a Value is Nan
hessian
     sparse Sparse Hessian: Easy Driver
hold
     thread_alloc memory Control When Thread Alloc Retains Memory For Future Use
I
Independent Declare Independent Variables and Start Recording
     example Independent and ADFun Constructor: Example and Test
     parallel Declare Independent Variables and Start Recording: Parallel Mode
Integer Convert From AD to Integer: Example and Test
        Convert From AD to Integer
     base require AD<Base> Requirements for Base Type: Integer
Ipopt
     AD Nonlinear Programming Using the CppAD Interface to Ipopt
     unix Unix Download, Test and Installation: IpoptDir
identical
     base require Base Type Requirements for Identically Equal Comparisons: Identical
imag() Not Complex Differentiable: Example and Test
implementation
     exp_2 exp_2: Implementation
     exp_eps exp_eps: Implementation
in_parallel Setup thread_alloc For Use in Multi-Threading Environment
     omp_alloc Is The Current Execution in OpenMP Parallel Mode: Deprecated
     thread_alloc Is The Current Execution in Parallel Mode
inactive Glossary: Tape.Inactive
include
     cppad.hpp cppad-20120207: A Package for Differentiation of C++ Algorithms: Include File
     deprecated file Deprecated Include Files
independent Glossary: Tape.Independent Variable
            Glossary: Operation.Independent
            Frequently Asked Questions and Answers: Assignment and Independent
independent variable Frequently Asked Questions and Answers: Independent Variables
index
     AD record AD Vectors that Record Index Operations
     tape array operation Taping Array Index Operation: Example and Test
initialize
     multi-threading Setup thread_alloc For Use in Multi-Threading Environment
install CppAD Download, Test, and Installation Instructions
     documentation Unix Download, Test and Installation: --with-Documentation
     Fedora Unix Download, Test and Installation: Fedora
     unix CppAD Unix Download, Test and Installation
     windows CppAD Windows Download and Test
int
     numeric constructor Definition of a Numeric Type: Constructor From Integer
integer
     pow The Integer Power Function
integrate
     multi-dimensional Romberg Multi-dimensional Romberg Integration
     Romberg One DimensionalRomberg Integration
interface
     to C Interfacing to C: Example and Test
interpolate
     example Interpolation With Retaping: Example and Test
     example Interpolation With Out Retaping: Example and Test
     test Interpolation With Retaping: Example and Test
     test Interpolation With Out Retaping: Example and Test
interpreter
     example Example Differentiating a Stack Machine Interpreter
introduction cppad-20120207: A Package for Differentiation of C++ Algorithms: Introduction
     AD An Introduction by Example to Algorithmic Differentiation
     windows Windows Download and Test: Introduction
inuse
     omp_alloc Amount of Memory a Thread is Currently Using: Deprecated
     thread_alloc Amount of Memory a Thread is Currently Using
inverse
     AD tan AD Two Argument Inverse Tangent Function
     matrix Frequently Asked Questions and Answers: Matrix Inverse
     ode example ODE Inverse Problem Definitions: Source Code
     ode example An ODE Inverse Problem Example
ipopt
     AD example Nonlinear Programming Using CppAD and Ipopt: Example and Test
ipopt_cppad_nlp Changes and Additions to CppAD During 2008: 08-29
isnan Obtain Nan or Determine if a Value is Nan
     macro Obtain Nan or Determine if a Value is Nan: Include.Macros
J
Jacobian Jacobian and Hessian of Optimal Values
         Jacobian: Example and Test
     Bender Computing Jacobian and Hessian of Bender's Reduced Objective
     driver Jacobian: Driver Routine
     sparse Sparse Jacobian: Example and Test
     sparse speed cppad CppAD Speed: Sparse Jacobian
jacobian
     ode speed cppad CppAD Speed: Gradient of Ode Solution
     sparse Sparse Jacobian: Easy Driver
K
Kutta
     ODE An Embedded 4th and 5th Order Runge-Kutta ODE Solver
L
LU Gradient of Determinant Using LU Factorization: Example and Test
Lu Gradient of Determinant Using Lu Factorization: Example and Test
     linear equation Lu Factor and Solve with Recorded Pivoting
     record pivot Lu Factor and Solve With Recorded Pivoting: Example and Test
LuFactor LU Factorization of A Square Matrix
     source Source: LuFactor
LuInvert Invert an LU Factored Equation
     source Source: LuInvert
LuRatio LU Factorization of A Square Matrix and Stability Calculation
LuSolve Compute Determinant and Solve Linear Equations
     source Source: LuSolve
LuVecAD Lu Factor and Solve with Recorded Pivoting
language
     link CppAD Example and Test Linking CppAD to Languages Other than C++
leak
     memory Memory Leak Detection
level
     AD Glossary: AD Levels Above Base
     multiple AD Computing a Jacobian With Constants that Change
     multiple AD Multiple Tapes: Example and Test
     multiple AD Using Multiple Levels of AD
     multiple Adolc Using Adolc with Multiple Levels of Taping: Example and Test
levels Glossary: AD Levels Above Base
library
     numerical C++ template The CppAD General Purpose Library
linear
     equation Compute Determinant and Solve Linear Equations
     equation Compute Determinants and Solve Equations by LU Factorization
     invert Lu equation Invert an LU Factored Equation
     Lu factor equation LU Factorization of A Square Matrix and Stability Calculation
     Lu factor equation LU Factorization of A Square Matrix
     solve equation Lu Factor and Solve with Recorded Pivoting
link
     CppAD to language Example and Test Linking CppAD to Languages Other than C++
link_det_lu Speed Testing Gradient of Determinant Using Lu Factorization
     adolc Adolc Speed: Gradient of Determinant Using Lu Factorization: Implementation
     cppad CppAD Speed: Gradient of Determinant Using Lu Factorization: Implementation
     double Double Speed: Determinant Using Lu Factorization: Implementation
     fadbad Fadbad Speed: Gradient of Determinant Using Lu Factorization: Implementation
     sacado Sacado Speed: Gradient of Determinant Using Lu Factorization: Implementation
link_det_minor Sacado Speed: Gradient of Determinant by Minor Expansion: link_det_minor
               Fadbad Speed: Gradient of Determinant by Minor Expansion: link_det_minor
               CppAD Speed: Gradient of Determinant by Minor Expansion: link_det_minor
               Adolc Speed: Gradient of Determinant by Minor Expansion: link_det_minor
               Double Speed: Determinant by Minor Expansion: link_det_minor
               Speed Testing Gradient of Determinant by Minor Expansion
link_mat_mul Speed Testing Derivative of Matrix Multiply
     cppad CppAD Speed: Matrix Multiplication: Implementation
     cppad CppAD Speed: Matrix Multiplication (Double Version): Implementation
link_ode Sacado Speed: Gradient of Ode Solution: link_ode
         CppAD Speed: Gradient of Ode Solution: link_ode
         Double Speed: Ode Solution: link_ode
         Speed Testing the Jacobian of Ode Solution
link_poly Sacado Speed: Second Derivative of a Polynomial: link_poly
          Fadbad Speed: Second Derivative of a Polynomial: link_poly
          CppAD Speed: Second Derivative of a Polynomial: link_poly
          Adolc Speed: Second Derivative of a Polynomial: link_poly
          Double Speed: Evaluate a Polynomial: link_poly
          Speed Testing Second Derivative of a Polynomial
link_sparse_hessian CppAD Speed: Sparse Hessian: link_sparse_hessian
                    Adolc Speed: Sparse Hessian: link_sparse_hessian
                    Double Speed: Sparse Hessian: link_sparse_hessian
                    Speed Testing Sparse Hessian
link_sparse_jacobian CppAD Speed: Sparse Jacobian: link_sparse_jacobian
                     Double Speed: Sparse Jacobian: link_sparse_jacobian
                     Speed Testing Sparse Jacobian
log
     AD AD Standard Math Unary Functions
     AD example The AD log Function: Example and Test
     forward theory Logarithm Function Forward Taylor Polynomial Theory
     reverse theory Logarithm Function Reverse Mode Theory
log10
     AD AD Standard Math Unary Functions
     AD example The AD log10 Function: Example and Test
lu
     factor determinant Determinant Using Expansion by Lu Factorization
     speed adolc Adolc Speed: Gradient of Determinant Using Lu Factorization
     speed cppad CppAD Speed: Gradient of Determinant Using Lu Factorization
     speed double Double Speed: Determinant Using Lu Factorization
     speed fadbad Fadbad Speed: Gradient of Determinant Using Lu Factorization
     speed sacado Sacado Speed: Gradient of Determinant Using Lu Factorization
M
Memory
     ADFun ADFun Object Deprecated Member Functions: Memory
MS Windows
     extend speed tests The CppAD Wish List: Speed Testing
machine
     epsilon base AD<Base> Requirements for Base Type: epsilon
machine epsilon
     testing The CppAD Wish List: Numeric Limits
macro
     error assert CppAD Assertions During Execution
     isnan Obtain Nan or Determine if a Value is Nan: Include.Macros
     nan Obtain Nan or Determine if a Value is Nan: Include.Macros
mat_mul
     define Define Matrix Multiply as a User Atomic Operation
     example Matrix Multiply as a User Atomic Operation: Example and Test
     test Matrix Multiply as a User Atomic Operation: Example and Test
mat_sum_sq Sum Elements of a Matrix Times Itself
     example Sum of the Elements of the Square of a Matrix: Example and Test
     source Source: mat_sum_sq
math
     AD other Other AD Math Functions
     AD unary AD Standard Math Unary Functions
     base require Base Type Requirements for Standard Math Functions
     base unary Base Type Requirements for Standard Math Functions: Unary Standard Math
     functions Frequently Asked Questions and Answers: Math Functions
     standard function Frequently Asked Questions and Answers: Namespace.Using
matrix
     atomic example Matrix Multiply as a User Atomic Operation: Example and Test
     determinant Compute Determinants and Solve Equations by LU Factorization
     factor Compute Determinants and Solve Equations by LU Factorization
     inverse Frequently Asked Questions and Answers: Matrix Inverse
     linear equation Compute Determinants and Solve Equations by LU Factorization
     minor determinant Determinant of a Minor
     multiply Define Matrix Multiply as a User Atomic Operation
     multiply speed cppad CppAD Speed: Matrix Multiplication
     multiply speed cppad CppAD Speed: Matrix Multiplication (Double Version)
     multiply speed test Sum Elements of a Matrix Times Itself
     multiply speed test Speed Testing Derivative of Matrix Multiply
max_num_threads
     omp_alloc Set Maximum Number of Threads for omp_alloc Allocator: Removed
maxabs
     OdeErrControl OdeErrControl: Example and Test Using Maxabs Argument
maximum
     number of threads Using CppAD in a Multi-Threading Environment: CPPAD_MAX_NUM_THREADS
memory
     allocate Get At Least A Specified Amount of Memory
     available Amount of Memory Available for Quick Use by a Thread
     available Return Memory to thread_alloc
     control Controlling Taylor Coefficients Memory Allocation
     multi-threading allocation A Quick OpenMP Memory Allocator Used by CppAD
     multi-threading allocation A Fast Multi-Threading Memory Allocator
     optimize Optimize an ADFun Object Tape
     tape Frequently Asked Questions and Answers: Tape Storage: Disk or Memory
     tape Unix Download, Test and Installation: TapeAddrType
     thread_alloc hold Control When Thread Alloc Retains Memory For Future Use
     track Routines That Track Use of New and Delete
     usage Unix Download, Test and Installation: TapeAddrType
memory_leak Memory Leak Detection
minor
     expansion determinant Determinant Using Expansion by Minors
     matrix determinant Determinant of a Minor
     speed adolc Adolc Speed: Gradient of Determinant by Minor Expansion
     speed cppad CppAD Speed: Gradient of Determinant by Minor Expansion
     speed cppad Double Speed: Determinant by Minor Expansion
     speed fadbad Fadbad Speed: Gradient of Determinant by Minor Expansion
     speed sacado Sacado Speed: Gradient of Determinant by Minor Expansion
minors Gradient of Determinant Using Expansion by Minors: Example and Test
       Gradient of Determinant Using Expansion by Minors: Example and Test
minus
     AD example AD Binary Subtraction: Example and Test
     AD unary operator AD Unary Minus Operator
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
mode Frequently Asked Questions and Answers: Mode: Forward or Reverse
     any order reverse Any Order Reverse Mode
     example forward exp_eps: Second Order Forward Mode
     example forward exp_2: Second Order Forward Mode
     example forward exp_2: First Order Forward Mode
     example reverse exp_2: Second Order Reverse Mode
     example reverse exp_2: First Order Reverse Mode
     first order reverse First Order Reverse Mode
     forward Any Order Forward Mode
     parallel Using CppAD in a Multi-Threading Environment
     reverse example exp_eps: Second Order Reverse Sweep
     reverse example exp_eps: First Order Reverse Sweep
     second order reverse Second Order Reverse Mode
multi
     dimensional Romberg integration Multi-dimensional Romberg Integration
multi-thread
     memory allocation OpenMP Memory Allocator: Example and Test
     memory allocation Fast Multi-Threading Memory Allocator: Example and Test
multi-threading Using CppAD in a Multi-Threading Environment
     initialize Setup thread_alloc For Use in Multi-Threading Environment
     memory allocation A Quick OpenMP Memory Allocator Used by CppAD
     memory allocation A Fast Multi-Threading Memory Allocator
     TrackCount Routines That Track Use of New and Delete: Multi-Threading
multi_newton
     threading A Multi-Threaded Newton's Method
multi_newton_combine Multi-threading Newton Method Utility Routines
multi_newton_setup Multi-threading Newton Method Utility Routines
multi_newton_time Timing Test of Multi-Threaded Newton Method
multi_newton_work Multi-threading Newton Method Utility Routines
multi_newton_worker Multi-threading Newton Method Utility Routines
multi_thread
     arc_tan example Two Argument Inverse Tangent Function
     harmonic Multi-Threaded Implementation of Summation of 1/i
     Newton AD speed Timing Test of Multi-Threaded Newton Method
     summation speed Timing Test of Multi-Threaded Summation of 1/i
multiple
     AD level Computing a Jacobian With Constants that Change
     AD level Multiple Tapes: Example and Test
     AD level Using Multiple Levels of AD
     Adolc Using Adolc with Multiple Levels of Taping: Example and Test
     assignment AD Computed Assignment Operators: Result
multiply
     AD example AD Binary Multiplication: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
     matrix Define Matrix Multiply as a User Atomic Operation
     matrix speed cppad CppAD Speed: Matrix Multiplication
     matrix speed cppad CppAD Speed: Matrix Multiplication (Double Version)
     matrix speed test Sum Elements of a Matrix Times Itself
     matrix speed test Speed Testing Derivative of Matrix Multiply
N
NDEBUG Routines That Track Use of New and Delete: TrackNewVec
       Frequently Asked Questions and Answers: Speed
       Frequently Asked Questions and Answers: CompareChange
       Definition of a Simple Vector: Exercise
       CppAD Assertions During Execution: NDEBUG
       Optimize an ADFun Object Tape: Checking Optimization
     CompareChange Comparison Changes During Zero Order Forward Mode: Restrictions
NearEqual Determine if Two Values Are Nearly Equal
     AD with Base Compare AD and Base Objects for Nearly Equal
     example NearEqual Function: Example and Test
NearEqualExt
     example Compare AD with Base Objects: Example and Test
NULL
     pointer CppAD API Preprocessor Symbols: Documented Here.CPPAD_NULL
NumericType
     example The NumericType: Example and Test
namespace Frequently Asked Questions and Answers: Namespace
     CppAD cppad-20120207: A Package for Differentiation of C++ Algorithms: Namespace
nan Obtain Nan or Determine if a Value is Nan
     example nan: Example and Test
     macro Obtain Nan or Determine if a Value is Nan: Include.Macros
new
     example Tracking Use of New and Delete: Example and Test
     features The CppAD Wish List
     track Routines That Track Use of New and Delete
newton
     multi-threading A Multi-Threaded Newton's Method
     multi_thread AD speed Timing Test of Multi-Threaded Newton Method
nonlinear
     programming CppAD Nonlinear Programming Using the CppAD Interface to Ipopt
num_threads Setup thread_alloc For Use in Multi-Threading Environment
     thread_alloc Get Number of Threads
numeric
     check Check NumericType Class Concept
     type Definition of a Numeric Type
numerical
     C++ template library The CppAD General Purpose Library
O
ODE
     control error An Error Controller for ODE Solvers
     Rosenbrock A 3rd and 4th Order Rosenbrock ODE Solver
     Runge-Kutta An Embedded 4th and 5th Order Runge-Kutta ODE Solver
     Taylor Taylor's Ode Solver: An Example and Test
     Taylor Adolc Using Adolc with Taylor's Ode Solver: An Example and Test
Ode
     Gear An Arbitrary Order Gear Method
OdeErrControl An Error Controller for ODE Solvers
     example OdeErrControl: Example and Test Using Maxabs Argument
     example OdeErrControl: Example and Test
     maxabs OdeErrControl: Example and Test Using Maxabs Argument
OdeGear An Arbitrary Order Gear Method
     example OdeGear: Example and Test
OdeGearControl An Error Controller for Gear's Ode Solvers
     example OdeGearControl: Example and Test
OpenMP
     compile flags Unix Download, Test and Installation: OpenmpFlags
     example A.1.1c A Simple Parallel Pthread Example and Test
     example A.1.1c A Simple OpenMP Example and Test
Order
     ADFun ADFun Object Deprecated Member Functions: Order
object
     ADFun ADFun Objects
ode
     cppad_ipopt_nlp example source ODE Fitting Using Fast Representation
     cppad_ipopt_nlp example source ODE Fitting Using Simple Representation
     cppad_ipopt_nlp representation ODE Fitting Using Fast Representation
     cppad_ipopt_nlp simple representation ODE Fitting Using Simple Representation
     gradient speed sacado Sacado Speed: Gradient of Ode Solution
     inverse example ODE Inverse Problem Definitions: Source Code
     inverse example An ODE Inverse Problem Example
     jacobian speed cppad CppAD Speed: Gradient of Ode Solution
     speed double Double Speed: Ode Solution
     speed test Speed Testing the Jacobian of Ode Solution
     stiff A Stiff Ode: Example and Test
ode_evaluate
     example ode_evaluate: Example and test
     function Evaluate a Function Defined in Terms of an ODE
     source Source: ode_evaluate
of Glossary: Sparsity Pattern.Vector of Sets
   Glossary: Sparsity Pattern.Vector of Boolean
   Glossary: AD of Base
omp_alloc
     available Amount of Memory Available for Quick Use by a Thread: Deprecated
     create_array Allocate Memory and Create A Raw Array: Deprecated
     delete_array Return A Raw Array to The Available Memory for a Thread: Deprecated
     efficient Check If A Memory Allocation is Efficient for Another Use: Removed
     free_available Free Memory Currently Available for Quick Use by a Thread: Deprecated
     get_thread_num Get At Least A Specified Amount of Memory: Deprecated
     get_thread_num Get the Current OpenMP Thread Number: Deprecated
     in_parallel Is The Current Execution in OpenMP Parallel Mode: Deprecated
     inuse Amount of Memory a Thread is Currently Using: Deprecated
     max_num_threads Set Maximum Number of Threads for omp_alloc Allocator: Removed
     return_memory Return Memory to omp_alloc: Deprecated
omp_max_thread
     depreciated OpenMP Parallel Setup: Deprecated
one
     order Forward First Order Forward Mode: Derivative Values
openmp
     AD team OpenMP Implementation of a Team of AD Threads
     memory allocation OpenMP Memory Allocator: Example and Test
     memory allocation A Quick OpenMP Memory Allocator Used by CppAD
     memory allocation Fast Multi-Threading Memory Allocator: Example and Test
     run tests Run Multi-Threading Examples and Speed Tests: Running Tests.threading
operation Glossary: Operation
     AD Bool valued Bool Valued Operations and Functions with AD Arguments
     AD valued AD Valued Operations and Functions
     equal sequence Check if Two Value are Identically Equal
     optimize sequence ADFun Operation Sequence Optimization: Example and Test
     sequence The CppAD Wish List: Operation Sequence
     sequence abort Abort Recording of an Operation Sequence
     sequence example exp_eps: Operation Sequence and Zero Order Forward Sweep
     sequence example exp_2: Operation Sequence and Zero Order Forward Mode
     sequence store Stop Recording and Store Operation Sequence
     sequence tracing The CppAD Wish List: Tracing
     user atomic User Defined Atomic AD Functions
operations
     optimize sequence Optimize an ADFun Object Tape
operator
     AD arithmetic AD Arithmetic Operators and Computed Assignments
     AD binary compare AD Binary Comparison Operators
     ADFun assignment Construct an ADFun Object and Stop Recording: Assignment Operator
     assignment Frequently Asked Questions and Answers: Assignment and Independent
     assignment AD Computed Assignment Operators
     binary AD Binary Arithmetic Operators
opt_val_hes Jacobian and Hessian of Optimal Values
     example opt_val_hes: Example and Test
optimal value Jacobian and Hessian of Optimal Values
optimize Optimize an ADFun Object Tape
     operation sequence ADFun Operation Sequence Optimization: Example and Test
     tape The CppAD Wish List: Optimization
order
     first exp_2 exp_eps: Verify Second Order Forward Sweep
     first exp_2 exp_eps: Verify First Order Forward Sweep
     first exp_2 exp_2: Verify First Order Forward Sweep
     first expansion exp_eps: First Order Forward Sweep: First Order Expansion
     first expansion exp_2: First Order Forward Mode: First Order Expansion
     first forward exp_eps: First Order Forward Sweep
     first reverse exp_eps: First Order Reverse Sweep
     first reverse exp_2: First Order Reverse Mode
     one Forward First Order Forward Mode: Derivative Values
     second exp_2 exp_2: Verify Second Order Forward Sweep
     second expansion exp_eps: Second Order Forward Mode: Second Order Expansion
     second expansion exp_2: Second Order Forward Mode: Second Order Expansion
     second reverse exp_eps: Second Order Reverse Sweep
     second reverse exp_2: Second Order Reverse Mode
     zero exp_2 exp_2: Verify Zero Order Forward Sweep
     zero exp_eps exp_eps: Verify Zero Order Forward Sweep
     zero expansion exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion
     zero Forward Zero Order Forward Mode: Function Values
     zero forward exp_eps: Operation Sequence and Zero Order Forward Sweep
     zero forward exp_2: Operation Sequence and Zero Order Forward Mode
other
     AD math Other AD Math Functions
output
     AD AD Output Stream Operator
     AD example AD Output Operator: Example and Test
     text Printing AD Values During Forward Mode
P
Parameter Is an AD Object a Parameter or Variable
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties: Parameter
     example AD Parameter and Variable Functions: Example and Test
Poly Evaluate a Polynomial or its Derivative
     source Source: Poly
parallel
     ADFun Construct an ADFun Object and Stop Recording: Parallel Mode
     CheckNumericType Check NumericType Class Concept: Parallel Mode
     CheckSimpleVector Check Simple Vector Concept: Parallel Mode
     Dependent Stop Recording and Store Operation Sequence: Parallel Mode
     discrete Discrete AD Functions: Parallel Mode
     ErrorHandler Replacing the CppAD Error Handler: Constructor.Parallel Mode
     execution Is The Current Execution in Parallel Mode
     Independent Declare Independent Variables and Start Recording: Parallel Mode
     mode Using CppAD in a Multi-Threading Environment
     Rosen34 A 3rd and 4th Order Rosenbrock ODE Solver: Parallel Mode
     Runge45 An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Parallel Mode
     setup Setup thread_alloc For Use in Multi-Threading Environment
     sparsity pattern The CppAD Wish List: Sparsity Patterns
     user_atomic Obtain Nan or Determine if a Value is Nan: Parallel Mode
     user_atomic User Defined Atomic AD Functions: afun.Parallel Mode
parameter Glossary: Parameter
     convert from variable Convert an AD Variable to a Parameter
partial
     easy Reverse Mode Second Partial Derivative Driver
     easy Forward Mode Second Partial Derivative Driver
     easy First Order Partial Derivative: Driver Routine
     example First Order Partial Driver: Example and Test
     first order driver First Order Partial Derivative: Driver Routine
     second Second Partials Reverse Driver: Example and Test
     second Subset of Second Order Partials: Example and Test
     second order driver Reverse Mode Second Partial Derivative Driver
     second order driver Forward Mode Second Partial Derivative Driver
pattern Glossary: Sparsity Pattern
     forward Jacobian Jacobian Sparsity Pattern: Forward Mode
     reverse Hessian Hessian Sparsity Pattern: Reverse Mode
     reverse Jacobian Jacobian Sparsity Pattern: Reverse Mode
     sparsity Glossary: Sparsity Pattern
     sparsity Calculating Sparsity Patterns
     sparsity parallel The CppAD Wish List: Sparsity Patterns
pc
     pkg-config CppAD pkg-config Files
pkg-config
     files CppAD pkg-config Files
plus
     *= example AD Computed Assignment Multiplication: Example and Test
     += example AD Computed Assignment Addition: Example and Test
     -= example AD Computed Assignment Subtraction: Example and Test
     /= example AD Computed Assignment Division: Example and Test
     AD example AD Binary Addition: Example and Test
     AD unary operator AD Unary Plus Operator
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
polynomial Evaluate a Polynomial or its Derivative
     complex Not Complex Differentiable: Example and Test
     complex Complex Polynomial: Example and Test
     example Polynomial Evaluation: Example and Test
     speed adolc Adolc Speed: Second Derivative of a Polynomial
     speed cppad CppAD Speed: Second Derivative of a Polynomial
     speed cppad Double Speed: Evaluate a Polynomial
     speed fadbad Fadbad Speed: Second Derivative of a Polynomial
     speed sacado Sacado Speed: Second Derivative of a Polynomial
     speed test Speed Testing Second Derivative of a Polynomial
postfix
     configure directory Unix Download, Test and Installation: PostfixDir
pow
     AD The AD Power Function
     AD example The AD Power Function: Example and Test
     base require Base Type Requirements for Standard Math Functions: pow
     int The Pow Integer Exponent: Example and Test
     integer The Integer Power Function
prefix
     configure directory Unix Download, Test and Installation: PrefixDir
preprocessor
     CPPAD_ symbol CppAD API Preprocessor Symbols
     symbol CppAD cppad-20120207: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols
     symbols Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol
print
     example forward mode Printing During Forward Mode: Example and Test
     forward mode Printing AD Values During Forward Mode
     forward mode Windows Download and Test: Printing During Forward Mode
     zero order forward Print During Zero Order Forward Mode: Example and Test
problem
     using CppAD Know Bugs and Problems Using CppAD
profile
     cppad speed Unix Download, Test and Installation: Profiling CppAD
program
     speed example Run the Speed Examples
programming
     nonlinear Nonlinear Programming Using the CppAD Interface to Ipopt
     nonlinear example Nonlinear Programming Using CppAD and Ipopt: Example and Test
pthread
     AD team Pthread Implementation of a Team of AD Threads
     memory allocation Fast Multi-Threading Memory Allocator: Example and Test
     run tests Run Multi-Threading Examples and Speed Tests: Running Tests.threading
pthread_exit
     bug in cygwin Pthread Implementation of a Team of AD Threads: Bug in Cygwin
push_back
     CppAD vector The CppAD::vector Template Class: push_back
push_vector
     CppAD The CppAD::vector Template Class: push_vector
Q
quotient
     AD example AD Binary Division: Example and Test
R
Range
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties: Range
RevSparseHes Reverse Mode Hessian Sparsity: Example and Test
             Hessian Sparsity Pattern: Reverse Mode
RevSparseJac Reverse Mode Jacobian Sparsity: Example and Test
             Jacobian Sparsity Pattern: Reverse Mode
Romberg
     example One Dimensional Romberg Integration: Example and Test
     example One Dimensional Romberg Integration: Example and Test
     Integrate One DimensionalRomberg Integration
     multi-dimensional integrate Multi-dimensional Romberg Integration
Rosen34 A 3rd and 4th Order Rosenbrock ODE Solver
     example Rosen34: Example and Test
     parallel A 3rd and 4th Order Rosenbrock ODE Solver: Parallel Mode
Rosenbrock
     ODE A 3rd and 4th Order Rosenbrock ODE Solver
Runge
     ODE An Embedded 4th and 5th Order Runge-Kutta ODE Solver
Runge45 An Embedded 4th and 5th Order Runge-Kutta ODE Solver
     example Runge45: Example and Test
     example Runge45: Example and Test
     parallel An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Parallel Mode
random
     uniform vector Simulate a [0,1] Uniform Random Variate
re-tape
     example CompareChange and Re-Tape: Example and Test
real() Not Complex Differentiable: Example and Test
realistic
     example General Examples
record
     AD index AD Vectors that Record Index Operations
     avoid Frequently Asked Questions and Answers: Independent Variables
     example Convert From AD to its Base Type: Example and Test
recording
     abort Abort Current Recording: Example and Test
     abort Abort Recording of an Operation Sequence
     start Declare Independent Variables and Start Recording
     stop Stop Recording and Store Operation Sequence
     stop tape Construct an ADFun Object and Stop Recording
reference
     VecAD<Base> AD Vectors that Record Index Operations: VecAD<Base>::reference
relative
     difference Determine if Two Values Are Nearly Equal
replace
     error handler Replacing the CppAD Error Handler
representation
     cppad_ipopt_nlp ode ODE Fitting Using Fast Representation
require
     Base type AD<Base> Requirements for Base Type
     base CondExp Base Type Requirements for Conditional Expressions
     base EqualOpSeq Base Type Requirements for Identically Equal Comparisons: EqualOpSeq
     base Integer AD<Base> Requirements for Base Type: Integer
     base identical Base Type Requirements for Identically Equal Comparisons: Identical
     base math Base Type Requirements for Standard Math Functions
     base pow Base Type Requirements for Standard Math Functions: pow
     base sign Base Type Requirements for Standard Math Functions: sign
resize
     vector Definition of a Simple Vector: Resize
retape
     interpolate Interpolation With Retaping: Example and Test
     interpolate Interpolation With Out Retaping: Example and Test
return_memory
     omp_alloc Return Memory to omp_alloc: Deprecated
     thread_alloc Return Memory to thread_alloc
reverse Frequently Asked Questions and Answers: Mode: Forward or Reverse
     acos theory Arccosine Function Reverse Mode Theory
     any order mode Any Order Reverse Mode
     asin theory Arcsine Function Reverse Mode Theory
     atan theory Arctangent Function Reverse Mode Theory
     cos Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     cosh Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     easy driver First and Second Derivatives: Easy Drivers
     exp theory Exponential Function Reverse Mode Theory
     exp_2 exp_2: Verify Second Order Reverse Sweep
     exp_2 exp_2: Verify First Order Reverse Sweep
     exp_eps exp_eps: Verify Second Order Reverse Sweep
     exp_eps exp_eps: Verify First Order Reverse Sweep
     first order First Order Reverse Mode: Example and Test
     first order exp_eps: First Order Reverse Sweep
     first order exp_2: First Order Reverse Mode
     first order mode First Order Reverse Mode
     general example Reverse Mode General Case: Example and Test
     log theory Logarithm Function Reverse Mode Theory
     mode example exp_eps: Second Order Reverse Sweep
     mode example exp_eps: First Order Reverse Sweep
     mode example exp_2: Second Order Reverse Mode
     mode example exp_2: First Order Reverse Mode
     second order Second Order Reverse ModeExample and Test
     second order exp_eps: Second Order Reverse Sweep
     second order exp_2: Second Order Reverse Mode
     second order mode Second Order Reverse Mode
     sin Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     sinh Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     sparse Hessian Hessian Sparsity Pattern: Reverse Mode
     sparse Jacobian Jacobian Sparsity Pattern: Reverse Mode
     sqrt theory Square Root Function Reverse Mode Theory
     tan theory Tangent and Hyperbolic Tangent Reverse Mode Theory
     third order Third Order Reverse Mode: Example and Test
rpm
     cppad.spec Unix Download, Test and Installation: RPM
run
     exp_apx test Correctness Tests For Exponential Approximation in Introduction
S
Sacado
     unix Unix Download, Test and Installation: SacadoDir
Size
     ADFun ADFun Object Deprecated Member Functions: Size
SparseHessian Sparse Hessian: Easy Driver
SparseJacobian Sparse Jacobian: Easy Driver
SpeedTest Run One Speed Test and Print Results
     example Example Use of SpeedTest
sacado
     link_det_lu Sacado Speed: Gradient of Determinant Using Lu Factorization: Implementation
     speed lu Sacado Speed: Gradient of Determinant Using Lu Factorization
     speed minor Sacado Speed: Gradient of Determinant by Minor Expansion
     speed ode gradient Sacado Speed: Gradient of Ode Solution
     speed polynomial Sacado Speed: Second Derivative of a Polynomial
     speed test Speed Test Derivatives Using Sacado
second
     derivative Hessian: Easy Driver
     order exp_2 exp_2: Verify Second Order Forward Sweep
     order expansion exp_eps: Second Order Forward Mode: Second Order Expansion
     order expansion exp_2: Second Order Forward Mode: Second Order Expansion
     order partial driver Reverse Mode Second Partial Derivative Driver
     order partial driver Forward Mode Second Partial Derivative Driver
     order reverse exp_eps: Second Order Reverse Sweep
     order reverse exp_2: Second Order Reverse Mode
     order reverse mode Second Order Reverse Mode
     partial Second Partials Reverse Driver: Example and Test
     partial Subset of Second Order Partials: Example and Test
seconds
     elapsed Elapsed Seconds: Example and Test
     time Returns Elapsed Number of Seconds
sequence Glossary: Operation.Sequence
     ADFun constructor Construct an ADFun Object and Stop Recording: Sequence Constructor
     equal operation Check if Two Value are Identically Equal
     example operation exp_eps: Operation Sequence and Zero Order Forward Sweep
     example operation exp_2: Operation Sequence and Zero Order Forward Mode
     operation The CppAD Wish List: Operation Sequence
     operation abort Abort Recording of an Operation Sequence
     operation store Stop Recording and Store Operation Sequence
     operation tracing The CppAD Wish List: Tracing
     optimize operation ADFun Operation Sequence Optimization: Example and Test
     optimize operations Optimize an ADFun Object Tape
sequential
     execution Is The Current Execution in Parallel Mode
set_max_num_threads
     omp_alloc Set and Get Maximum Number of Threads for omp_alloc Allocator: Deprecated
sets Glossary: Sparsity Pattern.Vector of Sets
setup
     harmonic Multi-threading Sum of 1/i Utility Routines
     multi_newton Multi-threading Newton Method Utility Routines
     parallel Setup thread_alloc For Use in Multi-Threading Environment
     thread_alloc Setup thread_alloc For Use in Multi-Threading Environment
sign
     AD Sign Function
     base require Base Type Requirements for Standard Math Functions: sign
     example Sign Function: Example and Test
simple
     cppad_ipopt_nlp ode representation ODE Fitting Using Simple Representation
     example Getting Started Using CppAD to Compute Derivatives
     multi_thread AD Simple Multi-Threading AD: Example and Test
     vector Definition of a Simple Vector
     vector check Check Simple Vector Concept
     vector example Simple Vector Template Class: Example and Test
sin
     AD AD Standard Math Unary Functions
     AD example The AD sin Function: Example and Test
     forward Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     reverse Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
sinh
     AD AD Standard Math Unary Functions
     AD example The AD sinh Function: Example and Test
     forward Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     reverse Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
size
     vector Definition of a Simple Vector: Size
     vector constructor Definition of a Simple Vector: Sizing Constructor
size_op
     ADFun ADFun Sequence Properties: Example and Test
size_op_arg
     ADFun ADFun Sequence Properties: Example and Test
size_par
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties: size_par
size_VecAD
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties: size_VecAD
size_var
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties: size_var
solve
     Lu factor LU Factorization of A Square Matrix and Stability Calculation
     Lu factor LU Factorization of A Square Matrix
     linear equation Lu Factor and Solve with Recorded Pivoting
     linear equation Compute Determinant and Solve Linear Equations
     ODE A 3rd and 4th Order Rosenbrock ODE Solver
     ODE An Embedded 4th and 5th Order Runge-Kutta ODE Solver
source
     cppad_ipopt_nlp ode example ODE Fitting Using Fast Representation
     cppad_ipopt_nlp ode example ODE Fitting Using Simple Representation
     det_33 Source: det_33
     det_by_lu Source: det_by_lu
     det_by_minor Source: det_by_minor
     det_grad_33 Source: det_grad_33
     det_of_minor Source: det_of_minor
     LuFactor Source: LuFactor
     LuInvert Source: LuInvert
     LuSolve Source: LuSolve
     mat_sum_sq Source: mat_sum_sq
     ode_evaluate Source: ode_evaluate
     Poly Source: Poly
     sparse_evaluate Source: sparse_evaluate
     uniform_01 Source: uniform_01
spare
     Hessian example Sparse Hessian: Example and Test
     Jacobian example Sparse Jacobian: Example and Test
sparse
     Hessian speed adolc Adolc Speed: Sparse Hessian
     Hessian speed cppad CppAD Speed: Sparse Hessian
     hessian speed double Double Speed: Sparse Hessian
     Jacobian speed cppad CppAD Speed: Sparse Jacobian
     jacobian speed double Double Speed: Sparse Jacobian
     reverse Hessian Hessian Sparsity Pattern: Reverse Mode
     reverse Jacobian Jacobian Sparsity Pattern: Reverse Mode
     speed test Speed Testing Sparse Jacobian
     speed test Speed Testing Sparse Hessian
sparse_evaluate
     example sparse_evaluate: Example and test
     function Evaluate a Function That Has a Sparse Hessian
     source Source: sparse_evaluate
sparsity Glossary: Sparsity Pattern
     forward example Forward Mode Jacobian Sparsity: Example and Test
     forward Jacobian Jacobian Sparsity Pattern: Forward Mode
     Hessian Reverse Mode Hessian Sparsity: Example and Test
     pattern Glossary: Sparsity Pattern
     pattern Calculating Sparsity Patterns
     pattern parallel The CppAD Wish List: Sparsity Patterns
     reverse example Reverse Mode Jacobian Sparsity: Example and Test
speed Frequently Asked Questions and Answers: Speed
     adolc lu Adolc Speed: Gradient of Determinant Using Lu Factorization
     adolc minor Adolc Speed: Gradient of Determinant by Minor Expansion
     adolc polynomial Adolc Speed: Second Derivative of a Polynomial
     adolc sparse Hessian Adolc Speed: Sparse Hessian
     avoid taping Frequently Asked Questions and Answers: Independent Variables
     compile AD<double> The CppAD Wish List: Library
     cppad lu CppAD Speed: Gradient of Determinant Using Lu Factorization
     cppad matrix multiply CppAD Speed: Matrix Multiplication
     cppad matrix multiply CppAD Speed: Matrix Multiplication (Double Version)
     cppad minor CppAD Speed: Gradient of Determinant by Minor Expansion
     cppad minor Double Speed: Determinant by Minor Expansion
     cppad ode jacobian CppAD Speed: Gradient of Ode Solution
     cppad polynomial CppAD Speed: Second Derivative of a Polynomial
     cppad polynomial Double Speed: Evaluate a Polynomial
     cppad sparse Hessian CppAD Speed: Sparse Hessian
     cppad sparse Jacobian CppAD Speed: Sparse Jacobian
     cppad test Windows Download and Test: CppAD Speed Test
     double lu Double Speed: Determinant Using Lu Factorization
     double ode Double Speed: Ode Solution
     double sparse hessian Double Speed: Sparse Hessian
     double sparse jacobian Double Speed: Sparse Jacobian
     double test Windows Download and Test: Double Speed Test
     example program Run the Speed Examples
     extend tests The CppAD Wish List: Speed Testing
     fadbad lu Fadbad Speed: Gradient of Determinant Using Lu Factorization
     fadbad minor Fadbad Speed: Gradient of Determinant by Minor Expansion
     fadbad polynomial Fadbad Speed: Second Derivative of a Polynomial
     improve The CppAD Wish List: Multiple Arguments
     matrix multiply test Sum Elements of a Matrix Times Itself
     multi_thread summation Timing Test of Multi-Threaded Summation of 1/i
     optimize Optimize an ADFun Object Tape
     profile cppad Unix Download, Test and Installation: Profiling CppAD
     sacado lu Sacado Speed: Gradient of Determinant Using Lu Factorization
     sacado minor Sacado Speed: Gradient of Determinant by Minor Expansion
     sacado ode gradient Sacado Speed: Gradient of Ode Solution
     sacado polynomial Sacado Speed: Second Derivative of a Polynomial
     test Speed Test Routines
     test adolc Speed Test of Derivatives Using Adolc
     test cppad Speed Test Derivatives Using CppAD
     test cppad Speed Testing Main Program
     test det_lu Speed Testing Gradient of Determinant Using Lu Factorization
     test det_minor Speed Testing Gradient of Determinant by Minor Expansion
     test double Speed Test of Functions in Double
     test fadbad Speed Test Derivatives Using Fadbad
     test matrix multiple Speed Testing Derivative of Matrix Multiply
     test ode Speed Testing the Jacobian of Ode Solution
     test polynomial Speed Testing Second Derivative of a Polynomial
     test sacado Speed Test Derivatives Using Sacado
     test sparse Speed Testing Sparse Jacobian
     test sparse Speed Testing Sparse Hessian
     test windows Speed Test Routines: Windows
     thread_test Run Multi-Threading Examples and Speed Tests
     utility Speed Testing Utilities
     utility example Windows Download and Test: Speed Utility Example
speed_test Run One Speed Test and Return Results
     example speed_test: Example and test
sqrt
     AD AD Standard Math Unary Functions
     AD example The AD sqrt Function: Example and Test
     forward theory Square Root Function Forward Taylor Polynomial Theory
     reverse theory Square Root Function Reverse Mode Theory
standard
     AD math unary AD Standard Math Unary Functions
     math function Frequently Asked Questions and Answers: Namespace.Using
start
     recording Declare Independent Variables and Start Recording
     using CppAD Getting Started Using CppAD to Compute Derivatives
started
     getting Getting Started Using CppAD to Compute Derivatives
std::vector
     unix Unix Download, Test and Installation: --with-stdvector
stiff
     ODE A 3rd and 4th Order Rosenbrock ODE Solver
     Ode An Arbitrary Order Gear Method
     ode A Stiff Ode: Example and Test
storage
     tape Frequently Asked Questions and Answers: Tape Storage: Disk or Memory
stream
     AD output AD Output Stream Operator
subtract
     AD example AD Binary Subtraction: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
subversion
     download Using Subversion To Download Source Code
summation
     multi_thread speed Timing Test of Multi-Threaded Summation of 1/i
symbol
     preprocessor CPPAD_ CppAD API Preprocessor Symbols
     preprocessor CppAD cppad-20120207: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols
symbols
     preprocessor Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol
T
Taylor
     ODE Taylor's Ode Solver: An Example and Test
     ODE Adolc Using Adolc with Taylor's Ode Solver: An Example and Test
TrackCount Routines That Track Use of New and Delete: TrackCount
     multi-threading Routines That Track Use of New and Delete: Multi-Threading
TrackDelVec Routines That Track Use of New and Delete: TrackDelVec
TrackExtend Routines That Track Use of New and Delete: TrackExtend
TrackNewVec Routines That Track Use of New and Delete: TrackNewVec
tan
     AD AD Standard Math Unary Functions
     AD inverse AD Two Argument Inverse Tangent Function
     example The AD tan Function: Example and Test
     forward theory Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory
     reverse theory Tangent and Hyperbolic Tangent Reverse Mode Theory
     user_atomic Tan and Tanh as User Atomic Operations: Example and Test
tanh
     AD AD Standard Math Unary Functions
     example The AD tanh Function: Example and Test
tape Glossary: Tape
     AD index AD Vectors that Record Index Operations
     abort recording Abort Recording of an Operation Sequence
     array index operation Taping Array Index Operation: Example and Test
     avoid Frequently Asked Questions and Answers: Independent Variables
     interpolate Interpolation With Retaping: Example and Test
     interpolate Interpolation With Out Retaping: Example and Test
     memory Unix Download, Test and Installation: TapeAddrType
     optimize The CppAD Wish List: Optimization
     optimize Optimize an ADFun Object Tape
     stop recording Stop Recording and Store Operation Sequence
     stop recording Construct an ADFun Object and Stop Recording
     storage Frequently Asked Questions and Answers: Tape Storage: Disk or Memory
taping
     Value during Convert an AD Variable to a Parameter: Example and Test
tar
     CppAD file Unix Download, Test and Installation: Download.Unix Tar Files
taylor Glossary: Taylor Coefficient
taylor_size
     ADFun ADFun Object Deprecated Member Functions: taylor_size
team
     AD bthread Boost Thread Implementation of a Team of AD Threads
     AD openmp OpenMP Implementation of a Team of AD Threads
     AD pthread Pthread Implementation of a Team of AD Threads
     AD threads Specifications for A Team of AD Threads
template
     CppAD vector class The CppAD::vector Template Class
     numerical C++ library The CppAD General Purpose Library
     polynomial derivative Evaluate a Polynomial or its Derivative
     simple vector class Definition of a Simple Vector
test CppAD Download, Test, and Installation Instructions
     AD acos The AD acos Function: Example and Test
     AD add AD Binary Addition: Example and Test
     AD asin The AD asin Function: Example and Test
     AD assignment AD Assignment Operator: Example and Test
     AD atan The AD atan Function: Example and Test
     AD atan2 The AD atan2 Function: Example and Test
     AD bool AD Boolean Functions: Example and Test
     AD compare AD Binary Comparison Operators: Example and Test
     AD computed assignment add AD Computed Assignment Addition: Example and Test
     AD computed assignment divide AD Computed Assignment Division: Example and Test
     AD computed assignment multiply AD Computed Assignment Multiplication: Example and Test
     AD computed assignment subtract AD Computed Assignment Subtraction: Example and Test
     AD cos The AD cos Function: Example and Test
     AD cosh The AD cosh Function: Example and Test
     AD divide AD Binary Division: Example and Test
     AD exp The AD exp Function: Example and Test
     AD log The AD log Function: Example and Test
     AD log10 The AD log10 Function: Example and Test
     AD multiply AD Binary Multiplication: Example and Test
     AD output AD Output Operator: Example and Test
     AD pow The AD Power Function: Example and Test
     AD sin The AD sin Function: Example and Test
     AD sinh The AD sinh Function: Example and Test
     AD sqrt The AD sqrt Function: Example and Test
     ADFun Creating Your Own Interface to an ADFun Object
     ADFun ADFun Check and Re-Tape: Example and Test
     ADFun default constructor Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     abort Abort Current Recording: Example and Test
     abs AD Absolute Value Function: Example and Test
     adolc speed Speed Test of Derivatives Using Adolc
     BenderQuad BenderQuad: Example and Test
     C AD Example and Test Linking CppAD to Languages Other than C++
     CompareChange CompareChange and Re-Tape: Example and Test
     CondExp Conditional Expressions: Example and Test
     CppAD CppAD Examples and Tests
     CppAD::vector CppAD::vector Template Class: Example and Test
     CppAD::vectorBool CppAD::vectorBool Class: Example and Test
     check NumericType The CheckNumericType Function: Example and Test
     check SimpleVector The CheckSimpleVector Function: Example and Test
     checkpoint Checkpoint and Function Composition: Example and Test
     complex LuSolve With Complex Arguments: Example and Test
     complex polynomial Complex Polynomial: Example and Test
     composition Reverse Mode General Case: Example and Test
     conjugate gradient Differentiate Conjugate Gradient Algorithm: Example and Test
     construct from base AD Constructor From Base Type: Example and Test
     copy AD object AD Copy Constructor: Example and Test
     cppad speed Speed Test Derivatives Using CppAD
     cppad speed Speed Testing Main Program
     cppad speed Windows Download and Test: CppAD Speed Test
     Dependent ADFun Check and Re-Tape: Example and Test
     Domain ADFun Sequence Properties: Example and Test
     default AD construct Default AD Constructor: Example and Test
     delete Tracking Use of New and Delete: Example and Test
     derivative First Order Derivative Driver: Example and Test
     det_lu speed Speed Testing Gradient of Determinant Using Lu Factorization
     det_minor speed Speed Testing Gradient of Determinant by Minor Expansion
     det_of_minor Determinant of a Minor: Example and Test
     determinant by minors Determinant Using Lu Factorization: Example and Test
     determinant by minors Determinant Using Expansion by Minors: Example and Test
     double speed Speed Test of Functions in Double
     double speed Windows Download and Test: Double Speed Test
     EqualOpSeq EqualOpSeq: Example and Test
     epsilon Machine Epsilon: Example and Test
     erf The AD erf Function: Example and Test
     error handler Replacing The CppAD Error Handler: Example and Test
     exception Frequently Asked Questions and Answers: Exceptions
     exp_2 exp_2: Test
     exp_apx main Correctness Tests For Exponential Approximation in Introduction
     exp_eps exp_eps: Test of exp_eps
     Forward Forward Mode: Example and Test
     FunCheck ADFun Check and Re-Tape: Example and Test
     fadbad speed Speed Test Derivatives Using Fadbad
     first order reverse First Order Reverse Mode: Example and Test
     general reverse Reverse Mode General Case: Example and Test
     gradient Gradient of Determinant Using Lu Factorization: Example and Test
     gradient Gradient of Determinant Using Expansion by Minors: Example and Test
     gradient Gradient of Determinant Using LU Factorization: Example and Test
     gradient Gradient of Determinant Using Expansion by Minors: Example and Test
     Hessian Hessian: Example and Test
     Hessian of Lagrangian Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     Independent Independent and ADFun Constructor: Example and Test
     Integer Convert From AD to Integer: Example and Test
     interpreter Example Differentiating a Stack Machine Interpreter
     Jacobian Jacobian: Example and Test
     LU Gradient of Determinant Using LU Factorization: Example and Test
     Lu Gradient of Determinant Using Lu Factorization: Example and Test
     Lu record pivot Lu Factor and Solve With Recorded Pivoting: Example and Test
     LuFactor LuFactor: Example and Test
     LuInvert LuInvert: Example and Test
     LuRatio LuRatio: Example and Test
     LuSolve LuSolve With Complex Arguments: Example and Test
     mat_sum_sq Sum of the Elements of the Square of a Matrix: Example and Test
     matrix multiple speed Speed Testing Derivative of Matrix Multiply
     matrix multiply speed Sum Elements of a Matrix Times Itself
     memory allocation OpenMP Memory Allocator: Example and Test
     memory allocation Fast Multi-Threading Memory Allocator: Example and Test
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     NearEqual NearEqual Function: Example and Test
     NearEqualExt Compare AD with Base Objects: Example and Test
     NumericType The NumericType: Example and Test
     nan nan: Example and Test
     new Tracking Use of New and Delete: Example and Test
     not complex differentiable Not Complex Differentiable: Example and Test
     ODE Taylor's Ode Solver: An Example and Test
     OdeErrControl OdeErrControl: Example and Test Using Maxabs Argument
     OdeErrControl OdeErrControl: Example and Test
     OdeGear OdeGear: Example and Test
     OdeGearControl OdeGearControl: Example and Test
     ode speed Speed Testing the Jacobian of Ode Solution
     ode_evaluate ode_evaluate: Example and test
     opt_val_hes opt_val_hes: Example and Test
     optimize ADFun Operation Sequence Optimization: Example and Test
     Parameter ADFun Sequence Properties: Example and Test
     Parameter AD Parameter and Variable Functions: Example and Test
     partial First Order Partial Driver: Example and Test
     polynomial Polynomial Evaluation: Example and Test
     polynomial speed Speed Testing Second Derivative of a Polynomial
     pow int The Pow Integer Exponent: Example and Test
     Range ADFun Sequence Properties: Example and Test
     Romberg One Dimensional Romberg Integration: Example and Test
     Romberg One Dimensional Romberg Integration: Example and Test
     Rosen34 Rosen34: Example and Test
     Runge45 Runge45: Example and Test
     Runge45 Runge45: Example and Test
     re-tape CompareChange and Re-Tape: Example and Test
     reverse third order Third Order Reverse Mode: Example and Test
     sacado speed Speed Test Derivatives Using Sacado
     second order reverse Second Order Reverse ModeExample and Test
     second partial Second Partials Reverse Driver: Example and Test
     second partial Subset of Second Order Partials: Example and Test
     sign Sign Function: Example and Test
     simple vector Simple Vector Template Class: Example and Test
     size_op ADFun Sequence Properties: Example and Test
     size_op_arg ADFun Sequence Properties: Example and Test
     size_par ADFun Sequence Properties: Example and Test
     size_VecAD ADFun Sequence Properties: Example and Test
     size_var ADFun Sequence Properties: Example and Test
     sparse Hessian Sparse Hessian: Example and Test
     sparse Jacobian Sparse Jacobian: Example and Test
     sparse speed Speed Testing Sparse Jacobian
     sparse speed Speed Testing Sparse Hessian
     sparse_evaluate sparse_evaluate: Example and test
     sparsity forward Forward Mode Jacobian Sparsity: Example and Test
     sparsity Hessian Reverse Mode Hessian Sparsity: Example and Test
     sparsity reverse Reverse Mode Jacobian Sparsity: Example and Test
     speed Speed Test Routines
     speed Determine Amount of Time to Execute a Test
     speed Example Use of SpeedTest
     speed speed_test: Example and test
     speed Run One Speed Test and Print Results
     speed Run One Speed Test and Return Results
     speed windows Speed Test Routines: Windows
     stiff ode A Stiff Ode: Example and Test
     subtract AD Binary Subtraction: Example and Test
     tan The AD tan Function: Example and Test
     tanh The AD tanh Function: Example and Test
     time time_test: Example and test
     time Determine Amount of Time to Execute a Test
     timer Elapsed Seconds: Example and Test
     unary minus AD Unary Minus Operator: Example and Test
     unary plus AD Unary Plus Operator: Example and Test
     user_atomic Define Matrix Multiply as a User Atomic Operation
     user_atomic Tan and Tanh as User Atomic Operations: Example and Test
     Value Convert From AD to its Base Type: Example and Test
     Var2Par Convert an AD Variable to a Parameter: Example and Test
     Variable AD Parameter and Variable Functions: Example and Test
     VecAD AD Vectors that Record Index Operations: Example and Test
     vector Choosing The Vector Testing Template Class
     windows Windows Download and Test: Examples and Testing
test more
     windows Windows Download and Test: More Correctness Testing
testing
     machine epsilon The CppAD Wish List: Numeric Limits
text
     output Printing AD Values During Forward Mode
theory
     acos forward Arccosine Function Forward Taylor Polynomial Theory
     acos reverse Arccosine Function Reverse Mode Theory
     asin forward Arcsine Function Forward Taylor Polynomial Theory
     asin reverse Arcsine Function Reverse Mode Theory
     atan forward Arctangent Function Forward Taylor Polynomial Theory
     atan reverse Arctangent Function Reverse Mode Theory
     cos Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     cos Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     cosh Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     cosh Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     exp forward Exponential Function Forward Taylor Polynomial Theory
     exp reverse Exponential Function Reverse Mode Theory
     log forward Logarithm Function Forward Taylor Polynomial Theory
     log reverse Logarithm Function Reverse Mode Theory
     sin Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     sin Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     sinh Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
     sinh Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     sqrt forward Square Root Function Forward Taylor Polynomial Theory
     sqrt reverse Square Root Function Reverse Mode Theory
     tan forward Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory
     tan reverse Tangent and Hyperbolic Tangent Reverse Mode Theory
thread
     AD team Specifications for A Team of AD Threads
     available memory Amount of Memory Available for Quick Use by a Thread
     available memory Return Memory to thread_alloc
     boost example A Simple Boost Thread Example and Test
     current Get the Current Thread Number
     free memory Free Memory Currently Available for Quick Use by a Thread
     memory inuse Amount of Memory a Thread is Currently Using
     multi example Run Multi-Threading Examples and Speed Tests
     multi harmonic Multi-Threaded Implementation of Summation of 1/i
     multi TrackCount Routines That Track Use of New and Delete: Multi-Threading
     multi_newton A Multi-Threaded Newton's Method
     multi_newton AD speed Timing Test of Multi-Threaded Newton Method
     multiple simple AD Simple Multi-Threading AD: Example and Test
     OpenMP example A Simple Parallel Pthread Example and Test
     OpenMP example A Simple OpenMP Example and Test
thread_alloc
     available Amount of Memory Available for Quick Use by a Thread
     create_array Allocate An Array and Call Default Constructor for its Elements
     delete_array Deallocate An Array and Call Destructor for its Elements
     free_available Free Memory Currently Available for Quick Use by a Thread
     hold memory Control When Thread Alloc Retains Memory For Future Use
     in_parallel Is The Current Execution in Parallel Mode
     inuse Amount of Memory a Thread is Currently Using
     num_threads Get Number of Threads
     return_memory Return Memory to thread_alloc
     setup Setup thread_alloc For Use in Multi-Threading Environment
     thread_num Get At Least A Specified Amount of Memory
     thread_num Get the Current Thread Number
     vector The CppAD::vector Template Class: Memory and Parallel Mode
thread_num Setup thread_alloc For Use in Multi-Threading Environment
     thread_alloc Get At Least A Specified Amount of Memory
     thread_alloc Get the Current Thread Number
thread_test
     example Run Multi-Threading Examples and Speed Tests
     speed Run Multi-Threading Examples and Speed Tests
threads
     maximum number of Using CppAD in a Multi-Threading Environment: CPPAD_MAX_NUM_THREADS
     number of Get Number of Threads
time
     multi_thread summation Timing Test of Multi-Threaded Summation of 1/i
     seconds Returns Elapsed Number of Seconds
time_test Determine Amount of Time to Execute a Test
     example time_test: Example and test
times
     AD example AD Binary Multiplication: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
tracing
     operation sequence The CppAD Wish List: Tracing
track
     new and delete Routines That Track Use of New and Delete
type Glossary: Base Type
     Base require AD<Base> Requirements for Base Type
     numeric Definition of a Numeric Type
U
unary
     AD bool AD Boolean Functions
     AD math AD Standard Math Unary Functions
     AD minus operator AD Unary Minus Operator
     AD plus operator AD Unary Plus Operator
     base math Base Type Requirements for Standard Math Functions: Unary Standard Math
unary minus
     example AD Unary Minus Operator: Example and Test
unary plus
     example AD Unary Plus Operator: Example and Test
uniform
     random vector Simulate a [0,1] Uniform Random Variate
uniform_01 Simulate a [0,1] Uniform Random Variate
           Speed Testing Main Program: seed
     source Source: uniform_01
unix
     CppAD install Unix Download, Test and Installation
     download Unix Download, Test and Installation: Download
use
     memory Amount of Memory a Thread is Currently Using
use_VecAD
     ADFun ADFun Object Deprecated Member Functions: use_VecAD
user
     atomic function User Defined Atomic AD Functions
     atomic tan Tan and Tanh as User Atomic Operations: Example and Test
user_atomic
     example Define Matrix Multiply as a User Atomic Operation
     example Matrix Multiply as a User Atomic Operation: Example and Test
     example Tan and Tanh as User Atomic Operations: Example and Test
     parallel Obtain Nan or Determine if a Value is Nan: Parallel Mode
     parallel User Defined Atomic AD Functions: afun.Parallel Mode
     test Define Matrix Multiply as a User Atomic Operation
     test Matrix Multiply as a User Atomic Operation: Example and Test
using
     namespace Frequently Asked Questions and Answers: Namespace.Using
utility
     speed Speed Testing Utilities
     speed example Windows Download and Test: Speed Utility Example
V
Value Convert From AD to its Base Type: Example and Test
      Convert From an AD Type to its Base Type
     during taping Convert an AD Variable to a Parameter: Example and Test
Var2Par Convert an AD Variable to a Parameter: Example and Test
        Convert an AD Variable to a Parameter
Variable Is an AD Object a Parameter or Variable
     example AD Parameter and Variable Functions: Example and Test
VecAD AD Vectors that Record Index Operations: Example and Test
      AD Vectors that Record Index Operations
     convert to AD AD Copy Constructor and Assignment Operator
     improve assignment The CppAD Wish List: VecAD
VecAD<Base>::reference AD Vectors that Record Index Operations: VecAD<Base>::reference
value Jacobian and Hessian of Optimal Values
     AD absolute AD Absolute Value Function
value_
     obtain during taping Convert an AD Variable to a Parameter
value_type
     vector Definition of a Simple Vector: Value Type
variable Glossary: Variable
         Glossary: Tape.Independent Variable
     convert to parameter Convert an AD Variable to a Parameter
     independent Declare Independent Variables and Start Recording
variables Glossary: Tape.Dependent Variables
vec_ad.cpp AD Vectors that Record Index Operations: Example and Test
vector Glossary: Sparsity Pattern.Vector of Sets
       Glossary: Sparsity Pattern.Vector of Boolean
       Glossary: Elementary Vector
     [] CppAD The CppAD::vector Template Class: Element Access
     AD index AD Vectors that Record Index Operations
     boost Unix Download, Test and Installation: --with-boostvector
     CppAD CppAD::vector Template Class: Example and Test
     CppAD push The CppAD::vector Template Class: push_vector
     CppAD push_back The CppAD::vector Template Class: push_back
     CppAD template class The CppAD::vector Template Class
     simple Simple Vector Template Class: Example and Test
     simple Definition of a Simple Vector
     simple check Check Simple Vector Concept
     std Unix Download, Test and Installation: --with-stdvector
     test Choosing The Vector Testing Template Class
     thread_alloc The CppAD::vector Template Class: Memory and Parallel Mode
     uniform random Simulate a [0,1] Uniform Random Variate
vectorBool The CppAD::vector Template Class: vectorBool
     CppAD CppAD::vectorBool Class: Example and Test
version
     CppAD cppad-20120207: A Package for Differentiation of C++ Algorithms
W
windows
     CppAD install Windows Download and Test
     download Windows Download and Test: Download
     speed test Speed Test Routines: Windows
wish list The CppAD Wish List
worker
     harmonic Multi-threading Sum of 1/i Utility Routines
     multi_newton Multi-threading Newton Method Utility Routines
write
     AD AD Output Stream Operator
Z
zero
     order exp_2 exp_2: Verify Zero Order Forward Sweep
     order exp_eps exp_eps: Verify Zero Order Forward Sweep
     order expansion exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion
     order Forward Zero Order Forward Mode: Function Values
     order forward Comparison Changes During Zero Order Forward Mode
     order forward exp_eps: Operation Sequence and Zero Order Forward Sweep
     order forward exp_2: Operation Sequence and Zero Order Forward Mode
     order forward print Print During Zero Order Forward Mode: Example and Test
zip
     CppAD file Windows Download and Test: Download