Enabling Colpack Sparsity Calculations
            Enabling Colpack Sparsity Calculations
                ColPack: Sparse Jacobian Example and Test
                ColPack: Sparse Jacobian Example and Test
                ColPack: Sparse Hessian Example and Test
                ColPack: Sparse Hessian Example and Test
            Choosing the CppAD Test Vector Template Class
        Checking the CppAD Examples and Tests
        CppAD pkg-config Files

The Theory of Derivative Calculations
The Theory of Derivative Calculations

An Introduction by Example to Algorithmic Differentiation
An Introduction by Example to Algorithmic Differentiation

Second Order Exponential Approximation
            Second Order Exponential Approximation
                exp_2: Implementation
                exp_2: Test

exp_2: Operation Sequence and Zero Order Forward Mode
                exp_2: Operation Sequence and Zero Order Forward Mode
                    exp_2: Verify Zero Order Forward Sweep

exp_2: First Order Forward Mode
                exp_2: First Order Forward Mode
                    exp_2: Verify First Order Forward Sweep

exp_2: First Order Reverse Mode
                exp_2: First Order Reverse Mode
                    exp_2: Verify First Order Reverse Sweep

exp_2: Second Order Forward Mode
                exp_2: Second Order Forward Mode
                    exp_2: Verify Second Order Forward Sweep

exp_2: Second Order Reverse Mode
                exp_2: Second Order Reverse Mode
                    exp_2: Verify Second Order Reverse Sweep
                exp_2: CppAD Forward and Reverse Sweeps

An Epsilon Accurate Exponential Approximation
            An Epsilon Accurate Exponential Approximation
                exp_eps: Implementation
                exp_eps: Test of exp_eps

exp_eps: Operation Sequence and Zero Order Forward Sweep
                exp_eps: Operation Sequence and Zero Order Forward Sweep
                    exp_eps: Verify Zero Order Forward Sweep

exp_eps: First Order Forward Sweep
                exp_eps: First Order Forward Sweep
                    exp_eps: Verify First Order Forward Sweep

exp_eps: First Order Reverse Sweep
                exp_eps: First Order Reverse Sweep
                    exp_eps: Verify First Order Reverse Sweep

exp_eps: Second Order Forward Mode
                exp_eps: Second Order Forward Mode
                    exp_eps: Verify Second Order Forward Sweep

exp_eps: Second Order Reverse Sweep
                exp_eps: Second Order Reverse Sweep
                    exp_eps: Verify Second Order Reverse Sweep
                exp_eps: CppAD Forward and Reverse Sweeps
            Correctness Tests For Exponential Approximation in Introduction

The Theory of Forward Mode
        The Theory of Forward Mode
            Exponential Function Forward Mode Theory
            Logarithm Function Forward Mode Theory
            Square Root Function Forward Mode Theory
            Trigonometric and Hyperbolic Sine and Cosine Forward Theory
            Inverse Tangent and Hyperbolic Tangent Forward Mode Theory
            Inverse Sine and Hyperbolic Sine Forward Mode Theory
            Inverse Cosine and Hyperbolic Cosine Forward Mode Theory
            Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory
            Error Function Forward Taylor Polynomial Theory
            Power Function Forward Mode Theory

AD Theory for Solving ODE's Using Taylor's Method
        AD Theory for Solving ODE's Using Taylor's Method
            Taylor's Ode Solver: An Example and Test
        Research and Software Engineering Projects Related to CppAD

AD Objects
AD Objects

AD Constructors
        AD Constructors
            AD Constructors: Example and Test

AD Assignment Operator
        AD Assignment Operator
            AD Assignment: Example and Test

Conversion and I/O of AD Objects
Conversion and I/O of AD Objects

Convert From an AD Type to its Base Type
            Convert From an AD Type to its Base Type
                Convert From AD to its Base Type: Example and Test

Convert From AD to Integer
            Convert From AD to Integer
                Convert From AD to Integer: Example and Test
            Convert An AD or Base Type to String

AD Input Stream Operator
            AD Input Stream Operator
                AD Output Operator: Example and Test

AD Output Stream Operator
            AD Output Stream Operator
                AD Output Operator: Example and Test

Printing AD Values During Forward Mode
            Printing AD Values During Forward Mode
                Printing During Forward Mode: Example and Test
                Print During Zero Order Forward Mode: Example and Test

Convert an AD Variable or Dynamic Parameter to a Constant
            Convert an AD Variable or Dynamic Parameter to a Constant
                Convert a Variable or Dynamic Parameter a Constant: Example and Test

AD Valued Operations and Functions
AD Valued Operations and Functions

AD Arithmetic Operators and Compound Assignments
AD Arithmetic Operators and Compound Assignments

AD Unary Plus Operator
                AD Unary Plus Operator
                    AD Unary Plus Operator: Example and Test

AD Unary Minus Operator
                AD Unary Minus Operator
                    AD Unary Minus Operator: Example and Test

AD Binary Arithmetic Operators
                AD Binary Arithmetic Operators
                    AD Binary Addition: Example and Test
                    AD Binary Subtraction: Example and Test
                    AD Binary Multiplication: Example and Test
                    AD Binary Division: Example and Test

AD Compound Assignment Operators
                AD Compound Assignment Operators
                    AD Compound Assignment Addition: Example and Test
                    AD Compound Assignment Subtraction: Example and Test
                    AD Compound Assignment Multiplication: Example and Test
                    AD Compound Assignment Division: Example and Test

The Unary Standard Math Functions
The Unary Standard Math Functions

Inverse Cosine Function: acos
                Inverse Cosine Function: acos
                    The AD acos Function: Example and Test

The Inverse Hyperbolic Cosine Function: acosh
                The Inverse Hyperbolic Cosine Function: acosh
                    The AD acosh Function: Example and Test

Inverse Sine Function: asin
                Inverse Sine Function: asin
                    The AD asin Function: Example and Test

The Inverse Hyperbolic Sine Function: asinh
                The Inverse Hyperbolic Sine Function: asinh
                    The AD asinh Function: Example and Test

Inverse Tangent Function: atan
                Inverse Tangent Function: atan
                    The AD atan Function: Example and Test

The Inverse Hyperbolic Tangent Function: atanh
                The Inverse Hyperbolic Tangent Function: atanh
                    The AD atanh Function: Example and Test

The Cosine Function: cos
                The Cosine Function: cos
                    The AD cos Function: Example and Test

The Hyperbolic Cosine Function: cosh
                The Hyperbolic Cosine Function: cosh
                    The AD cosh Function: Example and Test

The Error Function
                The Error Function
                    The AD erf Function: Example and Test

The Complementary Error Function: erfc
                The Complementary Error Function: erfc
                    The AD erfc Function: Example and Test

The Exponential Function: exp
                The Exponential Function: exp
                    The AD exp Function: Example and Test

The Exponential Function Minus One: expm1
                The Exponential Function Minus One: expm1
                    The AD exp Function: Example and Test

The Exponential Function: log
                The Exponential Function: log
                    The AD log Function: Example and Test

The Logarithm of One Plus Argument: log1p
                The Logarithm of One Plus Argument: log1p
                    The AD log1p Function: Example and Test

The Base 10 Logarithm Function: log10
                The Base 10 Logarithm Function: log10
                    The AD log10 Function: Example and Test

The Sine Function: sin
                The Sine Function: sin
                    The AD sin Function: Example and Test

The Hyperbolic Sine Function: sinh
                The Hyperbolic Sine Function: sinh
                    The AD sinh Function: Example and Test

The Square Root Function: sqrt
                The Square Root Function: sqrt
                    The AD sqrt Function: Example and Test

The Tangent Function: tan
                The Tangent Function: tan
                    The AD tan Function: Example and Test

The Hyperbolic Tangent Function: tanh
                The Hyperbolic Tangent Function: tanh
                    The AD tanh Function: Example and Test

AD Absolute Value Functions: abs, fabs
                AD Absolute Value Functions: abs, fabs
                    AD Absolute Value Function: Example and Test

The Sign: sign
                The Sign: sign
                    Sign Function: Example and Test

The Binary Math Functions
The Binary Math Functions

AD Two Argument Inverse Tangent Function
                AD Two Argument Inverse Tangent Function
                    The AD atan2 Function: Example and Test

The AD Power Function
                The AD Power Function
                    The AD Power Function: Example and Test
                    pow: Nan in Result of Pow Function: Example and Test

Absolute Zero Multiplication
                Absolute Zero Multiplication
                    AD Absolute Zero Multiplication: Example and Test

AD Conditional Expressions
            AD Conditional Expressions
                Conditional Expressions: Example and Test

Discrete AD Functions
            Discrete AD Functions
                Taping Array Index Operation: Example and Test
                Interpolation With Out Retaping: Example and Test
                Interpolation With Retaping: Example and Test

Numeric Limits For an AD and Base Types
            Numeric Limits For an AD and Base Types
                Numeric Limits: Example and Test

Atomic AD Functions
Atomic AD Functions

Defining Atomic Functions: Third Generation
                Defining Atomic Functions: Third Generation
                    Atomic Function Constructor
                    Using AD Version of an Atomic Function
                    Atomic Function Forward Type Calculation

Atomic Function Forward Mode
                    Atomic Function Forward Mode
                        Atomic Functions and Forward Mode: Example and Test
                        Atomic Functions with Dynamic Parameters: Example and Test

Atomic Function Reverse Mode
                    Atomic Function Reverse Mode
                        Atomic Functions and Reverse Mode: Example and Test

Atomic Function Jacobian Sparsity Patterns
                    Atomic Function Jacobian Sparsity Patterns
                        Atomic Function Jacobian Sparsity: Example and Test

Atomic Function Hessian Sparsity Patterns
                    Atomic Function Hessian Sparsity Patterns
                        Atomic Forward Hessian Sparsity: Example and Test

Atomic Function Reverse Dependency Calculation
                    Atomic Function Reverse Dependency Calculation
                        Atomic Functions Reverse Dependency Analysis: Example and Test

Example Defining Atomic Functions: Third Generation
                Example Defining Atomic Functions: Third Generation
                    Getting Started with Atomic Functions: Example and Test
                    Atomic Euclidean Norm Squared: Example and Test
                    Tan and Tanh as User Atomic Operations: Example and Test
                    base2ad with Atomic Operations: Example and Test
                    Reciprocal as an Atomic Operation: Example and Test

User Atomic Matrix Multiply: Example and Test
                    User Atomic Matrix Multiply: Example and Test
                        Matrix Multiply as an Atomic Operation
                    Atomic Vector Element-wise Operators: Example and Test

Checkpoint Functions: Second Generation
                Checkpoint Functions: Second Generation
                    Checkpoint Function Constructor
                    Using Checkpoint Functions
                    Dynamic Parameters in Checkpoint Functions
                    Get Started Checkpointing: Example and Test
                    Compare With and Without Checkpointing: Example and Test
                    Checkpointing With base2ad: Example and Test
                    Checkpoint Functions with Dynamic Parameters: Example and Test
                    Checkpointing an ODE Solver: Example and Test

Bool Valued Operations and Functions with AD Arguments
Bool Valued Operations and Functions with AD Arguments

AD Binary Comparison Operators
            AD Binary Comparison Operators
                AD Binary Comparison Operators: Example and Test

Compare AD and Base Objects for Nearly Equal
            Compare AD and Base Objects for Nearly Equal
                Compare AD with Base Objects: Example and Test

AD Boolean Functions
            AD Boolean Functions
                AD Boolean Functions: Example and Test

Constant, Dynamic, Parameter, and Variable
            Constant, Dynamic, Parameter, and Variable
                AD Parameter and Variable Functions: Example and Test

Check if Two Value are Identically Equal
            Check if Two Value are Identically Equal
                EqualOpSeq: Example and Test

AD Vectors that Record Index Operations
        AD Vectors that Record Index Operations
            AD Vectors that Record Index Operations: Example and Test

AD<Base> Requirements for a CppAD Base Type
        AD<Base> Requirements for a CppAD Base Type
            Required Base Class Member Functions
            Base Type Requirements for Conditional Expressions
            Base Type Requirements for Identically Equal Comparisons
            Base Type Requirements for Ordered Comparisons
            Base Type Requirements for Standard Math Functions
            Base Type Requirements for Numeric Limits
            Extending to_string To Another Floating Point Type
            Base Type Requirements for Hash Coding Values

Example AD Base Types That are not AD<OtherBase>
            Example AD Base Types That are not AD<OtherBase>
                Example AD<Base> Where Base Constructor Allocates Memory
                Using a User Defined AD Base Type: Example and Test

Enable use of AD<Base> where Base is Adolc's adouble Type
                Enable use of AD<Base> where Base is Adolc's adouble Type
                    Using Adolc with Multiple Levels of Taping: Example and Test
                Enable use of AD<Base> where Base is float
                Enable use of AD<Base> where Base is double

Enable use of AD<Base> where Base is std::complex<double>
                Enable use of AD<Base> where Base is std::complex<double>
                    Complex Polynomial: Example and Test

ADFun Objects
ADFun Objects

Create an ADFun Object by Recording an Operation Sequence
Create an ADFun Object by Recording an Operation Sequence

Declare Independent Variables and Start Recording
            Declare Independent Variables and Start Recording
                Independent and ADFun Constructor: Example and Test

Construct an ADFun Object and Stop Recording
            Construct an ADFun Object and Stop Recording
                ADFun Assignment: Example and Test
            Stop Recording and Store Operation Sequence

Abort Recording of an Operation Sequence
            Abort Recording of an Operation Sequence
                Abort Current Recording: Example and Test

ADFun Function Properties
            ADFun Function Properties
                ADFun Function Properties: Example and Test

Setting and Getting a Function's Name
            Setting and Getting a Function's Name
                ADFun Function Name: Example and Test

Other Ways to Create an ADFun Object
Other Ways to Create an ADFun Object

Create an AD<Base> Function From a Base Function
            Create an AD<Base> Function From a Base Function
                Taylor's Ode Solver: base2ad Example and Test

Json Representation of an AD Graph
Json Representation of an AD Graph

Json AD Graph Operator Definitions
                Json AD Graph Operator Definitions
                    Json Unary Operators: Example and Test
                    Json add Operator: Example and Test
                    Json azmul Operator: Example and Test
                    Json add Operator: Example and Test
                    Json div Operator: Example and Test
                    Json mul Operator: Example and Test
                    Json pow Operator: Example and Test
                    Json AD Graph print Operator: Example and Test
                    Json sub Operator: Example and Test
                    Json sum Operator: Example and Test
                    Json Comparison Operators: Example and Test
                    Json Conditional Expressions: Example and Test
                    Json Atomic Function Operator: Example and Test

ADFun Object Corresponding to a Json AD Graph
                ADFun Object Corresponding to a Json AD Graph
                    Convert Jason Graph to an ADFun Object: Example and Test

Json AD Graph Corresponding to an ADFun Object
                Json AD Graph Corresponding to an ADFun Object
                    Convert an ADFun Object to a Json AD Graph: Example and Test
                Json Get Started: Example and Test
                Json Representation of a Sparse Matrix: Example and Test

C++ Representation of an AD Graph
C++ Representation of an AD Graph

A C++ AD Graph Class
                A C++ AD Graph Class
                    C++ AD Graph Constructor
                    C++ AD Graph Scalar Values
                    C++ AD Graph Vector Values

Print A C++ AD Graph
                    Print A C++ AD Graph
                        Print a C++ AD Graph: Example and Test

ADFun Object Corresponding to a CppAD Graph
                ADFun Object Corresponding to a CppAD Graph
                    Switching Between Variables and Dynamic Parameters: Example and Test
                Create a C++ AD Graph Corresponding to an ADFun Object

Create An Abs-normal Representation of a Function
Create An Abs-normal Representation of a Function

Examples and Tests: Abs-normal Representation of Non-Smooth Functions
                Examples and Tests: Abs-normal Representation of Non-Smooth Functions
                    abs_normal Getting Started: Example and Test
                    abs_normal: Print a Vector or Matrix

abs_normal: Evaluate First Order Approximation
                    abs_normal: Evaluate First Order Approximation
                        abs_eval: Example and Test
                        abs_eval Source Code

abs_normal: Solve a Linear Program Using Simplex Method
                    abs_normal: Solve a Linear Program Using Simplex Method
                        abs_normal simplex_method: Example and Test
                        simplex_method Source Code

abs_normal: Solve a Linear Program With Box Constraints
                    abs_normal: Solve a Linear Program With Box Constraints
                        abs_normal lp_box: Example and Test
                        lp_box Source Code

abs_normal: Minimize a Linear Abs-normal Approximation
                    abs_normal: Minimize a Linear Abs-normal Approximation
                        abs_min_linear: Example and Test
                        abs_min_linear Source Code

Non-Smooth Optimization Using Abs-normal Linear Approximations
                    Non-Smooth Optimization Using Abs-normal Linear Approximations
                        abs_normal min_nso_linear: Example and Test
                        min_nso_linear Source Code

Solve a Quadratic Program Using Interior Point Method
                    Solve a Quadratic Program Using Interior Point Method
                        abs_normal qp_interior: Example and Test
                        qp_interior Source Code

abs_normal: Solve a Quadratic Program With Box Constraints
                    abs_normal: Solve a Quadratic Program With Box Constraints
                        abs_normal qp_box: Example and Test
                        qp_box Source Code

abs_normal: Minimize a Linear Abs-normal Approximation
                    abs_normal: Minimize a Linear Abs-normal Approximation
                        abs_min_quad: Example and Test
                        abs_min_quad Source Code

Non-Smooth Optimization Using Abs-normal Quadratic Approximations
                    Non-Smooth Optimization Using Abs-normal Quadratic Approximations
                        abs_normal min_nso_quad: Example and Test
                        min_nso_quad Source Code

First and Second Order Derivatives: Easy Drivers
First and Second Order Derivatives: Easy Drivers

Jacobian: Driver Routine
            Jacobian: Driver Routine
                Jacobian: Example and Test

Hessian: Easy Driver
            Hessian: Easy Driver
                Hessian: Example and Test
                Hessian of Lagrangian and ADFun Default Constructor: Example and Test

First Order Partial Derivative: Driver Routine
            First Order Partial Derivative: Driver Routine
                First Order Partial Driver: Example and Test

First Order Derivative: Driver Routine
            First Order Derivative: Driver Routine
                First Order Derivative Driver: Example and Test

Forward Mode Second Partial Derivative Driver
            Forward Mode Second Partial Derivative Driver
                Subset of Second Order Partials: Example and Test

Reverse Mode Second Partial Derivative Driver
            Reverse Mode Second Partial Derivative Driver
                Second Partials Reverse Driver: Example and Test

Forward Mode
Forward Mode

Change the Dynamic Parameters
            Change the Dynamic Parameters
                Dynamic Parameters: Example and Test
            Zero Order Forward Mode: Function Values
            First Order Forward Mode: Derivative Values
            Second Order Forward Mode: Derivative Values

Multiple Order Forward Mode
            Multiple Order Forward Mode
                Forward Mode: Example and Test
                Forward Mode: Example and Test of Multiple Orders

Multiple Directions Forward Mode
            Multiple Directions Forward Mode
                Forward Mode: Example and Test of Multiple Directions
            Number Taylor Coefficient Orders Currently Stored

Comparison Changes Between Taping and Zero Order Forward
            Comparison Changes Between Taping and Zero Order Forward
                CompareChange and Re-Tape: Example and Test

Controlling Taylor Coefficients Memory Allocation
            Controlling Taylor Coefficients Memory Allocation
                Controlling Taylor Coefficient Memory Allocation: Example and Test

Number of Variables that Can be Skipped
            Number of Variables that Can be Skipped
                Number of Variables That Can be Skipped: Example and Test

Reverse Mode
Reverse Mode

First Order Reverse Mode
            First Order Reverse Mode
                First Order Reverse Mode: Example and Test

Second Order Reverse Mode
            Second Order Reverse Mode
                Second Order Reverse ModeExample and Test
                Hessian Times Direction: Example and Test

Any Order Reverse Mode
            Any Order Reverse Mode
                Third Order Reverse Mode: Example and Test
                Reverse Mode General Case (Checkpointing): Example and Test

Reverse Mode Using Subgraphs
            Reverse Mode Using Subgraphs
                Computing Reverse Mode on Subgraphs: Example and Test

Calculating Sparsity Patterns
Calculating Sparsity Patterns

Forward Mode Jacobian Sparsity Patterns
            Forward Mode Jacobian Sparsity Patterns
                Forward Mode Jacobian Sparsity: Example and Test

Reverse Mode Jacobian Sparsity Patterns
            Reverse Mode Jacobian Sparsity Patterns
                Reverse Mode Jacobian Sparsity: Example and Test

Forward Mode Hessian Sparsity Patterns
            Forward Mode Hessian Sparsity Patterns
                Forward Mode Hessian Sparsity: Example and Test

Reverse Mode Hessian Sparsity Patterns
            Reverse Mode Hessian Sparsity Patterns
                Reverse Mode Hessian Sparsity: Example and Test

Subgraph Dependency Sparsity Patterns
            Subgraph Dependency Sparsity Patterns
                Subgraph Dependency Sparsity Patterns: Example and Test
            Computing Dependency: Example and Test
            Preferred Sparsity Patterns: Row and Column Indices: Example and Test

Jacobian Sparsity Pattern: Forward Mode
            Jacobian Sparsity Pattern: Forward Mode
                Forward Mode Jacobian Sparsity: Example and Test

Jacobian Sparsity Pattern: Reverse Mode
            Jacobian Sparsity Pattern: Reverse Mode
                Reverse Mode Jacobian Sparsity: Example and Test

Hessian Sparsity Pattern: Reverse Mode
            Hessian Sparsity Pattern: Reverse Mode
                Reverse Mode Hessian Sparsity: Example and Test
                Sparsity Patterns For a Subset of Variables: Example and Test

Hessian Sparsity Pattern: Forward Mode
            Hessian Sparsity Pattern: Forward Mode
                Forward Mode Hessian Sparsity: Example and Test

Calculating Sparse Derivatives
Calculating Sparse Derivatives

Computing Sparse Jacobians
            Computing Sparse Jacobians
                Computing Sparse Jacobian Using Forward Mode: Example and Test
                Computing Sparse Jacobian Using Reverse Mode: Example and Test

Sparse Jacobian
            Sparse Jacobian
                Sparse Jacobian: Example and Test

Computing Sparse Hessians
            Computing Sparse Hessians
                Computing Sparse Hessian: Example and Test

Sparse Hessian
            Sparse Hessian
                Sparse Hessian: Example and Test
                Computing Sparse Hessian for a Subset of Variables
                Subset of a Sparse Hessian: Example and Test

Compute Sparse Jacobians Using Subgraphs
            Compute Sparse Jacobians Using Subgraphs
                Computing Sparse Jacobian Using Reverse Mode: Example and Test
                Sparse Hessian Using Subgraphs and Jacobian: Example and Test

Optimize an ADFun Object Tape
        Optimize an ADFun Object Tape
            Optimizing Twice: Example and Test
            Optimize Forward Activity Analysis: Example and Test
            Optimize Reverse Activity Analysis: Example and Test
            Optimize Comparison Operators: Example and Test
            Optimize Print Forward Operators: Example and Test
            Optimize Conditional Expressions: Example and Test
            Optimize Nested Conditional Expressions: Example and Test
            Optimize Cumulative Sum Operations: Example and Test

Check an ADFun Sequence of Operations
        Check an ADFun Sequence of Operations
            ADFun Check and Re-Tape: Example and Test

Check an ADFun Object For Nan Results
        Check an ADFun Object For Nan Results
            ADFun Checking For Nan: Example and Test
    CppAD API Preprocessor Symbols

Using CppAD in a Multi-Threading Environment
    Using CppAD in a Multi-Threading Environment
        Enable AD Calculations During Parallel Mode

Run Multi-Threading Examples and Speed Tests
        Run Multi-Threading Examples and Speed Tests
            A Simple OpenMP Example and Test
            A Simple Boost Thread Example and Test
            A Simple Parallel Pthread Example and Test
            A Simple OpenMP AD: Example and Test
            A Simple Boost Threading AD: Example and Test
            A Simple pthread AD: Example and Test
            Using a Team of AD Threads: Example and Test

Multi-Threading Harmonic Summation Example / Test
            Multi-Threading Harmonic Summation Example / Test
                Common Variables Used by Multi-threading Sum of 1/i
                Set Up Multi-threading Sum of 1/i
                Do One Thread's Work for Sum of 1/i
                Take Down Multi-threading Sum of 1/i
                Multi-Threaded Implementation of Summation of 1/i
                Timing Test of Multi-Threaded Summation of 1/i

Multi-Threading atomic_three Example / Test
            Multi-Threading atomic_three Example / Test
                Defines a atomic_three Operation that Computes Square Root
                Multi-Threaded atomic_three Common Information
                Multi-Threaded atomic_three Set Up
                Multi-Threaded atomic_three Worker
                Multi-Threaded atomic_three Take Down
                Run Multi-Threaded atomic_three Calculation
                Timing Test for Multi-Threaded atomic_three Calculation

Multi-Threading chkpoint_two Example / Test
            Multi-Threading chkpoint_two Example / Test
                chkpoint_two Algorithm that Computes Square Root
                Multi-Threaded chkpoint_two Common Information
                Multi-Threaded chkpoint_two Set Up
                Multi-Threaded chkpoint_two Worker
                Multi-Threaded chkpoint_two Take Down
                Run Multi-Threaded chkpoint_two Calculation
                Timing Test for Multi-Threaded chkpoint_two Calculation

Multi-Threaded Newton Method Example / Test
            Multi-Threaded Newton Method Example / Test
                Common Variables use by Multi-Threaded Newton Method
                Set Up Multi-Threaded Newton Method
                Do One Thread's Work for Multi-Threaded Newton Method
                Take Down Multi-threaded Newton Method
                A Multi-Threaded Newton's Method
                Timing Test of Multi-Threaded Newton Method

Specifications for A Team of AD Threads
            Specifications for A Team of AD Threads
                OpenMP Implementation of a Team of AD Threads
                Boost Thread Implementation of a Team of AD Threads
                Pthread Implementation of a Team of AD Threads

Some General Purpose Utilities
Some General Purpose Utilities

Replacing the CppAD Error Handler
        Replacing the CppAD Error Handler
            Replacing The CppAD Error Handler: Example and Test
            CppAD Assertions During Execution

Determine if Two Values Are Nearly Equal
        Determine if Two Values Are Nearly Equal
            NearEqual Function: Example and Test

Run One Speed Test and Return Results
        Run One Speed Test and Return Results
            speed_test: Example and test

Run One Speed Test and Print Results
        Run One Speed Test and Print Results
            Example Use of SpeedTest

Determine Amount of Time to Execute a Test
Determine Amount of Time to Execute a Test

Returns Elapsed Number of Seconds
            Returns Elapsed Number of Seconds
                Elapsed Seconds: Example and Test
            time_test: Example and test
        Object that Runs a Group of Tests

Definition of a Numeric Type
        Definition of a Numeric Type
            The NumericType: Example and Test

Check NumericType Class Concept
        Check NumericType Class Concept
            The CheckNumericType Function: Example and Test

C++ Concept: A Simple Vector
        C++ Concept: A Simple Vector
            Simple Vector Template Class: Example and Test

Check Simple Vector Concept
        Check Simple Vector Concept
            The CheckSimpleVector Function: Example and Test

Obtain Nan or Determine if a Value is Nan
        Obtain Nan or Determine if a Value is Nan
            nan: Example and Test

The Integer Power Function
        The Integer Power Function
            The Pow Integer Exponent: Example and Test

Evaluate a Polynomial or its Derivative
        Evaluate a Polynomial or its Derivative
            Polynomial Evaluation: Example and Test
            Source: Poly

Compute Determinants and Solve Equations by LU Factorization
Compute Determinants and Solve Equations by LU Factorization

Compute Determinant and Solve Linear Equations
            Compute Determinant and Solve Linear Equations
                LuSolve With Complex Arguments: Example and Test
                Source: LuSolve

LU Factorization of A Square Matrix
            LU Factorization of A Square Matrix
                LuFactor: Example and Test
                Source: LuFactor

Invert an LU Factored Equation
            Invert an LU Factored Equation
                LuInvert: Example and Test
                Source: LuInvert

One DimensionalRomberg Integration
        One DimensionalRomberg Integration
            One Dimensional Romberg Integration: Example and Test

Multi-dimensional Romberg Integration
        Multi-dimensional Romberg Integration
            One Dimensional Romberg Integration: Example and Test

An Embedded 4th and 5th Order Runge-Kutta ODE Solver
        An Embedded 4th and 5th Order Runge-Kutta ODE Solver
            Runge45: Example and Test
            Runge45: Example and Test

A 3rd and 4th Order Rosenbrock ODE Solver
        A 3rd and 4th Order Rosenbrock ODE Solver
            rosen_34: Example and Test

An Error Controller for ODE Solvers
        An Error Controller for ODE Solvers
            OdeErrControl: Example and Test
            OdeErrControl: Example and Test Using Maxabs Argument

An Arbitrary Order Gear Method
        An Arbitrary Order Gear Method
            OdeGear: Example and Test

An Error Controller for Gear's Ode Solvers
        An Error Controller for Gear's Ode Solvers
            OdeGearControl: Example and Test

The CppAD::vector Template Class
        The CppAD::vector Template Class
            CppAD::vector Template Class: Example and Test
            CppAD::vectorBool Class: Example and Test

A Fast Multi-Threading Memory Allocator
        A Fast Multi-Threading Memory Allocator
            Fast Multi-Threading Memory Allocator: Example and Test
            Setup thread_alloc For Use in Multi-Threading Environment
            Get Number of Threads
            Is The Current Execution in Parallel Mode
            Get the Current Thread Number
            Get At Least A Specified Amount of Memory
            Return Memory to thread_alloc
            Free Memory Currently Available for Quick Use by a Thread
            Control When Thread Alloc Retains Memory For Future Use
            Amount of Memory a Thread is Currently Using
            Amount of Memory Available for Quick Use by a Thread
            Allocate An Array and Call Default Constructor for its Elements
            Deallocate An Array and Call Destructor for its Elements
            Free All Memory That Was Allocated for Use by thread_alloc

Returns Indices that Sort a Vector
        Returns Indices that Sort a Vector
            Index Sort: Example and Test

Convert Certain Types to a String
        Convert Certain Types to a String
            to_string: Example and Test

Union of Standard Sets
        Union of Standard Sets
            Set Union: Example and Test

Row and Column Index Sparsity Patterns
        Row and Column Index Sparsity Patterns
            sparse_rc: Example and Test

Sparse Matrix Row, Column, Value Representation
        Sparse Matrix Row, Column, Value Representation
            sparse_rcv: Example and Test

Convert A CppAD Sparse Matrix to an Eigen Sparse Matrix
        Convert A CppAD Sparse Matrix to an Eigen Sparse Matrix
            Converting CppAD Sparse Matrix to Eigen Format: Example and Test

Use Ipopt to Solve a Nonlinear Programming Problem
    Use Ipopt to Solve a Nonlinear Programming Problem
        Nonlinear Programming Using CppAD and Ipopt: Example and Test
        Nonlinear Programming Retaping: Example and Test
        ODE Inverse Problem Definitions: Source Code

Examples
    Examples
        Getting Started Using CppAD to Compute Derivatives
        List All (Except Deprecated) CppAD Examples

General Examples
        General Examples
            Creating Your Own Interface to an ADFun Object
            Example and Test Linking CppAD to Languages Other than C++
            Differentiate Conjugate Gradient Algorithm: Example and Test

Enable Use of Eigen Linear Algebra Package with CppAD
            Enable Use of Eigen Linear Algebra Package with CppAD
                Source Code for eigen_plugin.hpp
                Using Eigen Arrays: Example and Test
                Using Eigen To Compute Determinant: Example and Test
            Gradient of Determinant Using Expansion by Minors: Example and Test
            Gradient of Determinant Using LU Factorization: Example and Test
            Interfacing to C: Example and Test
            Gradient of Determinant Using Expansion by Minors: Example and Test
            Gradient of Determinant Using Lu Factorization: Example and Test

Using Multiple Levels of AD
            Using Multiple Levels of AD
                Multiple Level of AD: Example and Test
                Computing a Jacobian With Constants that Change
            A Stiff Ode: Example and Test
            Taylor's Ode Solver: A Multi-Level AD Example and Test
            Taylor's Ode Solver: A Multi-Level Adolc Example and Test
            Example Differentiating a Stack Machine Interpreter

Generate Source Code and Compile an AD Function
            Generate Source Code and Compile an AD Function
                Evaluate a Code Gen Function: Example and Test
                File Store and Retrieve a Code Gen Function: Example and Test
                Evaluate Jacobian of a Code Gen Function: Example and Test
                Pass Jacobian as Code Gen Function: Example and Test
                Evaluate Sparse Jacobian of a Code Gen Function: Example and Test
                Pass Sparse Jacobian as Code Gen Function: Example and Test
            code_gen_fun Class Include File
            code_gen_fun Class Member Implementation

Utility Routines used by CppAD Examples
        Utility Routines used by CppAD Examples
            CppAD Examples and Tests
            Run the Speed Examples

Lu Factor and Solve with Recorded Pivoting
            Lu Factor and Solve with Recorded Pivoting
                Lu Factor and Solve With Recorded Pivoting: Example and Test
        Using The CppAD Test Vector Template Class
        Suppress Suspect Implicit Conversion Warnings

Speed Test an Operator Overloading AD Package
Speed Test an Operator Overloading AD Package

Running the Speed Test Program
Running the Speed Test Program

Package Specific Speed Test Linking Routines
            Package Specific Speed Test Linking Routines
                Speed Testing Gradient of Determinant Using Lu Factorization
                Speed Testing Gradient of Determinant by Minor Expansion
                Speed Testing Derivative of Matrix Multiply
                Speed Testing the Jacobian of Ode Solution
                Speed Testing Second Derivative of a Polynomial
                Link to Speed Test Sparse Hessian
                Speed Testing Sparse Jacobians

Speed Testing Utilities
Speed Testing Utilities

Determinant Using Expansion by Lu Factorization
            Determinant Using Expansion by Lu Factorization
                Determinant Using Lu Factorization: Example and Test
                Source: det_by_lu

Determinant of a Minor
            Determinant of a Minor
                Determinant of a Minor: Example and Test
                Source: det_of_minor

Determinant Using Expansion by Minors
            Determinant Using Expansion by Minors
                Determinant Using Expansion by Minors: Example and Test
                Source: det_by_minor

Check Determinant of 3 by 3 matrix
            Check Determinant of 3 by 3 matrix
                Source: det_33

Check Gradient of Determinant of 3 by 3 matrix
            Check Gradient of Determinant of 3 by 3 matrix
                Source: det_grad_33

Sum Elements of a Matrix Times Itself
            Sum Elements of a Matrix Times Itself
                Sum of the Elements of the Square of a Matrix: Example and Test
                Source: mat_sum_sq

Evaluate a Function Defined in Terms of an ODE
            Evaluate a Function Defined in Terms of an ODE
                ode_evaluate: Example and test
                Source: ode_evaluate

Evaluate a Function That Has a Sparse Jacobian
            Evaluate a Function That Has a Sparse Jacobian
                sparse_jac_fun: Example and test
                Source: sparse_jac_fun

Evaluate a Function That Has a Sparse Hessian
            Evaluate a Function That Has a Sparse Hessian
                sparse_hes_fun: Example and test
                Source: sparse_hes_fun

Simulate a [0,1] Uniform Random Variate
            Simulate a [0,1] Uniform Random Variate
                Source: uniform_01

Speed Test of Functions in Double
        Speed Test of Functions in Double
            Double Speed: Determinant by Minor Expansion
            Double Speed: Determinant Using Lu Factorization
            Double Speed: Matrix Multiplication
            Double Speed: Ode Solution
            Double Speed: Evaluate a Polynomial
            Double Speed: Sparse Hessian
            Double Speed: Sparse Jacobian

Speed Test of Derivatives Using Adolc
        Speed Test of Derivatives Using Adolc
            Adolc Speed: Gradient of Determinant by Minor Expansion
            Adolc Speed: Gradient of Determinant Using Lu Factorization
            Adolc Speed: Matrix Multiplication
            Adolc Speed: Ode
            Adolc Speed: Second Derivative of a Polynomial
            Adolc Speed: Sparse Hessian
            Adolc Speed: Sparse Jacobian
            Adolc Test Utility: Allocate and Free Memory For a Matrix

Speed Test Derivatives Using CppAD
        Speed Test Derivatives Using CppAD
            Cppad Speed: Gradient of Determinant by Minor Expansion
            Cppad Speed: Gradient of Determinant Using Lu Factorization
            CppAD Speed, Matrix Multiplication
            Cppad Speed: Gradient of Ode Solution
            Cppad Speed: Second Derivative of a Polynomial
            Cppad Speed: Sparse Hessian
            Cppad Speed: Sparse Jacobian

Speed Test Derivatives Using Fadbad
        Speed Test Derivatives Using Fadbad
            Fadbad Speed: Gradient of Determinant by Minor Expansion
            Fadbad Speed: Gradient of Determinant Using Lu Factorization
            Fadbad Speed: Matrix Multiplication
            Fadbad Speed: Ode
            Fadbad Speed: Second Derivative of a Polynomial
            Fadbad Speed: Sparse Hessian
            Fadbad Speed: sparse_jacobian

Speed Test Derivatives Using Cppadcg
        Speed Test Derivatives Using Cppadcg
            cppadcg Speed: Gradient of Determinant by Minor Expansion
            Cppadcg Speed: Gradient of Determinant Using Lu Factorization
            Cppadcg Speed: Matrix Multiplication
            Cppadcg Speed: Ode
            Cppadcg Speed: Second Derivative of a Polynomial
            Cppadcg Speed: Sparse Hessian
            Cppadcg Speed: Sparse Jacobian

Speed Test Derivatives Using Sacado
        Speed Test Derivatives Using Sacado
            Sacado Speed: Gradient of Determinant by Minor Expansion
            Sacado Speed: Gradient of Determinant Using Lu Factorization
            Sacado Speed: Matrix Multiplication
            Sacado Speed: Gradient of Ode Solution
            Sacado Speed: Second Derivative of a Polynomial
            Sacado Speed: Sparse Hessian
            Sacado Speed: sparse_jacobian

Speed Test Example and Template for a New Package
        Speed Test Example and Template for a New Package
            Xpackage Speed: Gradient of Determinant by Minor Expansion
            Xpackage Speed: Gradient of Determinant Using Lu Factorization
            Xpackage Speed: Matrix Multiplication
            Xpackage Speed: Ode
            Xpackage Speed: Second Derivative of a Polynomial
            Xpackage Speed: Sparse Hessian
            Xpackage Speed: sparse_jacobian

Appendix
    Appendix
        Frequently Asked Questions and Answers
        Directory Structure
        Glossary
        Bibliography
        The CppAD Wish List

CppAD Deprecated API Features
        CppAD Deprecated API Features
            Deprecated Include Files
            ADFun Object Deprecated Member Functions
            Comparison Changes During Zero Order Forward Mode
            OpenMP Parallel Setup
            Routines That Track Use of New and Delete

A Quick OpenMP Memory Allocator Used by CppAD
            A Quick OpenMP Memory Allocator Used by CppAD
                Set and Get Maximum Number of Threads for omp_alloc Allocator
                Is The Current Execution in OpenMP Parallel Mode
                Get the Current OpenMP Thread Number
                Get At Least A Specified Amount of Memory
                Return Memory to omp_alloc
                Free Memory Currently Available for Quick Use by a Thread
                Amount of Memory a Thread is Currently Using
                Amount of Memory Available for Quick Use by a Thread
                Allocate Memory and Create A Raw Array
                Return A Raw Array to The Available Memory for a Thread
                Check If A Memory Allocation is Efficient for Another Use
                Set Maximum Number of Threads for omp_alloc Allocator
            Memory Leak Detection
            Machine Epsilon For AD Types
            Choosing The Vector Testing Template Class
            Nonlinear Programming Using the CppAD Interface to Ipopt
            Defining Atomic Functions: First Generation

Defining Atomic Functions: Second Generation
            Defining Atomic Functions: Second Generation
                Atomic Function Constructor
                Set Atomic Function Options
                Using AD Version of Atomic Function
                Atomic Forward Mode
                Atomic Reverse Mode
                Atomic Forward Jacobian Sparsity Patterns
                Atomic Reverse Jacobian Sparsity Patterns
                Atomic Forward Hessian Sparsity Patterns
                Atomic Reverse Hessian Sparsity Patterns
                Free Static Variables

Example Defining Atomic Functions: Second Generation
Example Defining Atomic Functions: Second Generation

Atomic Eigen Matrix Multiply: Example and Test
                Atomic Eigen Matrix Multiply: Example and Test
                    atomic_two Eigen Matrix Multiply Class

Atomic Eigen Matrix Inverse: Example and Test
                Atomic Eigen Matrix Inverse: Example and Test
                    atomic_two Eigen Matrix Inversion Class

Atomic Eigen Cholesky Factorization: Example and Test
                Atomic Eigen Cholesky Factorization: Example and Test
                    AD Theory for Cholesky Factorization
                    atomic_two Eigen Cholesky Factorization Class

Multi-Threading atomic_two Example / Test
            Multi-Threading atomic_two Example / Test
                Defines a atomic_two Operation that Computes Square Root
                Multi-Threaded atomic_two Common Information
                Multi-Threaded atomic_two Set Up
                Multi-Threaded atomic_two Worker
                Multi-Threaded atomic_two Take Down
                Run Multi-Threaded atomic_two Calculation
                Timing Test for Multi-Threaded atomic_two Calculation
            Checkpoint Functions: First Generation

Multi-Threading chkpoint_one Example / Test
            Multi-Threading chkpoint_one Example / Test
                chkpoint_one Algorithm that Computes Square Root
                Multi-Threaded chkpoint_one Common Information
                Multi-Threaded chkpoint_one Set Up
                Multi-Threaded chkpoint_one Worker
                Multi-Threaded chkpoint_one Take Down
                Run Multi-Threaded chkpoint_one Calculation
                Timing Test for Multi-Threaded chkpoint_one Calculation
            zdouble: An AD Base Type With Absolute Zero
            Autotools Unix Test and Installation

Compare Speed of C and C++
        Compare Speed of C and C++
            Determinant of a Minor
            Compute Determinant using Expansion by Minors
            Simulate a [0,1] Uniform Random Variate
            Correctness Test of det_by_minor Routine
            Repeat det_by_minor Routine A Specified Number of Times
            Returns Elapsed Number of Seconds
            Determine Amount of Time to Execute det_by_minor
            Main Program For Comparing C and C++ Speed

Some Numerical AD Utilities
Some Numerical AD Utilities

Computing Jacobian and Hessian of Bender's Reduced Objective
            Computing Jacobian and Hessian of Bender's Reduced Objective
                BenderQuad: Example and Test

Jacobian and Hessian of Optimal Values
            Jacobian and Hessian of Optimal Values
                opt_val_hes: Example and Test

LU Factorization of A Square Matrix and Stability Calculation
            LU Factorization of A Square Matrix and Stability Calculation
                LuRatio: Example and Test
        CppAD Addons
        Your License for the CppAD Software
    Alphabetic Listing of Cross Reference Tags
    Keyword Index
    Search This Web Site
    External Internet References