Prev Next _contents Headings

Table of Contents

cppad-20221105: A C++ Algorithmic Differentiation Package
cppad-20221105: A C++ Algorithmic Differentiation Package
    Table of Contents
     CppAD Download, Test, and Install Instructions
    CppAD Download, Test, and Install Instructions
        Download The CppAD Source Code
         Using CMake to Configure CppAD
        Using CMake to Configure CppAD
             Download and Install The CppAD Optional Packages
            Download and Install The CppAD Optional Packages
                Download and Install Adolc in Build Directory
                Download and Install CppADCodeGen in Build Directory
                Download and Install ColPack in Build Directory
                Download and Install Eigen in Build Directory
                Download and Install Fadbad in Build Directory
                Download and Install Ipopt in Build Directory
                Download and Install Sacado in Build Directory
            Including Adolc Examples and Tests
            Including Eigen Examples, Tests, and sparse2eigen
            Including CppADCodeGen Examples and Tests
            Including Ipopt Library Examples, Tests, and pkg-config
            Including Fadbad Speed Tests
            Including Sacado Speed Tests
             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
         The Theory of Reverse Mode
        The Theory of Reverse Mode
            Exponential Function Reverse Mode Theory
            Logarithm Function Reverse Mode Theory
            Square Root Function Reverse Mode Theory
            Trigonometric and Hyperbolic Sine and Cosine Reverse Theory
            Inverse Tangent and Hyperbolic Tangent Reverse Mode Theory
            Inverse Sine and Hyperbolic Sine Reverse Mode Theory
            Inverse Cosine and Hyperbolic Cosine Reverse Mode Theory
            Tangent and Hyperbolic Tangent Reverse Mode Theory
            Error Function Reverse Mode Theory
            Power Function Reverse Mode Theory
        An Important Reverse Mode Identity
         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
                 Atomic AD Functions: Fourth Generation
                Atomic AD Functions: Fourth Generation
                     Defining Atomic Functions: Fourth Generation
                    Defining Atomic Functions: Fourth Generation
                        Atomic Function Constructor
                        Calling an Atomic Function
                        Atomic Function Forward Type Calculation
                        Atomic Function Forward Mode
                        Atomic Function Reverse Mode
                        Atomic Function Jacobian Sparsity Patterns
                        Atomic Function Hessian Sparsity Patterns
                        Atomic Function Reverse Dependency
                     Examples Defining Atomic Functions: Fourth Generation
                    Examples Defining Atomic Functions: Fourth Generation
                        Getting Started with Atomic Functions: Example and Test
                        Atomic Euclidean Norm Squared: Example and Test
                        Atomic Functions and Forward Mode: Example and Test
                        Atomic Functions with Dynamic Parameters: Example and Test
                         Atomic Vector Element-wise Operators: Example and Test
                        Atomic Vector Element-wise Operators: Example and Test
                             Implementing Atomic Vector Operations
                            Implementing Atomic Vector Operations
                                Atomic Vector Class: Example Implementation
                                Atomic Vector Forward Mode: Example Implementation
                                Atomic Vector Forward Mode: Example Implementation
                                Atomic Vector Jacobian Sparsity Pattern: Example Implementation
                                Atomic Vector Hessian Sparsity Pattern: Example Implementation
                                Atomic Vector Forward Type Calculation: Example Implementation
                                Atomic Vector Forward Type Calculation: Example Implementation
                                Atomic Vector Add Operator: Example Implementation
                                Atomic Vector Subtract Operator: Example Implementation
                                Atomic Vector Multiply Operator: Example Implementation
                                Atomic Vector Divide Operator: Example Implementation
                                Atomic Vector Negative Operator: Example Implementation
                            Atomic Vector Addition Example
                            Atomic Vector Division Example
                            Atomic Vector Sparsity Patterns Example
                            Atomic Vector Sparsity Patterns Example
                            Atomic Vector Multiplication Example
                            Atomic Vector Negation Example
                            Example Optimizing Atomic Vector Usage
                            Atomic Vector Subtraction Example
                         Atomic Matrix Multiply Class: Example Implementation
                        Atomic Matrix Multiply Class: Example Implementation
                             Implementing Atomic Matrix Multiply
                            Implementing Atomic Matrix Multiply
                                Atomic Matrix Multiply Class: Example Implementation
                                atomic_mat_mul Set Routine: Example Implementation
                                atomic_mat_mul Get Routine: Example Implementation
                                Atomic Multiply Base Matrices: Example Implementation
                                Atomic Matrix Multiply Forward Type Calculation: Example Implementation
                                Atomic Matrix Multiply Forward Mode: Example Implementation
                                Atomic Matrix Multiply Reverse Mode: Example Implementation
                                Atomic Matrix Multiply Jacobian Sparsity Pattern: Example Implementation
                                Atomic Matrix Multiply Jacobian Sparsity Pattern: Example Implementation
                                Atomic Matrix Multiply Reverse Dependency Analysis: Example Implementation
                            Atomic Matrix Multiply Forward Mode: Example and Test
                            Atomic Matrix Multiply Reverse Mode: Example and Test
                            Atomic Matrix Multiply Sparsity Patterns: Example and Test
                            Atomic Matrix Multiply Reverse Dependency: Example and Test
                            Atomic Matrix Multiply Identical Zero: Example and Test
                         Atomic First Order Linear ODE Method: Example Implementation
                        Atomic First Order Linear ODE Method: Example Implementation
                             Implementing Atomic Linear ODE
                            Implementing Atomic Linear ODE
                                Atomic Linear ODE Class: Example Implementation
                                atomic_lin_ode Set Routine: Example Implementation
                                atomic_lin_ode Get Routine: Example Implementation
                                Atomic Multiply Base Matrices: Example Implementation
                                Atomic Linear ODE Forward Type Calculation: Example Implementation
                                Atomic Linear ODE Forward Mode: Example Implementation
                                 Atomic Linear ODE Reverse Mode: Example Implementation
                                Atomic Linear ODE Reverse Mode: Example Implementation
                                    Atomic Linear ODE Second Order Reverse
                                Atomic Linear ODE Jacobian Sparsity Pattern: Example Implementation
                                Atomic Linear ODE Hessian Sparsity Pattern: Example Implementation
                                Atomic Linear ODE Forward Type Calculation: Example Implementation
                            Atomic Linear ODE Forward Mode: Example and Test
                            Atomic Linear ODE Reverse Mode: Example and Test
                            Atomic Linear ODE Sparsity Calculations: Example and Test
                            Atomic Linear ODE Reverse Dependency Analysis: Example and Test
                 Atomic AD Functions: Third Generation
                Atomic AD Functions: Third Generation
                     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
                 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
                Using base2ad and VecAD together: 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 div Operator: Example and Test
                    Json mul Operator: Example and Test
                    Json pow Operator: Example and Test
                    Json sub Operator: Example and Test
                    Json sum Operator: Example and Test
                    Json Conditional Expressions: Example and Test
                    Json Comparison Operators: Example and Test
                    Json add Operator: Example and Test
                    Json Atomic Function Three Operator: Example and Test
                    Json Atomic Function Operator: Example and Test
                    Json AD Graph print 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
                 C++ AD Graph Operator Enum Type
                C++ AD Graph Operator Enum Type
                    C++ AD Graph add Operator: Example and Test
                    C++ AD Graph add Operator: Example and Test
                    C++ AD Graph div Operator: Example and Test
                    C++ AD Graph mul Operator: Example and Test
                    C++ AD Graph pow Operator: Example and Test
                    C++ AD Graph sub Operator: Example and Test
                    Graph Unary Operator: Example and Test
                    C++ AD Graph sum Operator: Example and Test
                    C++ AD Graph Comparison Operators: Example and Test
                    C++ AD Graph Conditional Expressions: Example and Test
                    C++ AD Graph add Operator: Example and Test
                    C++ AD Graph Atomic Three Functions: Example and Test
                    C++ AD Graph Atomic Four Functions: Example and Test
                    C++ AD Graph print Operator: Example and Test
                 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
         C Source Code Corresponding to an ADFun Object
        C Source Code Corresponding to an ADFun Object
             JIT Creation, Compilation, and Linking of C Source Code
            JIT Creation, Compilation, and Linking of C Source Code
                JIT Computation of Derivatives: Example and Test
                C Source Code Corresponding to a Function: Example and Test
                JIT Compiler Options: Example and Test
                Atomic Callbacks in JIT Function: Example and Test
                JIT With Dynamic Parameters: 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
         Check NumericType Class Concept
        Check NumericType Class Concept
            The CheckNumericType Function: Example and Test
         Check Simple Vector Concept
        Check Simple Vector Concept
            The CheckSimpleVector Function: Example and Test
        Create a Dynamic Link Library
         Replacing the CppAD Error Handler
        Replacing the CppAD Error Handler
            Replacing The CppAD Error Handler: Example and Test
            CppAD Assertions During Execution
         Returns Indices that Sort a Vector
        Returns Indices that Sort a Vector
            Index Sort: Example and Test
         Link a Dynamic Link Library
        Link a Dynamic Link Library
            dll_lib: 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
         Determine if Two Values Are Nearly Equal
        Determine if Two Values Are Nearly Equal
            NearEqual Function: 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
         Evaluate a Polynomial or its Derivative
        Evaluate a Polynomial or its Derivative
            Polynomial Evaluation: Example and Test
            Source: Poly
         The Integer Power Function
        The Integer Power Function
            The Pow Integer Exponent: Example and Test
         Multi-dimensional Romberg Integration
        Multi-dimensional Romberg Integration
            One Dimensional Romberg Integration: Example and Test
         One DimensionalRomberg Integration
        One DimensionalRomberg Integration
            One Dimensional Romberg Integration: 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 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
         Union of Standard Sets
        Union of Standard Sets
            Set Union: 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
         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
         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
        Object that Runs a Group of Tests
         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
         Convert Certain Types to a String
        Convert Certain Types to a String
            to_string: Example and Test
         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
         Definition of a Numeric Type
        Definition of a Numeric Type
            The NumericType: Example and Test
         C++ Concept: A Simple Vector
        C++ Concept: A Simple Vector
            Simple Vector Template 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
     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 cppad_jit
        Speed Test Derivatives Using cppad_jit
            cppad_jit Speed: Gradient of Determinant by Minor Expansion
            cppad_jit Speed: Gradient of Determinant Using Lu Factorization
            cppad_jit Speed: Matrix Multiplication
            cppad_jit Speed: Ode
            cppad_jit Speed: Second Derivative of a Polynomial
            cppad_jit Speed: Sparse Hessian
            cppad_jit 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
         Changes and Additions to CppAD
        Changes and Additions to CppAD
            Changes and Additions to CppAD During 2022
            Changes and Additions to CppAD During 2021
            Changes and Additions to CppAD During 2020
            Changes and Additions to CppAD During 2019
            Changes and Additions to CppAD During 2018
            Changes and Additions to CppAD During 2017
            Changes and Additions to CppAD During 2016
            CppAD Changes and Additions During 2015
            CppAD Changes and Additions During 2014
            CppAD Changes and Additions During 2013
            CppAD Changes and Additions During 2012
            Changes and Additions to CppAD During 2011
            Changes and Additions to CppAD During 2010
            Changes and Additions to CppAD During 2009
            Changes and Additions to CppAD During 2008
            Changes and Additions to CppAD During 2007
            Changes and Additions to CppAD During 2006
            Changes and Additions to CppAD During 2005
            Changes and Additions to CppAD During 2004
            Changes and Additions to CppAD During 2003
         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
            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