Prev Next _contents Headings

Table of Contents

cppad-20150630: A Package for Differentiation of C++ Algorithms
cppad-20150630: 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
                Using ColPack: Example and Test
                Using ColPack: 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
        Auto Tools Unix Test and Installation

     An Introduction by Example to Algorithmic Differentiation
    An Introduction by Example to Algorithmic Differentiation
        Getting Started Using CppAD to Compute Derivatives
         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

             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 Computed Assignments
            AD Arithmetic Operators and Computed 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 Computed Assignment Operators
                AD Computed Assignment Operators
                    AD Computed Assignment Addition: Example and Test
                    AD Computed Assignment Subtraction: Example and Test
                    AD Computed Assignment Multiplication: Example and Test
                    AD Computed 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

                 Numeric Limits For an AD and Base Types
                Numeric Limits For an AD and Base Types
                    Numeric Limits: 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 Standard Math Functions
            The Binary Standard 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

             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

             Atomic AD Functions
            Atomic AD Functions
                 Checkpointing Functions
                Checkpointing Functions
                    Simple Checkpointing: 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 Reverse Mode
                    Atomic Forward Jacobian Sparsity Patterns
                    Atomic Reverse Jacobian Sparsity Patterns
                    Atomic Reverse Hessian Sparsity Patterns
                    Free Static Variables
                    Getting Started with Atomic Operations: Example and Test
                    Euclidean Norm Squared: Example and Test
                    Reciprocal as an Atomic Operation: Example and Test
                    Tan and Tanh as User Atomic Operations: Example and Test
                    Atomic Operation Hessian Sparsity: Example and Test
                     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
             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

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

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

         Evaluate ADFun Functions, Derivatives, and Sparsity Patterns
        Evaluate ADFun Functions, Derivatives, and Sparsity Patterns
             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: Example and Test

             Calculating Sparsity Patterns
            Calculating Sparsity Patterns
                 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

         First and Second Derivatives: Easy Drivers
        First and Second Derivatives: Easy Drivers
             Jacobian: Driver Routine
            Jacobian: Driver Routine
                Jacobian: 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

             Hessian: Easy Driver
            Hessian: Easy Driver
                Hessian: Example and Test
                Hessian of Lagrangian and ADFun Default Constructor: 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

             Sparse Jacobian: Easy Driver
            Sparse Jacobian: Easy Driver
                Sparse Jacobian: Example and Test

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

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

         Optimize an ADFun Object Tape
        Optimize an ADFun Object Tape
            ADFun Operation Sequence Optimization: Example and Test

         Check an ADFun Object For Nan
        Check an ADFun Object For Nan
            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-Threaded Implementation of Summation of 1/i
            Multi-Threaded Implementation of Summation of 1/i
                Timing Test of Multi-Threaded Summation of 1/i
                Multi-threading Sum of 1/i Utility Routines

             A Multi-Threaded Newton's Method
            A Multi-Threaded Newton's Method
                Timing Test of Multi-Threaded Newton Method
                Multi-threading Newton Method Utility Routines

             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

     The CppAD General Purpose Library
    The CppAD General Purpose Library
         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

         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

         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

     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
         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 of All the CppAD Examples
        Using The CppAD Test Vector Template Class

     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
         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
            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
                Tan and Tanh as User Atomic Operations: Example and Test
                 Matrix Multiply as a User Atomic Operation: Example and Test
                Matrix Multiply as a User Atomic Operation: Example and Test
                    Define Matrix Multiply as a User Atomic Operation

         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

        Your License for the CppAD Software

    Alphabetic Listing of Cross Reference Tags
    Keyword Index
    Search This Web Site
    External Internet References