Prev Next _index

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
     OpenMP example A Simple Parallel Loop
AD CppAD: 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
     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
     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
     stream output AD Output Stream Operator
     unary minus operator AD Unary Minus Operator
     unary plus operator AD Unary Plus Operator
ADFun
     CompareChange Comparison Changes During Zero Order Forward Mode
     check Check an ADFun Sequence of Operations
     construct Construct an ADFun Object and Stop Recording
     Dependent deprecated ADFun Object Deprecated Member Functions: Dependent
     Domain ADFun Sequence Properties
     evaluate Evaluate ADFun Functions, Derivatives, and Sparsity Patterns
     example ADFun Check and Re-Tape: Example and Test
     Memory deprecated ADFun Object Deprecated Member Functions: Memory
     OpenMP Construct an ADFun Object and Stop Recording: OpenMP
     Order deprecated ADFun Object Deprecated Member Functions: Order
     object ADFun Objects
     operation sequence Stop Recording and Store Operation Sequence
     Parameter ADFun Sequence Properties
     Range ADFun Sequence Properties
     Size deprecated ADFun Object Deprecated Member Functions: Size
     size_var ADFun Sequence Properties
     taylor_size deprecated ADFun Object Deprecated Member Functions: taylor_size
     use_VecAD ADFun Sequence Properties
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
above Glossary: AD Levels Above Base
abs
     AD AD Absolute Value Function
     Base require AD<Base> Requirements for Base Type: abs
     example AD Absolute Value Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
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
     float and double Float and Double Standard Math Unary Functions
     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
     speed lu Adolc Speed: Gradient of Determinant Using Lu Factorization
     speed minor Adolc Speed: Gradient of Determinant Using Expansion by Minors
     speed polynomial Adolc Speed: Second Derivative of a Polynomial
     speed test Speed Test 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 differentiation CppAD: A Package for Differentiation of C++ Algorithms
any
     order reverse mode Any Order Reverse Mode
arithmetic
     AD operator AD Arithmetic Operators and Computed Assignments
array
     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
     float and double Float and Double Standard Math Unary Functions
     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
     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
     float and double Float and Double Standard Math Unary Functions
     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 Other AD Math Functions
     AD example The AD atan2 Function: Example and Test
atomic Glossary: Operation.Atomic
automatic differentiation CppAD: A Package for Differentiation of C++ Algorithms
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 complex Enable use of AD<Base> where Base is std::complex<double>
     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
     convert to AD AD Constructor From Base Type: Example and Test
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
boost
     unix Unix Download, Test and Installation: BoostDir
bug
     gcc 3.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
     interface to Interfacing to C: Example and Test
C++
     algorithm derivative CppAD: A Package for Differentiation of C++ Algorithms
     numerical template library The CppAD General Purpose Library
CheckNumericType The CheckNumericType Function: Example and Test
CheckSimpleVector The CheckSimpleVector Function: Example and Test
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 AD<Base> Requirements for Base Type: CondExp
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_DISCRETE_FUNCTION Discrete AD Functions: Create AD Version
CPPAD_TEST_VECTOR Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol
                  Choosing The Vector Testing Template Class
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 CppAD: A Package for Differentiation of C++ Algorithms
     install windows Windows Download and Test
     namespace CppAD: A Package for Differentiation of C++ Algorithms: Namespace
     OpenMP OpenMP Maximum Thread Number
     preprocessor symbol CppAD: 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.Deprecated
CppADTrackExtend Routines That Track Use of New and Delete: TrackExtend.Deprecated
CppADTrackNewVec Routines That Track Use of New and Delete: TrackNewVec.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
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
     numeric Check NumericType Class Concept
     quadratic Check Sparse Quadratic Function and Derivatives
     simple vector Check Simple Vector Concept
class
     simple vector Definition of a Simple Vector
     template CppAD vector The CppAD::vector Template Class
coefficient Glossary: Taylor Coefficient
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 example Compile and Run the OpenMP Test
     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
compute_det_lu Sacado Speed: Gradient of Determinant Using Lu Factorization: compute_det_lu
               Fadbad Speed: Gradient of Determinant Using Lu Factorization: compute_det_lu
               CppAD Speed: Gradient of Determinant Using Lu Factorization: compute_det_lu
               Adolc Speed: Gradient of Determinant Using Lu Factorization: compute_det_lu
               Double Speed: Determinant Using Lu Factorization: compute_det_lu
compute_det_minor Sacado Speed: Gradient of Determinant Using Expansion by Minors: compute_det_minor
                  Fadbad Speed: Gradient of Determinant Using Expansion by Minors: compute_det_minor
                  CppAD Speed: Gradient of Determinant Using Expansion by Minors: compute_det_minor
                  Adolc Speed: Gradient of Determinant Using Expansion by Minors: compute_det_minor
                  Double Speed: Determinant Using Expansion by Minors: compute_det_minor
compute_poly Sacado Speed: Second Derivative of a Polynomial: compute_poly
             Fadbad Speed: Second Derivative of a Polynomial: compute_poly
             CppAD Speed: Second Derivative of a Polynomial: compute_poly
             Adolc Speed: Second Derivative of a Polynomial: compute_poly
             Double Speed: Evaluate a Polynomial: compute_poly
compute_sparse_hessian CppAD Speed: Sparse Hessian of a Quadratic Function: compute_sparse_hessian
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
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
     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
     numeric constructor Definition of a Numeric Type: Copy Constructor
     vector constructor Definition of a Simple Vector: Copy Constructor
correct
     det_lu Speed Testing Main Program: det_lu
     det_minor Speed Testing Main Program: det_minor
     determinant check Check Gradient of Determinant of 3 by 3 matrix
     determinant check Check Determinant of 3 by 3 matrix
     poly Speed Testing Main Program: poly
     quadratic Check Sparse Quadratic Function and Derivatives
     sparse quadratic Speed Testing Main Program: sparse_hessian
cos
     AD AD Standard Math Unary Functions
     AD example The AD cos Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
     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
     float and double Float and Double Standard Math Unary Functions
     forward Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     reverse Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
cppad
     profile speed Unix Download, Test and Installation: --with-Speed.profile
     speed lu CppAD Speed: Gradient of Determinant Using Lu Factorization
     speed minor CppAD Speed: Gradient of Determinant Using Expansion by Minors
     speed minor Double Speed: Determinant Using Expansion by Minors
     speed polynomial CppAD Speed: Second Derivative of a Polynomial
     speed polynomial Double Speed: Evaluate a Polynomial
     speed sparse Hessian CppAD Speed: Sparse Hessian of a Quadratic Function
     speed test Speed Test Derivatives Using CppAD
     speed test Speed Testing Main Program
     test speed Windows Download and Test: CppAD Speed Test
     test speed Unix Download, Test and Installation: --with-Speed.cppad
cppad.hpp
     include CppAD: A Package for Differentiation of C++ Algorithms: Include File
cppad.spec Unix Download, Test and Installation: RPM
D
Dependent Stop Recording and Store Operation Sequence
     ADFun deprecated ADFun Object Deprecated Member Functions: Dependent
     example ADFun Check and Re-Tape: Example and Test
     OpenMP Construct an ADFun Object and Stop Recording: OpenMP
Domain
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties
default
     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
dependent Glossary: Tape.Dependent Variables
          Glossary: Operation.Dependent
deprecated
     CppADCreateDiscrete Discrete AD Functions: Deprecated
     CppADvector Choosing The Vector Testing Template Class: Deprecated
     Dependent ADFun ADFun Object Deprecated Member Functions: Dependent
     include file Deprecated Include Files
     Memory ADFun ADFun Object Deprecated Member Functions: Memory
     Order ADFun ADFun Object Deprecated Member Functions: Order
     Size ADFun ADFun Object Deprecated Member Functions: Size
     taylor_size ADFun ADFun Object Deprecated Member Functions: taylor_size
derivative
     directional abs AD Absolute Value Function: Directional 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
     correct Speed Testing Main Program: det_lu
     speed Speed Testing Main Program: det_lu
det_minor
     correct Speed Testing Main Program: det_minor
     speed Speed Testing Main Program: det_minor
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 abs AD Absolute Value Function: Directional Derivative
     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
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
     complex Base Enable use of AD<Base> where Base is std::complex<double>
     convert to AD AD Copy Constructor and Assignment Operator
     speed lu Double Speed: Determinant Using Lu Factorization
     speed test Speed Test Functions in Double
     test speed Windows Download and Test: Double Speed Test
     test speed Unix Download, Test and Installation: --with-Speed.double
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 Equal and Correspond to Same Operation Sequence
     Base require AD<Base> Requirements for Base Type: EqualOpSeq
     example EqualOpSeq: Example and Test
ErrorHandler Frequently Asked Questions and Answers: Exceptions
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
     sparsity Glossary: Sparsity Pattern
elementary Glossary: Elementary Vector
equal
     near Determine if Two Values Are Nearly Equal
     operation sequence Check if Equal and Correspond to Same Operation Sequence
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
     AD example The AD erf Function: Example and Test
     AD function The AD Error Function
     Base require AD<Base> Requirements for Base Type: erf
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 erf The AD erf Function: 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
     AD tan The AD tan Function: Example and Test
     ADFun ADFun Check and Re-Tape: Example and Test
     ADFun default constructor Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     abs AD Absolute Value Function: Example and Test
     algorithm An Epsilon Accurate Exponential Approximation
     algorithm Second Order Exponential Approximation
     BenderQuad BenderQuad: Example and Test
     CompareChange CompareChange and Re-Tape: Example and Test
     CondExp Conditional Expressions: Example and Test
     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
     compile OpenMP Compile and Run the OpenMP Test
     complex LuSolve With Complex Arguments: Example and Test
     complex polynomial Complex Polynomial: Example and Test
     construct from base AD Constructor From Base Type: Example and Test
     copy AD object AD Copy Constructor: Example and 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_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
     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
     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
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     multi-thread OpenMP Multi-Threading Newton's Method Source Code
     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
     OpenMP OpenMP Multi-Threading Newton's Method Source Code
     OpenMP A.1.1c A Simple Parallel Loop
     OpenMP Newton's method Multi-Threaded Newton's Method Routine
     OpenMP program Sum of 1/i Main Program
     OpenMP program Multi-Threaded Newton's Method Main Program
     operation sequence exp_eps: Operation Sequence and Zero Order Forward Sweep
     operation sequence exp_2: Operation Sequence and Zero Order Forward Mode
     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
     re-tape CompareChange and Re-Tape: Example and Test
     reverse any order Any Order Reverse Mode: 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
     run all Program That Runs the CppAD Examples
     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
     simple A Simple Program Using CppAD to Compute Derivatives
     simple vector Simple Vector Template Class: Example and Test
     size_var ADFun Sequence Properties: Example and Test
     sparse Hessian Sparse Hessian: 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 Program That Runs the Speed Examples
     speed utility Windows Download and Test: Speed Utility Example
     speed utility Unix Download, Test and Installation: --with-Speed.example
     speed_test speed_test: Example and test
     stiff ode A Stiff Ode: Example and Test
     subtract AD Binary Subtraction: Example and Test
     unary minus AD Unary Minus Operator: Example and Test
     unary plus AD Unary Plus Operator: Example and Test
     unix Unix Download, Test and Installation: --with-Example
     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
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
     float and double Float and Double Standard Math Unary Functions
     forward theory Exponential Function Forward Taylor Polynomial Theory
     reverse theory Exponential Function Reverse Mode Theory
exp_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 Run the exp_2 and exp_eps Tests
     unix Unix Download, Test and Installation: --with-Introduction.exp_apx
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
     speed lu Fadbad Speed: Gradient of Determinant Using Lu Factorization
     speed minor Fadbad Speed: Gradient of Determinant Using Expansion by Minors
     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
first
     derivative Jacobian: Driver Routine
     order derivative driver First Order Derivative: Driver Routine
     order exp_exp_eps: Verify Second Order Forward Sweep
     order exp_exp_eps: Verify First Order Forward Sweep
     order exp_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
     unix compile Unix Download, Test and Installation: CompilerFlags
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
     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
     print Unix Download, Test and Installation: --with-PrintFor
     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
     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
free
     install CppAD Windows Download and Test
     unix install Unix Download, Test and Installation
function Glossary: Base Function
         Glossary: AD Function
     AD Bool valued Bool Valued Operations and Functions with AD Arguments
     AD bool AD Boolean Functions
     AD error The AD Error Function
     AD valued AD Valued Operations and Functions
     discrete AD Discrete AD Functions
     math Frequently Asked Questions and Answers: Math Functions
G
Gear
     Ode An Arbitrary Order Gear Method
GetStarted
     windows Windows Download and Test: Getting Started
GreaterThanZero
     Base require AD<Base> Requirements for Base Type: Ordered
     Base require AD<Base> Requirements for Base Type: Ordered
gcc 3.4.4
     bug Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2
general
     example General Examples
get_started
     unix Unix Download, Test and Installation: --with-Introduction.get_started
getstarted A Simple Program 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
H
HesLagrangian Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
Hessian 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 cppad CppAD Speed: Sparse Hessian of a Quadratic Function
     times direction Hessian Times Direction: Example and Test
handler
     error Replacing The CppAD Error Handler: Example and Test
     error Replacing the CppAD Error Handler
hasnan Obtain Nan and Determine if a Value is Nan
I
Identical
     Base require AD<Base> Requirements for Base Type: Identical
Independent Declare Independent Variables and Start Recording
     example Independent and ADFun Constructor: Example and Test
     OpenMP Declare Independent Variables and Start Recording: OpenMP
Integer Convert From AD to Integer: Example and Test
        Convert From AD to Integer
     Base require AD<Base> Requirements for Base Type: Integer
imag() Not Complex Differentiable: Example and Test
implementation
     exp_exp_2: Implementation
     exp_eps exp_eps: Implementation
inactive Glossary: Tape.Inactive
include
     cppad.hpp CppAD: 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
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 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: A Package for Differentiation of C++ Algorithms: Introduction
     AD An Introduction by Example to Algorithmic Differentiation
     unix Unix Download, Test and Installation: --with-Introduction
     windows Windows Download and Test: Introduction
inverse
     AD tan AD Two Argument Inverse Tangent Function
     matrix Frequently Asked Questions and Answers: Matrix Inverse
isnan Obtain Nan and Determine if a Value is Nan
     macro Obtain Nan and Determine if a Value is Nan: Include.Macros
J
Jacobian Jacobian: Example and Test
     Bender Computing Jacobian and Hessian of Bender's Reduced Objective
     driver Jacobian: Driver Routine
K
Kutta
     ODE An Embedded 4th and 5th Order Runge-Kutta ODE Solver
L
LessThanOrZero
     Base require AD<Base> Requirements for Base Type: Ordered
     Base require AD<Base> Requirements for Base Type: Ordered
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
level
     AD Glossary: AD Levels Above Base
     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
log
     AD AD Standard Math Unary Functions
     AD example The AD log Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
     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
     float and double Float and Double Standard Math Unary Functions
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 deprecated ADFun Object Deprecated Member Functions: Memory
macro
     error assert CppAD Assertions During Execution
     isnan Obtain Nan and Determine if a Value is Nan: Include.Macros
     nan Obtain Nan and Determine if a Value is Nan: Include.Macros
math
     AD other Other AD Math Functions
     AD unary AD Standard Math Unary Functions
     Base require AD<Base> Requirements for Base Type: Standard Math Unary
     functions Frequently Asked Questions and Answers: Math Functions
     standard function Frequently Asked Questions and Answers: Namespace.Using
     unary Float and Double Standard Math Unary Functions
matrix
     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
maxabs
     OdeErrControl OdeErrControl: Example and Test Using Maxabs Argument
memory
     control Controlling Taylor Coefficients Memory Allocation
     tape Frequently Asked Questions and Answers: Tape Storage: Disk or Memory
     track Routines That Track Use of New and Delete
minor
     expansion determinant Determinant Using Expansion by Minors
     matrix determinant Determinant of a Minor
     speed adolc Adolc Speed: Gradient of Determinant Using Expansion by Minors
     speed cppad CppAD Speed: Gradient of Determinant Using Expansion by Minors
     speed cppad Double Speed: Determinant Using Expansion by Minors
     speed fadbad Fadbad Speed: Gradient of Determinant Using Expansion by Minors
     speed sacado Sacado Speed: Gradient of Determinant Using Expansion by Minors
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
     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
     example OpenMP Multi-Threading Newton's Method Source Code
     Newton's method Multi-Threaded Newton's Method Routine
multi_newton
     source OpenMP Multi-Threading Newton's Method Source Code
multiple
     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
     thread OpenMP Maximum Thread Number
multiply
     AD example AD Binary Multiplication: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
N
NDEBUG Frequently Asked Questions and Answers: Speed
       Frequently Asked Questions and Answers: CompareChange
       Routines That Track Use of New and Delete: TrackNewVec
       Definition of a Simple Vector: Exercise
     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
NumericType
     example The NumericType: Example and Test
namespace Frequently Asked Questions and Answers: Namespace
     CppAD CppAD: A Package for Differentiation of C++ Algorithms: Namespace
nan Obtain Nan and Determine if a Value is Nan
     example nan: Example and Test
     macro Obtain Nan and 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
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
     ADFun Construct an ADFun Object and Stop Recording: OpenMP
     CppAD OpenMP Maximum Thread Number
     compile example Compile and Run the OpenMP Test
     Dependent Construct an ADFun Object and Stop Recording: OpenMP
     example OpenMP Multi-Threading Newton's Method Source Code
     example A.1.1c A Simple Parallel Loop
     example program Sum of 1/i Main Program
     example program Multi-Threaded Newton's Method Main Program
     Independent Declare Independent Variables and Start Recording: OpenMP
     Newton's method Multi-Threaded Newton's Method Routine
     TrackCount Routines That Track Use of New and Delete: TrackCount.OpenMP
     TrackNewDel Routines That Track Use of New and Delete: oldptr.OpenMP
Order
     ADFun deprecated ADFun Object Deprecated Member Functions: Order
object
     ADFun ADFun Objects
ode
     stiff A Stiff Ode: Example and Test
of Glossary: AD of Base
omp_max_thread OpenMP Maximum Thread Number
one
     order Forward First Order Forward Mode: Derivative Values
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 Equal and Correspond to Same Operation Sequence
     optimize sequence The CppAD Wish List: Optimization.Remove Dead Code
     sequence The CppAD Wish List: 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
operator
     AD arithmetic AD Arithmetic Operators and Computed Assignments
     AD binary compare AD Binary Comparison Operators
     assignment Frequently Asked Questions and Answers: Assignment and Independent
     assignment AD Computed Assignment Operators
     binary AD Binary Arithmetic Operators
optimize
     operation sequence The CppAD Wish List: Optimization.Remove Dead Code
order
     first exp_exp_eps: Verify Second Order Forward Sweep
     first exp_exp_eps: Verify First Order Forward Sweep
     first exp_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_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_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
P
PACKAGE
     preprocessor symbol Preprocessor Definitions Used by CppAD
Parameter Is an AD Object a Parameter or Variable
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties
     example AD Parameter and Variable Functions: Example and Test
Poly Evaluate a Polynomial or its Derivative
     source Source: Poly
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
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
poly
     correct Speed Testing Main Program: poly
     speed Speed Testing Main Program: poly
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
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 AD<Base> Requirements for Base Type: pow
     int The Pow Integer Exponent: Example and Test
     integer The Integer Power Function
prefix
     configure directory Unix Download, Test and Installation: PrefixDir
preprocessor
     symbol Preprocessor Definitions Used by CppAD
     symbol CppAD CppAD: 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
     forward mode Unix Download, Test and Installation: --with-PrintFor
problem
     using CppAD Know Bugs and Problems Using CppAD
profile
     cppad speed Unix Download, Test and Installation: --with-Speed.profile
program
     OpenMP example Sum of 1/i Main Program
     OpenMP example Multi-Threaded Newton's Method Main Program
     speed example Program That Runs the Speed Examples
push_back
     CppAD vector The CppAD::vector Template Class: push_back
Q
quadratic
     check Check Sparse Quadratic Function and Derivatives
     sparse Speed Testing Main Program: sparse_hessian
quadratic_ok Check Sparse Quadratic Function and Derivatives
     source Source: quadratic_ok
quotient
     AD example AD Binary Division: Example and Test
R
Range
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties
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
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
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
     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
require
     Base type AD<Base> Requirements for Base Type
resize
     vector Definition of a Simple Vector: Resize
retape
     interpolate Interpolation With Retaping: Example and Test
     interpolate Interpolation With Out Retaping: Example and Test
reverse Frequently Asked Questions and Answers: Mode: Forward or Reverse
     acos theory Arccosine Function Reverse Mode Theory
     any order Any Order Reverse Mode: Example and Test
     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_exp_2: Verify Second Order Reverse Sweep
     exp_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
     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
rpm
     cppad.spec Unix Download, Test and Installation: RPM
run
     exp_apx test Run the exp_2 and exp_eps Tests
S
Sacado
     unix Unix Download, Test and Installation: SacadoDir
Size
     ADFun deprecated ADFun Object Deprecated Member Functions: Size
SpeedTest Run One Speed Test and Print Results
     example Example Use of SpeedTest
sacado
     speed lu Sacado Speed: Gradient of Determinant Using Lu Factorization
     speed minor Sacado Speed: Gradient of Determinant Using Expansion by Minors
     speed polynomial Sacado Speed: Second Derivative of a Polynomial
     speed test Speed Test Derivatives Using Sacado
second
     derivative Hessian: Easy Driver
     order exp_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
sequence Glossary: Operation.Sequence
     equal operation Check if Equal and Correspond to Same Operation Sequence
     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 store Stop Recording and Store Operation Sequence
     optimize operations The CppAD Wish List: Optimization.Remove Dead Code
simple
     example A Simple Program Using CppAD to Compute Derivatives
     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
     float and double Float and Double Standard Math Unary Functions
     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
     float and double Float and Double Standard Math Unary Functions
     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_var
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties
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
     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
     multi_newton OpenMP Multi-Threading Newton's Method Source Code
     Poly Source: Poly
     quadratic_ok Source: quadratic_ok
     uniform_01 Source: uniform_01
spare
     Hessian example Sparse Hessian: Example and Test
sparse
     Hessian speed cppad CppAD Speed: Sparse Hessian of a Quadratic Function
     quadratic Speed Testing Main Program: sparse_hessian
     reverse Hessian Hessian Sparsity Pattern: Reverse Mode
     reverse Jacobian Jacobian Sparsity Pattern: Reverse Mode
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
     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 Using Expansion by Minors
     adolc polynomial Adolc Speed: Second Derivative of a Polynomial
     avoid taping Frequently Asked Questions and Answers: Independent Variables
     cppad lu CppAD Speed: Gradient of Determinant Using Lu Factorization
     cppad minor CppAD Speed: Gradient of Determinant Using Expansion by Minors
     cppad minor Double Speed: Determinant Using Expansion by Minors
     cppad polynomial CppAD Speed: Second Derivative of a Polynomial
     cppad polynomial Double Speed: Evaluate a Polynomial
     cppad sparse Hessian CppAD Speed: Sparse Hessian of a Quadratic Function
     cppad test Windows Download and Test: CppAD Speed Test
     cppad test Unix Download, Test and Installation: --with-Speed.cppad
     det_lu Speed Testing Main Program: det_lu
     det_minor Speed Testing Main Program: det_minor
     double lu Double Speed: Determinant Using Lu Factorization
     double test Windows Download and Test: Double Speed Test
     double test Unix Download, Test and Installation: --with-Speed.double
     example program Program That Runs the Speed Examples
     fadbad lu Fadbad Speed: Gradient of Determinant Using Lu Factorization
     fadbad minor Fadbad Speed: Gradient of Determinant Using Expansion by Minors
     fadbad polynomial Fadbad Speed: Second Derivative of a Polynomial
     poly Speed Testing Main Program: poly
     profile cppad Unix Download, Test and Installation: --with-Speed.profile
     sacado lu Sacado Speed: Gradient of Determinant Using Lu Factorization
     sacado minor Sacado Speed: Gradient of Determinant Using Expansion by Minors
     sacado polynomial Sacado Speed: Second Derivative of a Polynomial
     sparse quadratic Speed Testing Main Program: sparse_hessian
     test Speed Test Routines
     test adolc Speed Test Derivatives Using Adolc
     test cppad Speed Test Derivatives Using CppAD
     test cppad Speed Testing Main Program
     test double Speed Test Functions in Double
     test fadbad Speed Test Derivatives Using Fadbad
     test sacado Speed Test Derivatives Using Sacado
     test unix Unix Download, Test and Installation: --with-Speed
     test windows Speed Test Routines: Windows
     utility Speed Testing Utilities
     utility example Windows Download and Test: Speed Utility Example
     utility example Unix Download, Test and Installation: --with-Speed.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
     float and double Float and Double Standard Math Unary Functions
     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
     math unary Float and Double Standard Math Unary Functions
start
     recording Declare Independent Variables and Start Recording
     using CppAD A Simple Program Using CppAD to Compute Derivatives
status
     test return Unix Download, Test and Installation: Testing Return Status
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
symbol
     preprocessor Preprocessor Definitions Used by CppAD
     preprocessor CppAD CppAD: 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
     OpenMP Routines That Track Use of New and Delete: TrackCount.OpenMP
TrackDelVec Routines That Track Use of New and Delete: TrackDelVec
TrackExtend Routines That Track Use of New and Delete: TrackExtend
TrackNewDel
     OpenMP Routines That Track Use of New and Delete: oldptr.OpenMP
TrackNewVec Routines That Track Use of New and Delete: TrackNewVec
tan
     AD AD Standard Math Unary Functions
     AD example The AD tan Function: Example and Test
     AD inverse AD Two Argument Inverse Tangent Function
     float and double Float and Double Standard Math Unary Functions
tanh
     float and double Float and Double Standard Math Unary Functions
tape Glossary: Tape
     AD index AD Vectors that Record Index Operations
     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
     optimize The CppAD Wish List: Optimization.Remove Dead Code
     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 deprecated ADFun Object Deprecated Member Functions: taylor_size
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 erf The AD erf Function: 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
     AD tan The AD tan Function: Example and Test
     ADFun ADFun Check and Re-Tape: Example and Test
     ADFun default constructor Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     abs AD Absolute Value Function: Example and Test
     adolc speed Speed Test Derivatives Using Adolc
     BenderQuad BenderQuad: Example and Test
     CompareChange CompareChange and Re-Tape: Example and Test
     CondExp Conditional Expressions: Example and Test
     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
     complex LuSolve With Complex Arguments: Example and Test
     complex polynomial Complex Polynomial: 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
     cppad speed Unix Download, Test and Installation: --with-Speed.cppad
     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
     double speed Speed Test Functions in Double
     double speed Windows Download and Test: Double Speed Test
     double speed Unix Download, Test and Installation: --with-Speed.double
     EqualOpSeq EqualOpSeq: Example and Test
     error handler Replacing The CppAD Error Handler: Example and Test
     exception Frequently Asked Questions and Answers: Exceptions
     exp_exp_2: Test
     exp_apx main Run the exp_2 and exp_eps Tests
     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
     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
     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
     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
     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
     re-tape CompareChange and Re-Tape: Example and Test
     return status Unix Download, Test and Installation: Testing Return Status
     reverse any order Any 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
     simple vector Simple Vector Template Class: Example and Test
     size_var ADFun Sequence Properties: Example and Test
     sparse Hessian Sparse Hessian: 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 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
     unary minus AD Unary Minus Operator: Example and Test
     unary plus AD Unary Plus Operator: Example and Test
     unix Unix Download, Test and Installation: --with-Example
     unix speed Unix Download, Test and Installation: --with-Speed
     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
     unix Unix Download, Test and Installation: --with-TestMore
     windows Windows Download and Test: More Correctness Testing
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
thread
     multiple OpenMP Maximum Thread Number
times
     AD example AD Binary Multiplication: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
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
     math Float and Double Standard Math Unary Functions
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
     exp_apx Unix Download, Test and Installation: --with-Introduction.exp_apx
     get_started Unix Download, Test and Installation: --with-Introduction.get_started
     introduction Unix Download, Test and Installation: --with-Introduction
     speed test Unix Download, Test and Installation: --with-Speed
     test more Unix Download, Test and Installation: --with-TestMore
use_VecAD
     ADFun ADFun Sequence Properties
using
     namespace Frequently Asked Questions and Answers: Namespace.Using
utility
     speed Speed Testing Utilities
     speed example Windows Download and Test: Speed Utility Example
     speed example Unix Download, Test and Installation: --with-Speed.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
VERSION
     preprocessor symbol Preprocessor Definitions Used by CppAD
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
VecAD<Base>::reference AD Vectors that Record Index Operations: VecAD<Base>::reference
value_
     AD absolute AD Absolute Value Function
     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
vector Glossary: Elementary Vector
     [] CppAD The CppAD::vector Template Class: Element Access
     AD index AD Vectors that Record Index Operations
     CppAD CppAD::vector Template Class: Example and Test
     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
     test Choosing The Vector Testing Template Class
     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: 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
write
     AD AD Output Stream Operator
Z
zero
     order exp_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
zip
     CppAD file Windows Download and Test: Download