Index-> contents reference index search external

Up-> CppAD _index

Prev

Next

CppAD-> Install Introduction AD ADFun library preprocessor Example Appendix

_index

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

Keyword Index !=
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
*
     AD example AD Binary Multiplication: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
*=
     AD example AD Computed Assignment Multiplication: Example and Test
+
     AD example AD Binary Addition: Example and Test
     AD unary operator AD Unary Plus Operator
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
+=
     AD example AD Computed Assignment Addition: Example and Test
-
     AD example AD Binary Subtraction: Example and Test
     AD unary operator AD Unary Minus Operator
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
-=
     AD example AD Computed Assignment Subtraction: Example and Test
/
     AD example AD Binary Division: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
/=
     AD example AD Computed Assignment Division: Example and Test
<
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
<<
     AD example AD Output Operator: Example and Test
     AD output AD Output Stream Operator
<=
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
==
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
>
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
>=
     AD operator AD Binary Comparison Operators
     example AD Binary Comparison Operators: Example and Test
[]
     CppAD vector The CppAD::vector Template Class: Element Access
     vector Definition of a Simple Vector: Element Access
A
A.1.1c
     OpenMP example A Simple Parallel Loop
AD cppad-20081006: A Package for Differentiation of C++ Algorithms
     arithmetic operator AD Arithmetic Operators and Computed Assignments
     assignment AD Copy Constructor and Assignment Operator
     binary compare operator AD Binary Comparison Operators
     computed assignment AD Arithmetic Operators and Computed Assignments
     convert from Conversion and Printing of AD Objects
     convert to Base Convert From an AD Type to its Base Type
     convert to integer Convert From AD to Integer
     copy AD Copy Constructor and Assignment Operator
     default construct Default AD Constructor: Example and Test
     default construct AD Default Constructor
     introduction An Introduction by Example to Algorithmic Differentiation
     level Glossary: AD Levels Above Base
     multiple level Multiple Tapes: Example and Test
     multiple level Using Multiple Levels of AD
     nonlinear programming Nonlinear Programming Using Ipopt and CppAD
     object AD Objects
     stream output AD Output Stream Operator
     unary minus operator AD Unary Minus Operator
     unary plus operator AD Unary Plus Operator
ADFun
     CompareChange Comparison Changes During Zero Order Forward Mode
     check Check an ADFun Sequence of Operations
     construct Construct an ADFun Object and Stop Recording
     Dependent deprecated ADFun Object Deprecated Member Functions: Dependent
     Domain ADFun Sequence Properties
     evaluate Evaluate ADFun Functions, Derivatives, and Sparsity Patterns
     example ADFun Check and Re-Tape: Example and Test
     Memory deprecated ADFun Object Deprecated Member Functions: Memory
     OpenMP Construct an ADFun Object and Stop Recording: OpenMP
     Order deprecated ADFun Object Deprecated Member Functions: Order
     object ADFun Objects
     operation sequence Stop Recording and Store Operation Sequence
     Parameter ADFun Sequence Properties
     Range ADFun Sequence Properties
     Size deprecated ADFun Object Deprecated Member Functions: Size
     size_var ADFun Sequence Properties
     taylor_size deprecated ADFun Object Deprecated Member Functions: taylor_size
     use_VecAD ADFun Sequence Properties
Adolc
     adouble as Base Enable use of AD<Base> where Base is Adolc's adouble Type
     multiple level Using Adolc with Multiple Levels of Taping: Example and Test
     ODE Using Adolc with Taylor's Ode Solver: An Example and Test
     unix Unix Download, Test and Installation: AdolcDir
Algorithmic Differentiation
     introduction An Introduction by Example to Algorithmic Differentiation
Automatic Differentiation
     introduction An Introduction by Example to Algorithmic Differentiation
above Glossary: AD Levels Above Base
abs
     AD AD Absolute Value Function
     Base require AD<Base> Requirements for Base Type: abs
     example AD Absolute Value Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
absolute
     AD value AD Absolute Value Function
     difference Determine if Two Values Are Nearly Equal
aclocal Changes and Additions to CppAD During 2006: 01-08
acos
     AD AD Standard Math Unary Functions
     AD example The AD acos Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
     forward theory Arccosine Function Forward Taylor Polynomial Theory
     reverse theory Arccosine Function Reverse Mode Theory
active Glossary: Tape.Active
ad Glossary: AD Levels Above Base
   Glossary: AD of Base
   Glossary: AD Function
add
     *= example AD Computed Assignment Multiplication: Example and Test
     += example AD Computed Assignment Addition: Example and Test
     -= example AD Computed Assignment Subtraction: Example and Test
     /= example AD Computed Assignment Division: Example and Test
     AD example AD Binary Addition: Example and Test
     binary operator AD Binary Arithmetic Operators
     computed assignment AD Computed Assignment Operators
adolc
     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 differentiation cppad-20081006: A Package for Differentiation of C++ Algorithms
any
     order reverse mode Any Order Reverse Mode
arithmetic
     AD operator AD Arithmetic Operators and Computed Assignments
array
     tape index operation Taping Array Index Operation: Example and Test
asin
     AD AD Standard Math Unary Functions
     AD example The AD asin Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
     forward theory Arcsine Function Forward Taylor Polynomial Theory
     reverse theory Arcsine Function Reverse Mode Theory
assert
     error handler Replacing the CppAD Error Handler
     error macro CppAD Assertions During Execution
assign
     *= example AD Computed Assignment Multiplication: Example and Test
     += example AD Computed Assignment Addition: Example and Test
     -= example AD Computed Assignment Subtraction: Example and Test
     /= example AD Computed Assignment Division: Example and Test
     conditional AD Conditional Expressions
assignment
     AD AD Assignment Operator: Example and Test
     AD AD Copy Constructor and Assignment Operator
     AD computed AD Arithmetic Operators and Computed Assignments
     AD computed add example AD Computed Assignment Addition: Example and Test
     AD computed divide example AD Computed Assignment Division: Example and Test
     AD computed multiply example AD Computed Assignment Multiplication: Example and Test
     AD computed subtract example AD Computed Assignment Subtraction: Example and Test
     CppAD vector The CppAD::vector Template Class: Assignment
     multiple AD Computed Assignment Operators: Result
     operator Frequently Asked Questions and Answers: Assignment and Independent
     operator AD Computed Assignment Operators
     vector Definition of a Simple Vector: Assignment
atan
     AD AD Standard Math Unary Functions
     AD example The AD atan Function: Example and Test
     float and double Float and Double Standard Math Unary Functions
     forward theory Arctangent Function Forward Taylor Polynomial Theory
     reverse theory Arctangent Function Reverse Mode Theory
atan2 The CppAD Wish List: Atan2
     AD AD Two Argument Inverse Tangent Function
     AD Other AD Math Functions
     AD example The AD atan2 Function: Example and Test
atomic Glossary: Operation.Atomic
automatic differentiation cppad-20081006: A Package for Differentiation of C++ Algorithms
B
Base
     Adolc's adouble Enable use of AD<Base> where Base is Adolc's adouble Type
     convert to AD AD Copy Constructor and Assignment Operator
     double complex Enable use of AD<Base> where Base is std::complex<double>
     from AD Convert From an AD Type to its Base Type
     require AD<Base> Requirements for Base Type
     require AD Objects: Base Type Requirements
BenderQuad Computing Jacobian and Hessian of Bender's Reduced Objective
     example BenderQuad: Example and Test
base Glossary: Base Type
     Glossary: Base Function
     Glossary: AD Levels Above Base
     Glossary: AD of Base
     convert to AD AD Constructor From Base Type: Example and Test
binary
     AD bool AD Boolean Functions
     AD compare operator AD Binary Comparison Operators
     operator AD Binary Arithmetic Operators
bool
     AD function AD Boolean Functions
     CppAD::vector CppAD::vectorBool Class: Example and Test
boost
     unix Unix Download, Test and Installation: BoostDir
bug
     gcc 3.4.4 Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2
bugs
     reporting Frequently Asked Questions and Answers: Bugs
     using CppAD Know Bugs and Problems Using CppAD
C
C
     interface to Interfacing to C: Example and Test
C++
     algorithm derivative cppad-20081006: 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-20081006: A Package for Differentiation of C++ Algorithms
     install windows Windows Download and Test
     namespace cppad-20081006: A Package for Differentiation of C++ Algorithms: Namespace
     nonlinear programming Nonlinear Programming Using Ipopt and CppAD
     OpenMP OpenMP Maximum Thread Number
     preprocessor symbol cppad-20081006: 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
     determinant correct Check Gradient of Determinant of 3 by 3 matrix
     determinant correct Check Determinant of 3 by 3 matrix
     numeric Check NumericType Class Concept
     simple vector Check Simple Vector Concept
class
     simple vector Definition of a Simple Vector
     template CppAD vector The CppAD::vector Template Class
coefficient Glossary: Taylor Coefficient
compare
     AD binary operator AD Binary Comparison Operators
     AD example AD Binary Comparison Operators: Example and Test
     change CompareChange and Re-Tape: Example and Test
compile
     OpenMP example Compile and Run the OpenMP Test
     unix flags Unix Download, Test and Installation: CompilerFlags
complex
     double Base Enable use of AD<Base> where Base is std::complex<double>
     faq Frequently Asked Questions and Answers: Complex Types
     LuSolve LuSolve With Complex Arguments: Example and Test
     polynomial Not Complex Differentiable: Example and Test
     polynomial Complex Polynomial: Example and Test
computed
     *= example AD Computed Assignment Multiplication: Example and Test
     += example AD Computed Assignment Addition: Example and Test
     -= example AD Computed Assignment Subtraction: Example and Test
     /= example AD Computed Assignment Division: Example and Test
     AD assignment AD Arithmetic Operators and Computed Assignments
     AD assignment add example AD Computed Assignment Addition: Example and Test
     AD assignment divide example AD Computed Assignment Division: Example and Test
     AD assignment multiply example AD Computed Assignment Multiplication: Example and Test
     AD assignment subtract example AD Computed Assignment Subtraction: Example and Test
concept
     C++ The CppAD General Purpose Library: C++ Concepts
     check numeric Check NumericType Class Concept
     check simple vector Check Simple Vector Concept
conditional
     expression AD Conditional Expressions
configure Unix Download, Test and Installation: Configure
     postfix directory Unix Download, Test and Installation: PostfixDir
     prefix directory Unix Download, Test and Installation: PrefixDir
construct
     , AD default Default AD Constructor: Example and Test
     ADFun Construct an ADFun Object and Stop Recording
     default AD Default Constructor
     from base type AD Constructor From Base Type: Example and Test
constructor
     AD AD Copy Constructor and Assignment Operator
     copy vector Definition of a Simple Vector: Copy Constructor
     element Definition of a Simple Vector: Element Constructor and Destructor
     numeric Definition of a Numeric Type: Constructor From Integer
     numeric Definition of a Numeric Type: Default Constructor
     numeric copy Definition of a Numeric Type: Copy Constructor
     size vector Definition of a Simple Vector: Sizing Constructor
     vector default Definition of a Simple Vector: Default Constructor
control
     ODE error An Error Controller for ODE Solvers
     Ode Gear An Error Controller for Gear's Ode Solvers
convert
     AD to Base Convert From an AD Type to its Base Type
     AD to integer Convert From AD to Integer
     from AD Conversion and Printing of AD Objects
     to AD AD Copy Constructor and Assignment Operator
copy
     AD object AD Copy Constructor: Example and Test
     numeric constructor Definition of a Numeric Type: Copy Constructor
     vector constructor Definition of a Simple Vector: Copy Constructor
correct
     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: --with-Speed.profile
     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 gradient 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 test Speed Test Derivatives Using CppAD
     speed test Speed Testing Main Program
     test speed Windows Download and Test: CppAD Speed Test
     test speed Unix Download, Test and Installation: --with-Speed.cppad
cppad.hpp
     include cppad-20081006: A Package for Differentiation of C++ Algorithms: Include File
cppad.spec Unix Download, Test and Installation: RPM
D
Dependent Stop Recording and Store Operation Sequence
     ADFun deprecated ADFun Object Deprecated Member Functions: Dependent
     example ADFun Check and Re-Tape: Example and Test
     OpenMP Construct an ADFun Object and Stop Recording: OpenMP
Domain
     ADFun ADFun Sequence Properties: Example and Test
     ADFun ADFun Sequence Properties
default
     constructor AD Default Constructor
     numeric constructor Definition of a Numeric Type: Default Constructor
     vector constructor Definition of a Simple Vector: Default Constructor
delete
     example Tracking Use of New and Delete: Example and Test
     track Routines That Track Use of New and Delete
dependent Glossary: Tape.Dependent Variables
          Glossary: Operation.Dependent
deprecated
     CppADCreateDiscrete Discrete AD Functions: Deprecated
     CppADvector Choosing The Vector Testing Template Class: Deprecated
     Dependent ADFun ADFun Object Deprecated Member Functions: Dependent
     include file Deprecated Include Files
     Memory ADFun ADFun Object Deprecated Member Functions: Memory
     Order ADFun ADFun Object Deprecated Member Functions: Order
     Size ADFun ADFun Object Deprecated Member Functions: Size
     taylor_size ADFun ADFun Object Deprecated Member Functions: taylor_size
derivative
     directional abs AD Absolute Value Function: Directional Derivative
     directional example AD Absolute Value Function: Example and Test
     easy First Order Derivative: Driver Routine
     example First Order Derivative Driver: Example and Test
     first order driver First Order Derivative: Driver Routine
     forward mode Any Order Forward Mode
     polynomial template Evaluate a Polynomial or its Derivative
     reverse mode Any Order Reverse Mode
     reverse mode Second Order Reverse Mode
     reverse mode First Order Reverse Mode
destructor
     element Definition of a Simple Vector: Element Constructor and Destructor
det_33 Check Determinant of 3 by 3 matrix
     source Source: det_33
det_by_lu Determinant Using Expansion by Lu Factorization
     source Source: det_by_lu
det_by_minor
     source Source: det_by_minor
det_grad_33 Check Gradient of Determinant of 3 by 3 matrix
     source Source: det_grad_33
det_lu
     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 test Speed Test Functions in Double
     test speed Windows Download and Test: Double Speed Test
     test speed Unix Download, Test and Installation: --with-Speed.double
download
     subversion Using Subversion To Download Source Code
     unix Unix Download, Test and Installation: Download
     windows Windows Download and Test: Download
driver
     easy First and Second Derivatives: Easy Drivers
     easy derivative First Order Derivative: Driver Routine
     easy partial Reverse Mode Second Partial Derivative Driver
     easy partial Forward Mode Second Partial Derivative Driver
     easy partial First Order Partial Derivative: Driver Routine
     first order derivative First Order Derivative: Driver Routine
     first order partial First Order Partial Derivative: Driver Routine
     Hessian Hessian: Easy Driver
     Jacobian Jacobian: Driver Routine
     second order partial Reverse Mode Second Partial Derivative Driver
     second order partial Forward Mode Second Partial Derivative Driver
E
EqualOpSeq Check if Equal and Correspond to Same Operation Sequence
     Base require AD<Base> Requirements for Base Type: EqualOpSeq
     example EqualOpSeq: Example and Test
ErrorHandler Frequently Asked Questions and Answers: Exceptions
easy
     derivative First Order Derivative: Driver Routine
     driver First and Second Derivatives: Easy Drivers
     partial Reverse Mode Second Partial Derivative Driver
     partial Forward Mode Second Partial Derivative Driver
     partial First Order Partial Derivative: Driver Routine
efficient
     sparsity Glossary: Sparsity Pattern
elementary Glossary: Elementary Vector
equal
     near Determine if Two Values Are Nearly Equal
     operation sequence Check if Equal and Correspond to Same Operation Sequence
equation
     differential An Arbitrary Order Gear Method
     differential A 3rd and 4th Order Rosenbrock ODE Solver
     differential An Embedded 4th and 5th Order Runge-Kutta ODE Solver
     Lu factor LU Factorization of A Square Matrix and Stability Calculation
     Lu factor LU Factorization of A Square Matrix
     Lu invert Invert an LU Factored Equation
     linear Compute Determinant and Solve Linear Equations
     linear Compute Determinants and Solve Equations by LU Factorization
     ODE error control An Error Controller for ODE Solvers
     Ode Gear control An Error Controller for Gear's Ode Solvers
     solve linear Lu Factor and Solve with Recorded Pivoting
erf
     AD example The AD erf Function: Example and Test
     AD function The AD Error Function
     Base require AD<Base> Requirements for Base Type: erf
error
     AD function The AD Error Function
     assert macro CppAD Assertions During Execution
     control ODE An Error Controller for ODE Solvers
     Gear Ode An Error Controller for Gear's Ode Solvers
     handler Replacing The CppAD Error Handler: Example and Test
     handler Replacing the CppAD Error Handler
evaluate
     ADFun Evaluate ADFun Functions, Derivatives, and Sparsity Patterns
example Examples
     AD acos The AD acos Function: Example and Test
     AD add AD Binary Addition: Example and Test
     AD asin The AD asin Function: Example and Test
     AD assignment AD Assignment Operator: Example and Test
     AD atan The AD atan Function: Example and Test
     AD atan2 The AD atan2 Function: Example and Test
     AD bool AD Boolean Functions: Example and Test
     AD compare AD Binary Comparison Operators: Example and Test
     AD computed assignment add AD Computed Assignment Addition: Example and Test
     AD computed assignment divide AD Computed Assignment Division: Example and Test
     AD computed assignment multiply AD Computed Assignment Multiplication: Example and Test
     AD computed assignment subtract AD Computed Assignment Subtraction: Example and Test
     AD cos The AD cos Function: Example and Test
     AD cosh The AD cosh Function: Example and Test
     AD divide AD Binary Division: Example and Test
     AD erf The AD erf Function: Example and Test
     AD exp The AD exp Function: Example and Test
     AD log The AD log Function: Example and Test
     AD log10 The AD log10 Function: Example and Test
     AD multiply AD Binary Multiplication: Example and Test
     AD output AD Output Operator: Example and Test
     AD pow The AD Power Function: Example and Test
     AD sin The AD sin Function: Example and Test
     AD sinh The AD sinh Function: Example and Test
     AD sqrt The AD sqrt Function: Example and Test
     AD tan The AD tan Function: Example and Test
     ADFun ADFun Check and Re-Tape: Example and Test
     ADFun default constructor Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     abs AD Absolute Value Function: Example and Test
     algorithm An Epsilon Accurate Exponential Approximation
     algorithm Second Order Exponential Approximation
     BenderQuad BenderQuad: Example and Test
     CompareChange CompareChange and Re-Tape: Example and Test
     CondExp Conditional Expressions: Example and Test
     CppAD::vector CppAD::vector Template Class: Example and Test
     CppAD::vectorBool CppAD::vectorBool Class: Example and Test
     check NumericType The CheckNumericType Function: Example and Test
     check SimpleVector The CheckSimpleVector Function: Example and Test
     compile OpenMP Compile and Run the OpenMP Test
     complex LuSolve With Complex Arguments: Example and Test
     complex polynomial Complex Polynomial: Example and Test
     construct from base AD Constructor From Base Type: Example and Test
     copy AD object AD Copy Constructor: Example and Test
     Dependent ADFun Check and Re-Tape: Example and Test
     Domain ADFun Sequence Properties: Example and Test
     default AD construct Default AD Constructor: Example and Test
     delete Tracking Use of New and Delete: Example and Test
     derivative First Order Derivative Driver: Example and Test
     det_of_minor Determinant of a Minor: Example and Test
     determinant by minors Determinant Using Lu Factorization: Example and Test
     determinant by minors Determinant Using Expansion by Minors: Example and Test
     EqualOpSeq EqualOpSeq: Example and Test
     error handler Replacing The CppAD Error Handler: Example and Test
     Forward Forward Mode: Example and Test
     FunCheck ADFun Check and Re-Tape: Example and Test
     first order reverse First Order Reverse Mode: Example and Test
     forward mode exp_eps: Second Order Forward Mode
     forward mode exp_2: Second Order Forward Mode
     forward mode exp_2: First Order Forward Mode
     general General Examples
     gradient Gradient of Determinant Using LU Factorization: Example and Test
     gradient Gradient of Determinant Using Expansion by Minors: Example and Test
     gradient Gradient of Determinant Using Lu Factorization: Example and Test
     gradient Gradient of Determinant Using Expansion by Minors: Example and Test
     Hessian Hessian: Example and Test
     Hessian of Lagrangian Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
     Independent Independent and ADFun Constructor: Example and Test
     Integer Convert From AD to Integer: Example and Test
     interpreter Example Differentiating a Stack Machine Interpreter
     ipopt_cppad_nlp Fitting an Ode Using the CppAD Interface to Ipopt
     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_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
     Parameter ADFun Sequence Properties: Example and Test
     Parameter AD Parameter and Variable Functions: Example and Test
     partial First Order Partial Driver: Example and Test
     polynomial Polynomial Evaluation: Example and Test
     pow int The Pow Integer Exponent: Example and Test
     print forward mode Printing During Forward Mode: Example and Test
     Range ADFun Sequence Properties: Example and Test
     Romberg One Dimensional Romberg Integration: Example and Test
     Romberg One Dimensional Romberg Integration: Example and Test
     Rosen34 Rosen34: Example and Test
     Runge45 Runge45: Example and Test
     re-tape CompareChange and Re-Tape: Example and Test
     reverse any order Any Order Reverse Mode: Example and Test
     reverse mode exp_eps: Second Order Reverse Sweep
     reverse mode exp_eps: First Order Reverse Sweep
     reverse mode exp_2: Second Order Reverse Mode
     reverse mode exp_2: First Order Reverse Mode
     run all Program That Runs the CppAD Examples
     SpeedTest Example Use of SpeedTest
     second order reverse Second Order Reverse ModeExample and Test
     second partial Second Partials Reverse Driver: Example and Test
     second partial Subset of Second Order Partials: Example and Test
     simple A Simple Program Using CppAD to Compute Derivatives
     simple vector Simple Vector Template Class: Example and Test
     size_var ADFun Sequence Properties: Example and Test
     sparse Hessian Sparse Hessian: Example and Test
     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: --with-Speed.example
     speed_test speed_test: Example and test
     stiff ode A Stiff Ode: Example and Test
     subtract AD Binary Subtraction: Example and Test
     unary minus AD Unary Minus Operator: Example and Test
     unary plus AD Unary Plus Operator: Example and Test
     unix Unix Download, Test and Installation: --with-Example
     Value Convert From AD to its Base Type: Example and Test
     Var2Par Convert an AD Variable to a Parameter: Example and Test
     Variable AD Parameter and Variable Functions: Example and Test
     VecAD AD Vectors that Record Index Operations: Example and Test
     windows Windows Download and Test: Examples and Testing
exception
     error handler Replacing the CppAD Error Handler
     test Frequently Asked Questions and Answers: Exceptions
exercise
     CppAD::vector The CppAD::vector Template Class: Exercise
     NearEqual Determine if Two Values Are Nearly Equal: Exercise
     numeric type Definition of a Numeric Type: Exercise
     simple vector Definition of a Simple Vector: Exercise
exp
     AD AD Standard Math Unary Functions
     AD example The AD exp Function: Example and Test
     example An Epsilon Accurate Exponential Approximation
     example Second Order Exponential Approximation
     float and double Float and Double Standard Math Unary Functions
     forward theory Exponential Function Forward Taylor Polynomial Theory
     reverse theory Exponential Function Reverse Mode Theory
exp_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
     unix Unix Download, Test and Installation: --with-Introduction.exp_apx
exp_eps An Epsilon Accurate Exponential Approximation
     forward mode exp_eps: Second Order Forward Mode
     implementation exp_eps: Implementation
     operation sequence exp_eps: Operation Sequence and Zero Order Forward Sweep
     reverse exp_eps: Verify Second Order Reverse Sweep
     reverse exp_eps: Verify First Order Reverse Sweep
     reverse mode exp_eps: Second Order Reverse Sweep
     reverse mode exp_eps: First Order Reverse Sweep
     test exp_eps: Test of exp_eps
     zero order exp_eps: Verify Zero Order Forward Sweep
expansion Gradient of Determinant Using Expansion by Minors: Example and Test
          Gradient of Determinant Using Expansion by Minors: Example and Test
     first order exp_eps: First Order Forward Sweep: First Order Expansion
     first order exp_2: First Order Forward Mode: First Order Expansion
     minor determinant Determinant Using Expansion by Minors
     second order exp_eps: Second Order Forward Mode: Second Order Expansion
     second order exp_2: Second Order Forward Mode: Second Order Expansion
     zero order exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion
exponent
     AD function The AD Power Function
     integer The Integer Power Function
expression
     conditional AD Conditional Expressions
F
FAQ Frequently Asked Questions and Answers
Fadbad
     unix Unix Download, Test and Installation: FadbadDir
Fedora
     install Unix Download, Test and Installation: Fedora
ForSparseJac Forward Mode Jacobian Sparsity: Example and Test
             Jacobian Sparsity Pattern: Forward Mode
Forward Forward Mode: Example and Test
     capacity Controlling taylor_ Coefficients Memory Allocation
     order one First Order Forward Mode: Derivative Values
     order zero Zero Order Forward Mode: Function Values
FunCheck Check an ADFun Sequence of Operations
     example ADFun Check and Re-Tape: Example and Test
factor
     lu determinant Determinant Using Expansion by Lu Factorization
     matrix Compute Determinants and Solve Equations by LU Factorization
fadbad
     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
     easy driver First and Second Derivatives: Easy Drivers
     exp theory Exponential Function Forward Taylor Polynomial Theory
     first order exp_eps: First Order Forward Sweep
     first order exp_2: First Order Forward Mode
     log theory Logarithm Function Forward Taylor Polynomial Theory
     mode Any Order Forward Mode
     mode example exp_eps: Second Order Forward Mode
     mode example exp_2: Second Order Forward Mode
     mode example exp_2: First Order Forward Mode
     mode print Printing During Forward Mode: Example and Test
     mode print Printing AD Values During Forward Mode
     print Windows Download and Test: Printing During Forward Mode
     print Unix Download, Test and Installation: --with-PrintFor
     second order exp_eps: Second Order Forward Mode
     second order exp_2: Second Order Forward Mode
     sin Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     sinh Trigonometric and Hyperbolic Sine and Cosine Forward Theory
     sparsity Jacobian Jacobian Sparsity Pattern: Forward Mode
     sqrt theory Square Root Function Forward Taylor Polynomial Theory
     zero order Comparison Changes During Zero Order Forward Mode
     zero order exp_eps: Operation Sequence and Zero Order Forward Sweep
     zero order exp_2: Operation Sequence and Zero Order Forward Mode
free
     install CppAD Windows Download and Test
     unix install Unix Download, Test and Installation
function Glossary: Base Function
         Glossary: AD Function
     AD Bool valued Bool Valued Operations and Functions with AD Arguments
     AD bool AD Boolean Functions
     AD error The AD Error Function
     AD valued AD Valued Operations and Functions
     discrete AD Discrete AD Functions
     math Frequently Asked Questions and Answers: Math Functions
     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
get_started
     unix Unix Download, Test and Installation: --with-Introduction.get_started
getstarted A Simple Program Using CppAD to Compute Derivatives
gradient Gradient of Determinant Using LU Factorization: Example and Test
         Gradient of Determinant Using Expansion by Minors: Example and Test
         Gradient of Determinant Using Lu Factorization: Example and Test
         Gradient of Determinant Using Expansion by Minors: Example and Test
     ode speed cppad CppAD Speed: Gradient of Ode Solution
     ode speed sacado Sacado Speed: Gradient of Ode Solution
H
HesLagrangian Hessian of Lagrangian and  ADFun Default Constructor: Example and Test
Hessian Hessian: Example and Test
     Bender Computing Jacobian and Hessian of Bender's Reduced Objective
     driver Hessian: Easy Driver
     sparse Sparse Hessian: Example and Test
     sparse speed 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