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-20100313: 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
     Ipopt Nonlinear Programming Using the CppAD Interface to Ipopt
     introduction An Introduction by Example to Algorithmic Differentiation
     introduction Unix Download, Test and Installation: Introduction.exp_apx
     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
     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
     OpenMP Construct an ADFun Object and Stop Recording: OpenMP
     Order ADFun Object Deprecated Member Functions: Order
     object ADFun Objects
     operation sequence Stop Recording and Store Operation Sequence
     Parameter ADFun Sequence Properties: Parameter
     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
     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
     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 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-20100313: 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
     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
     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
     C differentiation Example and Test Linking CppAD to Languages Other than C++
automatic differentiation cppad-20100313: 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
boolean Glossary: Sparsity Pattern.Vector of Boolean
boost
     unix Unix Download, Test and Installation: BoostDir
bug
     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-20100313: 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_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 cppad-20100313: A Package for Differentiation of C++ Algorithms
     example Unix Download, Test and Installation: CppAD Examples
     install windows Windows Download and Test
     namespace cppad-20100313: A Package for Differentiation of C++ Algorithms: Namespace
     nonlinear programming Nonlinear Programming Using the CppAD Interface to Ipopt
     OpenMP OpenMP Maximum Thread Number
     preprocessor symbol cppad-20100313: 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: TrackCount.Deprecated
                 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
     CppAD speed test Unix Download, Test and Installation: Speed Testing.CppAD Derivative Speed Tests
     determinant correct Check Gradient of Determinant of 3 by 3 matrix
     determinant correct Check Determinant of 3 by 3 matrix
     function speed test Unix Download, Test and Installation: Speed Testing.Function Speed Tests
     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
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
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
config.h Preprocessor Definitions Used by CppAD: config.h
configure Unix Download, Test and Installation: Configure
     postfix directory Unix Download, Test and Installation: PostfixDir
     prefix directory Unix Download, Test and Installation: PrefixDir
     symbol Preprocessor Definitions Used by CppAD
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
     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
     link_det_lu CppAD Speed: Gradient of Determinant Using Lu Factorization: Implementation
     profile speed Unix Download, Test and Installation: Profiling CppAD
     speed lu CppAD Speed: Gradient of Determinant Using Lu Factorization
     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-20100313: A Package for Differentiation of C++ Algorithms: Include File
cppad.spec Unix Download, Test and Installation: RPM
cppad_ipopt_nlp
     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
D
Dependent Stop Recording and Store Operation Sequence
     ADFun 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: 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
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
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
     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 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
     link_det_lu Double Speed: Determinant Using Lu Factorization: Implementation
     speed lu Double Speed: Determinant Using Lu Factorization: Specifications
     speed ode Double Speed: Ode Solution
     speed sparse hessian Double Speed: Sparse Hessian
     speed sparse jacobian Double Speed: Sparse Jacobian
     speed test Speed Test 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 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
elapsed
     seconds Elapsed Seconds: Example and Test
elapsed_seconds Returns Elapsed Number of Seconds
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 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
     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 Unix Download, Test and Installation: CppAD Examples
     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
     compile OpenMP Compile and Run the OpenMP Test
     complex LuSolve With Complex Arguments: Example and Test
     complex polynomial Complex Polynomial: Example and Test
     composition Reverse Mode General Case: 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
     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
     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
     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 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
     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
     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_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 Program That Runs the Speed Examples
     speed utility Windows Download and Test: Speed Utility Example
     speed utility Unix Download, Test and Installation: Speed Testing.Examples For Speed Tests
     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
     timer Elapsed Seconds: Example and Test
     unary minus AD Unary Minus Operator: Example and Test
     unary plus AD Unary Plus Operator: 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
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_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 Run the exp_2 and exp_eps Tests
     run Unix Download, Test and Installation: 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
     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
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
     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
     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
     print Unix Download, Test and Installation: 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 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
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
     reverse example Reverse Mode General Case: Example and Test
get_started
     run Unix Download, Test and Installation: Introduction.Getting 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
     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
hasnan Obtain Nan and Determine if a Value is Nan
hessian
     sparse Sparse Hessian: Easy Driver
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
Ipopt
     AD Nonlinear Programming Using the CppAD Interface to Ipopt
     unix Unix Download, Test and Installation: IpoptDir
imag() Not Complex Differentiable: Example and Test
implementation
     exp_2 exp_2: Implementation
     exp_eps exp_eps: Implementation
inactive Glossary: Tape.Inactive
include
     cppad.hpp cppad-20100313: 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 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-20100313: A Package for Differentiation of C++ Algorithms: Introduction
     AD An Introduction by Example to Algorithmic Differentiation
     AD Unix Download, Test and Installation: Introduction.exp_apx
     windows Windows Download and Test: Introduction
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 and Determine if a Value is Nan
     macro Obtain Nan and 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
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
language
     link CppAD Example and Test Linking CppAD to Languages Other than C++
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
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_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
     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: Specifications
     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
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
     optimize Optimize the Tape Corresponding to an ADFun object
     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 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
     reverse example exp_eps: Second Order Reverse Sweep
     reverse example exp_eps: First Order Reverse Sweep
     second order reverse Second Order Reverse Mode
more
     testing Unix Download, Test and Installation: More Testing
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
       Optimize the Tape Corresponding to an ADFun object: 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
NumericType
     example The NumericType: Example and Test
namespace Frequently Asked Questions and Answers: Namespace
     CppAD cppad-20100313: 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
nonlinear
     programming CppAD Nonlinear Programming Using the CppAD Interface to Ipopt
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 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_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 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
operations
     optimize sequence Optimize the Tape Corresponding to an ADFun object
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 the Tape Corresponding to an ADFun object
     operation sequence ADFun Operation Sequence Optimization: Example and Test
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
PACKAGE
     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: Parameter
     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
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 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: Preprocessor Symbols
     symbol CppAD cppad-20100313: 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: PrintFor
problem
     using CppAD Know Bugs and Problems Using CppAD
profile
     cppad speed Unix Download, Test and Installation: Profiling CppAD
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
programming
     nonlinear Nonlinear Programming Using the CppAD Interface to Ipopt
     nonlinear example Nonlinear Programming Using CppAD and Ipopt: Example and Test
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
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
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
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 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
     third order Third Order Reverse Mode: Example and Test
rpm
     cppad.spec Unix Download, Test and Installation: RPM
run
     exp_apx Unix Download, Test and Installation: Introduction.exp_apx
     exp_apx test Run the exp_2 and exp_eps Tests
     get_started Unix Download, Test and Installation: Introduction.Getting Started
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 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 abort Abort Recording of an Operation Sequence
     operation store Stop Recording and Store Operation Sequence
     optimize operation ADFun Operation Sequence Optimization: Example and Test
     optimize operations Optimize the Tape Corresponding to an ADFun object
sets Glossary: Sparsity Pattern.Vector of Sets
simple
     cppad_ipopt_nlp ode representation ODE Fitting Using Simple Representation
     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_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
     multi_newton OpenMP Multi-Threading Newton's Method Source Code
     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
     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
     CppAD check test Unix Download, Test and Installation: Speed Testing.CppAD Derivative Speed Tests
     cppad lu CppAD Speed: Gradient of Determinant Using Lu Factorization
     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: Specifications
     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 Program That Runs the Speed Examples
     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
     function check test Unix Download, Test and Installation: Speed Testing.Function Speed Tests
     optimize Optimize the Tape Corresponding to an ADFun object
     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 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 Functions in Double
     test fadbad Speed Test Derivatives Using Fadbad
     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
     utility Speed Testing Utilities
     utility example Windows Download and Test: Speed Utility Example
     utility example Unix Download, Test and Installation: Speed Testing.Examples For Speed Tests
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
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
     configure Preprocessor Definitions Used by CppAD
     preprocessor CppAD cppad-20100313: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols
     processor Preprocessor Definitions Used by CppAD: 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 inverse AD Two Argument Inverse Tangent Function
     example The AD tan Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
tanh
     AD AD Standard Math Unary Functions
     example The AD tanh Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
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
     optimize Optimize the Tape Corresponding to an ADFun object
     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
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 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::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
     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 Functions in Double
     double speed Windows Download and Test: Double Speed Test
     EqualOpSeq EqualOpSeq: 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 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
     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
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     minors expansion Gradient of Determinant Using Expansion by Minors: Example and Test
     more Unix Download, Test and Installation: More Testing
     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
     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 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
     timer Elapsed Seconds: Example and Test
     unary minus AD Unary Minus Operator: Example and Test
     unary plus AD Unary Plus Operator: 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
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
thread
     multiple OpenMP Maximum Thread Number
time
     seconds Returns Elapsed Number of Seconds
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
use_VecAD
     ADFun ADFun Object Deprecated Member Functions: use_VecAD
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: Speed Testing.Examples For Speed Tests
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
     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 Jacobian and Hessian of Optimal Values
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
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
     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
     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-20100313: 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_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
zip
     CppAD file Windows Download and Test: Download