Prev Next _contents Headings

Table of Contents

cppad-20171217: A Package for Differentiation of C++ Algorithms
cppad-20171217: A Package for Differentiation of C++ Algorithms
    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
             Including the ADOL-C Examples and Tests
            Including the ADOL-C Examples and Tests
                Download and Install Adolc in Build Directory

             Including the ColPack Sparsity Calculations
            Including the 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
                Download and Install ColPack in Build Directory

             Including the Eigen Examples and Tests
            Including the Eigen Examples and Tests
                Download and Install Eigen in Build Directory

             Including the FADBAD Speed Tests
            Including the FADBAD Speed Tests
                Download and Install Fadbad in Build Directory

             Including the cppad_ipopt Library and Tests
            Including the cppad_ipopt Library and Tests
                Download and Install Ipopt in Build Directory

             Including the Sacado Speed Tests
            Including the Sacado Speed Tests
                Download and Install Sacado in Build Directory

            Choosing the CppAD Test Vector Template Class

        Checking the CppAD Examples and Tests
        CppAD pkg-config Files

     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

     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 Output Stream Operator
            AD Output 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 to a Parameter
            Convert an AD Variable to a Parameter
                Convert an AD Variable to a Parameter: 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 Sine Function: acos
                Inverse Sine Function: acos
                    The AD acos Function: Example and Test

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

                 Inverse Tangent Function: atan
                Inverse Tangent Function: atan
                    The AD atan 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 Exponential Function: exp
                The Exponential Function: exp
                    The AD exp Function: Example and Test

                 The Exponential Function: log
                The Exponential Function: log
                    The AD log 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 Inverse Hyperbolic Cosine Function: acosh
                The Inverse Hyperbolic Cosine Function: acosh
                    The AD acosh Function: Example and Test

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

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

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

                 The Exponential Function Minus One: expm1
                The Exponential Function Minus One: expm1
                    The AD exp 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 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

                 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
                 Checkpointing Functions
                Checkpointing Functions
                    Simple Checkpointing: Example and Test
                    Atomic Operations and Multiple-Levels of AD: Example and Test
                    Checkpointing an ODE Solver: Example and Test
                    Checkpointing an Extended ODE Solver: Example and Test

                 User Defined Atomic AD Functions
                User Defined Atomic AD Functions
                    Atomic Function Constructor
                    Set Atomic Function Options
                    Using AD Version of Atomic Function
                     Atomic Forward Mode
                    Atomic Forward Mode
                        Atomic Forward: Example and Test

                     Atomic Reverse Mode
                    Atomic Reverse Mode
                        Atomic Reverse: Example and Test

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

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

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

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

                    Free Static Variables
                    Getting Started with Atomic Operations: Example and Test
                    Atomic Euclidean Norm Squared: Example and Test
                    Reciprocal as an Atomic Operation: Example and Test
                    Atomic Sparsity with Set Patterns: Example and Test
                    Tan and Tanh as User Atomic Operations: Example and Test
                     Atomic Eigen Matrix Multiply: Example and Test
                    Atomic Eigen Matrix Multiply: Example and Test
                        Atomic Eigen Matrix Multiply Class

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

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

                     User Atomic Matrix Multiply: Example and Test
                    User Atomic Matrix Multiply: Example and Test
                        Matrix Multiply as an Atomic Operation

         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

             Is an AD Object a Parameter or Variable
            Is an AD Object a Parameter or 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 (Record an Operation Sequence)
        Create an ADFun Object (Record 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 Sequence Properties
            ADFun Sequence Properties
                ADFun Sequence Properties: Example and Test

         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
            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

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

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

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

             Reverse Mode Hessian Sparsity Patterns
            Reverse Mode Hessian Sparsity Patterns
                Reverse Mode Hessian 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

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

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

            Computing Dependency: Example and Test
            Preferred Sparsity Patterns: Row and Column Indices: Example and Test
             Subgraph Dependency Sparsity Patterns
            Subgraph Dependency Sparsity Patterns
                Subgraph Dependency Sparsity Patterns: 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
            Example Optimization and Forward Activity Analysis
            Example Optimization and Reverse Activity Analysis
            Example Optimization and Comparison Operators
            Example Optimization and Print Forward Operators
            Example Optimization and Conditional Expressions
            Example Optimization and Nested Conditional Expressions
            Example Optimization and Cumulative Sum Operations

         Abs-normal Representation of Non-Smooth Functions
        Abs-normal Representation of Non-Smooth Functions
             Create An Abs-normal Representation of a Function
            Create An Abs-normal Representation of a Function
                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

         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 User Atomic Example / Test
            Multi-Threading User Atomic Example / Test
                Defines a User Atomic Operation that Computes Square Root
                Multi-Threaded User Atomic Common Information
                Multi-Threaded User Atomic Set Up
                Multi-Threaded User Atomic Worker
                Multi-Threaded User Atomic Take Down
                Run Multi-Threaded User Atomic Calculation
                Timing Test for Multi-Threaded User Atomic 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

         Definition of a Simple Vector
        Definition of 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
            Rosen34: 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

     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
         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
            Taylor's Ode Solver: An Example and Test
            Example Differentiating a Stack Machine Interpreter

         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

        List All (Except Deprecated) CppAD Examples
        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
            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
            Speed Testing Sparse Hessian
            Speed Testing Sparse Jacobian
            Microsoft Version of Elapsed Number of Seconds

         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
            CppAD Speed: Matrix Multiplication (Double Version)
            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 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

     Appendix
    Appendix
        Frequently Asked Questions and Answers
        Directory Structure
         The Theory of Derivative Calculations
        The Theory of Derivative Calculations
             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

             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

            An Important Reverse Mode Identity

        Glossary
        Bibliography
        The CppAD Wish List
         Changes and Additions to CppAD
        Changes and Additions to CppAD
            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
            Routines That Track Use of New and Delete
                Tracking Use of New and Delete: Example and Test

             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
                OpenMP Memory Allocator: Example and Test

            Memory Leak Detection
            Machine Epsilon For AD Types
            Choosing The Vector Testing Template Class
             Nonlinear Programming Using the CppAD Interface to Ipopt
            Nonlinear Programming Using the CppAD Interface to Ipopt
                Nonlinear Programming Using CppAD and Ipopt: Example and Test
                 Example Simultaneous Solution of Forward and Inverse Problem
                Example Simultaneous Solution of Forward and Inverse Problem
                     An ODE Inverse Problem Example
                    An ODE Inverse Problem Example
                        ODE Inverse Problem Definitions: Source Code

                     ODE Fitting Using Simple Representation
                    ODE Fitting Using Simple Representation
                        ODE Fitting Using Simple Representation

                     ODE Fitting Using Fast Representation
                    ODE Fitting Using Fast Representation
                        ODE Fitting Using Fast Representation

                    Driver for Running the Ipopt ODE Example
                    Correctness Check for Both Simple and Fast Representations

                Speed Test for Both Simple and Fast Representations

             User Defined Atomic AD Functions
            User Defined Atomic AD Functions
                Old Atomic Operation Reciprocal: Example and Test
                Using AD to Compute Atomic Function Derivatives
                Using AD to Compute Atomic Function Derivatives
                Old Tan and Tanh as User Atomic Operations: Example and Test
                 Old Matrix Multiply as a User Atomic Operation: Example and Test
                Old Matrix Multiply as a User Atomic Operation: Example and Test
                    Define Matrix Multiply as a User Atomic Operation

             zdouble: An AD Base Type With Absolute Zero
            zdouble: An AD Base Type With Absolute Zero
                zdouble: Example and Test

            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