1. CppAD (http://www.coin-or.org/CppAD/) uses operator overloading to compute derivatives of algorithms defined in C++. It is distributed by the COIN-OR Foundation (http://www.coin-or.org/foundation.html) with the Eclipse Public License EPL-1.0 (http://www.opensource.org/licenses/EPL-1.0) or the GNU General Public License GPL-3.0 (http://www.opensource.org/licenses/AGPL-3.0) . Testing and installation is supported for Unix, Microsoft, and Apple operating systems. Extensive user and developer documentation is included.
2. An AD of Base 12.4.g.b: operation sequence is stored as an 5: AD function object which can evaluate function values and derivatives. Arbitrary order 5.3: forward and 5.4: reverse mode derivative calculations can be preformed on the operation sequence. Logical comparisons can be included in an operation sequence using AD 4.4.4: conditional expressions . Evaluation of user defined unary 4.4.5: discrete functions can also be included in the sequence of operations; i.e., functions that depend on the 12.4.k.c: independent variables but which have identically zero derivatives (e.g., a step function).
3. Derivatives of functions that are defined in terms of other derivatives can be computed using multiple levels of AD; see 10.2.10.1: mul_level.cpp for a simple example and 10.2.12: mul_level_ode.cpp for a more realistic example. To this end, CppAD can also be used with other AD types; for example see 10.2.13: mul_level_adolc_ode.cpp .
4. A set of programs for doing 11: speed comparisons between Adolc (https://projects.coin-or.org/ADOL-C) , CppAD, Fadbad (http://www.fadbad.com/) , and Sacado (http://trilinos.sandia.gov/packages/sacado/) are included.
5. Includes a set of C++ 8: utilities that are useful for general operator overloaded numerical method. Allows for replacement of the 10.5: testvector template vector class which is used for extensive testing; for example, you can do your testing with the uBlas (http://www.boost.org/libs/numeric/ublas/doc/index.htm) template vector class.
6. See 12.7: whats_new for a list of recent extensions and bug fixes.

cppad-20171217: A Package for Differentiation of C++ Algorithms: : CppAD
    Table of Contents: 1: _contents
    CppAD Download, Test, and Install Instructions: 2: Install
        Download The CppAD Source Code: 2.1: download
        Using CMake to Configure CppAD: 2.2: cmake
            Including the ADOL-C Examples and Tests: 2.2.1: adolc_prefix
                Download and Install Adolc in Build Directory: 2.2.1.1: get_adolc.sh
            Including the ColPack Sparsity Calculations: 2.2.2: colpack_prefix
                ColPack: Sparse Jacobian Example and Test: 2.2.2.1: colpack_jac.cpp
                ColPack: Sparse Jacobian Example and Test: 2.2.2.2: colpack_jacobian.cpp
                ColPack: Sparse Hessian Example and Test: 2.2.2.3: colpack_hes.cpp
                ColPack: Sparse Hessian Example and Test: 2.2.2.4: colpack_hessian.cpp
                Download and Install ColPack in Build Directory: 2.2.2.5: get_colpack.sh
            Including the Eigen Examples and Tests: 2.2.3: eigen_prefix
                Download and Install Eigen in Build Directory: 2.2.3.1: get_eigen.sh
            Including the FADBAD Speed Tests: 2.2.4: fadbad_prefix
                Download and Install Fadbad in Build Directory: 2.2.4.1: get_fadbad.sh
            Including the cppad_ipopt Library and Tests: 2.2.5: ipopt_prefix
                Download and Install Ipopt in Build Directory: 2.2.5.1: get_ipopt.sh
            Including the Sacado Speed Tests: 2.2.6: sacado_prefix
                Download and Install Sacado in Build Directory: 2.2.6.1: get_sacado.sh
            Choosing the CppAD Test Vector Template Class: 2.2.7: cppad_testvector
        Checking the CppAD Examples and Tests: 2.3: cmake_check
        CppAD pkg-config Files: 2.4: pkgconfig
    An Introduction by Example to Algorithmic Differentiation: 3: Introduction
        Second Order Exponential Approximation: 3.1: exp_2
            exp_2: Implementation: 3.1.1: exp_2.hpp
            exp_2: Test: 3.1.2: exp_2.cpp
            exp_2: Operation Sequence and Zero Order Forward Mode: 3.1.3: exp_2_for0
                exp_2: Verify Zero Order Forward Sweep: 3.1.3.1: exp_2_for0.cpp
            exp_2: First Order Forward Mode: 3.1.4: exp_2_for1
                exp_2: Verify First Order Forward Sweep: 3.1.4.1: exp_2_for1.cpp
            exp_2: First Order Reverse Mode: 3.1.5: exp_2_rev1
                exp_2: Verify First Order Reverse Sweep: 3.1.5.1: exp_2_rev1.cpp
            exp_2: Second Order Forward Mode: 3.1.6: exp_2_for2
                exp_2: Verify Second Order Forward Sweep: 3.1.6.1: exp_2_for2.cpp
            exp_2: Second Order Reverse Mode: 3.1.7: exp_2_rev2
                exp_2: Verify Second Order Reverse Sweep: 3.1.7.1: exp_2_rev2.cpp
            exp_2: CppAD Forward and Reverse Sweeps: 3.1.8: exp_2_cppad
        An Epsilon Accurate Exponential Approximation: 3.2: exp_eps
            exp_eps: Implementation: 3.2.1: exp_eps.hpp
            exp_eps: Test of exp_eps: 3.2.2: exp_eps.cpp
            exp_eps: Operation Sequence and Zero Order Forward Sweep: 3.2.3: exp_eps_for0
                exp_eps: Verify Zero Order Forward Sweep: 3.2.3.1: exp_eps_for0.cpp
            exp_eps: First Order Forward Sweep: 3.2.4: exp_eps_for1
                exp_eps: Verify First Order Forward Sweep: 3.2.4.1: exp_eps_for1.cpp
            exp_eps: First Order Reverse Sweep: 3.2.5: exp_eps_rev1
                exp_eps: Verify First Order Reverse Sweep: 3.2.5.1: exp_eps_rev1.cpp
            exp_eps: Second Order Forward Mode: 3.2.6: exp_eps_for2
                exp_eps: Verify Second Order Forward Sweep: 3.2.6.1: exp_eps_for2.cpp
            exp_eps: Second Order Reverse Sweep: 3.2.7: exp_eps_rev2
                exp_eps: Verify Second Order Reverse Sweep: 3.2.7.1: exp_eps_rev2.cpp
            exp_eps: CppAD Forward and Reverse Sweeps: 3.2.8: exp_eps_cppad
        Correctness Tests For Exponential Approximation in Introduction: 3.3: exp_apx.cpp
    AD Objects: 4: AD
        AD Constructors: 4.1: ad_ctor
            AD Constructors: Example and Test: 4.1.1: ad_ctor.cpp
        AD Assignment Operator: 4.2: ad_assign
            AD Assignment: Example and Test: 4.2.1: ad_assign.cpp
        Conversion and I/O of AD Objects: 4.3: Convert
            Convert From an AD Type to its Base Type: 4.3.1: Value
                Convert From AD to its Base Type: Example and Test: 4.3.1.1: value.cpp
            Convert From AD to Integer: 4.3.2: Integer
                Convert From AD to Integer: Example and Test: 4.3.2.1: integer.cpp
            Convert An AD or Base Type to String: 4.3.3: ad_to_string
            AD Output Stream Operator: 4.3.4: ad_input
                AD Output Operator: Example and Test: 4.3.4.1: ad_input.cpp
            AD Output Stream Operator: 4.3.5: ad_output
                AD Output Operator: Example and Test: 4.3.5.1: ad_output.cpp
            Printing AD Values During Forward Mode: 4.3.6: PrintFor
                Printing During Forward Mode: Example and Test: 4.3.6.1: print_for_cout.cpp
                Print During Zero Order Forward Mode: Example and Test: 4.3.6.2: print_for_string.cpp
            Convert an AD Variable to a Parameter: 4.3.7: Var2Par
                Convert an AD Variable to a Parameter: Example and Test: 4.3.7.1: var2par.cpp
        AD Valued Operations and Functions: 4.4: ADValued
            AD Arithmetic Operators and Compound Assignments: 4.4.1: Arithmetic
                AD Unary Plus Operator: 4.4.1.1: UnaryPlus
                    AD Unary Plus Operator: Example and Test: 4.4.1.1.1: unary_plus.cpp
                AD Unary Minus Operator: 4.4.1.2: UnaryMinus
                    AD Unary Minus Operator: Example and Test: 4.4.1.2.1: unary_minus.cpp
                AD Binary Arithmetic Operators: 4.4.1.3: ad_binary
                    AD Binary Addition: Example and Test: 4.4.1.3.1: add.cpp
                    AD Binary Subtraction: Example and Test: 4.4.1.3.2: sub.cpp
                    AD Binary Multiplication: Example and Test: 4.4.1.3.3: mul.cpp
                    AD Binary Division: Example and Test: 4.4.1.3.4: div.cpp
                AD Compound Assignment Operators: 4.4.1.4: compound_assign
                    AD Compound Assignment Addition: Example and Test: 4.4.1.4.1: AddEq.cpp
                    AD Compound Assignment Subtraction: Example and Test: 4.4.1.4.2: sub_eq.cpp
                    AD Compound Assignment Multiplication: Example and Test: 4.4.1.4.3: mul_eq.cpp
                    AD Compound Assignment Division: Example and Test: 4.4.1.4.4: div_eq.cpp
            The Unary Standard Math Functions: 4.4.2: unary_standard_math
                Inverse Sine Function: acos: 4.4.2.1: acos
                    The AD acos Function: Example and Test: 4.4.2.1.1: acos.cpp
                Inverse Sine Function: asin: 4.4.2.2: asin
                    The AD asin Function: Example and Test: 4.4.2.2.1: asin.cpp
                Inverse Tangent Function: atan: 4.4.2.3: atan
                    The AD atan Function: Example and Test: 4.4.2.3.1: atan.cpp
                The Cosine Function: cos: 4.4.2.4: cos
                    The AD cos Function: Example and Test: 4.4.2.4.1: cos.cpp
                The Hyperbolic Cosine Function: cosh: 4.4.2.5: cosh
                    The AD cosh Function: Example and Test: 4.4.2.5.1: cosh.cpp
                The Exponential Function: exp: 4.4.2.6: exp
                    The AD exp Function: Example and Test: 4.4.2.6.1: exp.cpp
                The Exponential Function: log: 4.4.2.7: log
                    The AD log Function: Example and Test: 4.4.2.7.1: log.cpp
                The Base 10 Logarithm Function: log10: 4.4.2.8: log10
                    The AD log10 Function: Example and Test: 4.4.2.8.1: log10.cpp
                The Sine Function: sin: 4.4.2.9: sin
                    The AD sin Function: Example and Test: 4.4.2.9.1: sin.cpp
                The Hyperbolic Sine Function: sinh: 4.4.2.10: sinh
                    The AD sinh Function: Example and Test: 4.4.2.10.1: sinh.cpp
                The Square Root Function: sqrt: 4.4.2.11: sqrt
                    The AD sqrt Function: Example and Test: 4.4.2.11.1: sqrt.cpp
                The Tangent Function: tan: 4.4.2.12: tan
                    The AD tan Function: Example and Test: 4.4.2.12.1: tan.cpp
                The Hyperbolic Tangent Function: tanh: 4.4.2.13: tanh
                    The AD tanh Function: Example and Test: 4.4.2.13.1: tanh.cpp
                AD Absolute Value Functions: abs, fabs: 4.4.2.14: abs
                    AD Absolute Value Function: Example and Test: 4.4.2.14.1: fabs.cpp
                The Inverse Hyperbolic Cosine Function: acosh: 4.4.2.15: acosh
                    The AD acosh Function: Example and Test: 4.4.2.15.1: acosh.cpp
                The Inverse Hyperbolic Sine Function: asinh: 4.4.2.16: asinh
                    The AD asinh Function: Example and Test: 4.4.2.16.1: asinh.cpp
                The Inverse Hyperbolic Tangent Function: atanh: 4.4.2.17: atanh
                    The AD atanh Function: Example and Test: 4.4.2.17.1: atanh.cpp
                The Error Function: 4.4.2.18: erf
                    The AD erf Function: Example and Test: 4.4.2.18.1: erf.cpp
                The Exponential Function Minus One: expm1: 4.4.2.19: expm1
                    The AD exp Function: Example and Test: 4.4.2.19.1: expm1.cpp
                The Logarithm of One Plus Argument: log1p: 4.4.2.20: log1p
                    The AD log1p Function: Example and Test: 4.4.2.20.1: log1p.cpp
                The Sign: sign: 4.4.2.21: sign
                    Sign Function: Example and Test: 4.4.2.21.1: sign.cpp
            The Binary Math Functions: 4.4.3: binary_math
                AD Two Argument Inverse Tangent Function: 4.4.3.1: atan2
                    The AD atan2 Function: Example and Test: 4.4.3.1.1: atan2.cpp
                The AD Power Function: 4.4.3.2: pow
                    The AD Power Function: Example and Test: 4.4.3.2.1: pow.cpp
                Absolute Zero Multiplication: 4.4.3.3: azmul
                    AD Absolute Zero Multiplication: Example and Test: 4.4.3.3.1: azmul.cpp
            AD Conditional Expressions: 4.4.4: CondExp
                Conditional Expressions: Example and Test: 4.4.4.1: cond_exp.cpp
            Discrete AD Functions: 4.4.5: Discrete
                Taping Array Index Operation: Example and Test: 4.4.5.1: tape_index.cpp
                Interpolation With Out Retaping: Example and Test: 4.4.5.2: interp_onetape.cpp
                Interpolation With Retaping: Example and Test: 4.4.5.3: interp_retape.cpp
            Numeric Limits For an AD and Base Types: 4.4.6: numeric_limits
                Numeric Limits: Example and Test: 4.4.6.1: num_limits.cpp
            Atomic AD Functions: 4.4.7: atomic
                Checkpointing Functions: 4.4.7.1: checkpoint
                    Simple Checkpointing: Example and Test: 4.4.7.1.1: checkpoint.cpp
                    Atomic Operations and Multiple-Levels of AD: Example and Test: 4.4.7.1.2: atomic_mul_level.cpp
                    Checkpointing an ODE Solver: Example and Test: 4.4.7.1.3: checkpoint_ode.cpp
                    Checkpointing an Extended ODE Solver: Example and Test: 4.4.7.1.4: checkpoint_extended_ode.cpp
                User Defined Atomic AD Functions: 4.4.7.2: atomic_base
                    Atomic Function Constructor: 4.4.7.2.1: atomic_ctor
                    Set Atomic Function Options: 4.4.7.2.2: atomic_option
                    Using AD Version of Atomic Function: 4.4.7.2.3: atomic_afun
                    Atomic Forward Mode: 4.4.7.2.4: atomic_forward
                        Atomic Forward: Example and Test: 4.4.7.2.4.1: atomic_forward.cpp
                    Atomic Reverse Mode: 4.4.7.2.5: atomic_reverse
                        Atomic Reverse: Example and Test: 4.4.7.2.5.1: atomic_reverse.cpp
                    Atomic Forward Jacobian Sparsity Patterns: 4.4.7.2.6: atomic_for_sparse_jac
                        Atomic Forward Jacobian Sparsity: Example and Test: 4.4.7.2.6.1: atomic_for_sparse_jac.cpp
                    Atomic Reverse Jacobian Sparsity Patterns: 4.4.7.2.7: atomic_rev_sparse_jac
                        Atomic Reverse Jacobian Sparsity: Example and Test: 4.4.7.2.7.1: atomic_rev_sparse_jac.cpp
                    Atomic Forward Hessian Sparsity Patterns: 4.4.7.2.8: atomic_for_sparse_hes
                        Atomic Forward Hessian Sparsity: Example and Test: 4.4.7.2.8.1: atomic_for_sparse_hes.cpp
                    Atomic Reverse Hessian Sparsity Patterns: 4.4.7.2.9: atomic_rev_sparse_hes
                        Atomic Reverse Hessian Sparsity: Example and Test: 4.4.7.2.9.1: atomic_rev_sparse_hes.cpp
                    Free Static Variables: 4.4.7.2.10: atomic_base_clear
                    Getting Started with Atomic Operations: Example and Test: 4.4.7.2.11: atomic_get_started.cpp
                    Atomic Euclidean Norm Squared: Example and Test: 4.4.7.2.12: atomic_norm_sq.cpp
                    Reciprocal as an Atomic Operation: Example and Test: 4.4.7.2.13: atomic_reciprocal.cpp
                    Atomic Sparsity with Set Patterns: Example and Test: 4.4.7.2.14: atomic_set_sparsity.cpp
                    Tan and Tanh as User Atomic Operations: Example and Test: 4.4.7.2.15: atomic_tangent.cpp
                    Atomic Eigen Matrix Multiply: Example and Test: 4.4.7.2.16: atomic_eigen_mat_mul.cpp
                        Atomic Eigen Matrix Multiply Class: 4.4.7.2.16.1: atomic_eigen_mat_mul.hpp
                    Atomic Eigen Matrix Inverse: Example and Test: 4.4.7.2.17: atomic_eigen_mat_inv.cpp
                        Atomic Eigen Matrix Inversion Class: 4.4.7.2.17.1: atomic_eigen_mat_inv.hpp
                    Atomic Eigen Cholesky Factorization: Example and Test: 4.4.7.2.18: atomic_eigen_cholesky.cpp
                        AD Theory for Cholesky Factorization: 4.4.7.2.18.1: cholesky_theory
                        Atomic Eigen Cholesky Factorization Class: 4.4.7.2.18.2: atomic_eigen_cholesky.hpp
                    User Atomic Matrix Multiply: Example and Test: 4.4.7.2.19: atomic_mat_mul.cpp
                        Matrix Multiply as an Atomic Operation: 4.4.7.2.19.1: atomic_mat_mul.hpp
        Bool Valued Operations and Functions with AD Arguments: 4.5: BoolValued
            AD Binary Comparison Operators: 4.5.1: Compare
                AD Binary Comparison Operators: Example and Test: 4.5.1.1: compare.cpp
            Compare AD and Base Objects for Nearly Equal: 4.5.2: NearEqualExt
                Compare AD with Base Objects: Example and Test: 4.5.2.1: near_equal_ext.cpp
            AD Boolean Functions: 4.5.3: BoolFun
                AD Boolean Functions: Example and Test: 4.5.3.1: bool_fun.cpp
            Is an AD Object a Parameter or Variable: 4.5.4: ParVar
                AD Parameter and Variable Functions: Example and Test: 4.5.4.1: par_var.cpp
            Check if Two Value are Identically Equal: 4.5.5: EqualOpSeq
                EqualOpSeq: Example and Test: 4.5.5.1: equal_op_seq.cpp
        AD Vectors that Record Index Operations: 4.6: VecAD
            AD Vectors that Record Index Operations: Example and Test: 4.6.1: vec_ad.cpp
        AD<Base> Requirements for a CppAD Base Type: 4.7: base_require
            Required Base Class Member Functions: 4.7.1: base_member
            Base Type Requirements for Conditional Expressions: 4.7.2: base_cond_exp
            Base Type Requirements for Identically Equal Comparisons: 4.7.3: base_identical
            Base Type Requirements for Ordered Comparisons: 4.7.4: base_ordered
            Base Type Requirements for Standard Math Functions: 4.7.5: base_std_math
            Base Type Requirements for Numeric Limits: 4.7.6: base_limits
            Extending to_string To Another Floating Point Type: 4.7.7: base_to_string
            Base Type Requirements for Hash Coding Values: 4.7.8: base_hash
            Example AD Base Types That are not AD<OtherBase>: 4.7.9: base_example
                Example AD<Base> Where Base Constructor Allocates Memory: 4.7.9.1: base_alloc.hpp
                Using a User Defined AD Base Type: Example and Test: 4.7.9.2: base_require.cpp
                Enable use of AD<Base> where Base is Adolc's adouble Type: 4.7.9.3: base_adolc.hpp
                    Using Adolc with Multiple Levels of Taping: Example and Test: 4.7.9.3.1: mul_level_adolc.cpp
                Enable use of AD<Base> where Base is float: 4.7.9.4: base_float.hpp
                Enable use of AD<Base> where Base is double: 4.7.9.5: base_double.hpp
                Enable use of AD<Base> where Base is std::complex<double>: 4.7.9.6: base_complex.hpp
                    Complex Polynomial: Example and Test: 4.7.9.6.1: complex_poly.cpp
    ADFun Objects: 5: ADFun
        Create an ADFun Object (Record an Operation Sequence): 5.1: record_adfun
            Declare Independent Variables and Start Recording: 5.1.1: Independent
                Independent and ADFun Constructor: Example and Test: 5.1.1.1: independent.cpp
            Construct an ADFun Object and Stop Recording: 5.1.2: FunConstruct
                ADFun Assignment: Example and Test: 5.1.2.1: fun_assign.cpp
            Stop Recording and Store Operation Sequence: 5.1.3: Dependent
            Abort Recording of an Operation Sequence: 5.1.4: abort_recording
                Abort Current Recording: Example and Test: 5.1.4.1: abort_recording.cpp
            ADFun Sequence Properties: 5.1.5: seq_property
                ADFun Sequence Properties: Example and Test: 5.1.5.1: seq_property.cpp
        First and Second Order Derivatives: Easy Drivers: 5.2: drivers
            Jacobian: Driver Routine: 5.2.1: Jacobian
                Jacobian: Example and Test: 5.2.1.1: jacobian.cpp
            Hessian: Easy Driver: 5.2.2: Hessian
                Hessian: Example and Test: 5.2.2.1: hessian.cpp
                Hessian of Lagrangian and ADFun Default Constructor: Example and Test: 5.2.2.2: hes_lagrangian.cpp
            First Order Partial Derivative: Driver Routine: 5.2.3: ForOne
                First Order Partial Driver: Example and Test: 5.2.3.1: for_one.cpp
            First Order Derivative: Driver Routine: 5.2.4: RevOne
                First Order Derivative Driver: Example and Test: 5.2.4.1: rev_one.cpp
            Forward Mode Second Partial Derivative Driver: 5.2.5: ForTwo
                Subset of Second Order Partials: Example and Test: 5.2.5.1: for_two.cpp
            Reverse Mode Second Partial Derivative Driver: 5.2.6: RevTwo
                Second Partials Reverse Driver: Example and Test: 5.2.6.1: rev_two.cpp
        Forward Mode: 5.3: Forward
            Zero Order Forward Mode: Function Values: 5.3.1: forward_zero
            First Order Forward Mode: Derivative Values: 5.3.2: forward_one
            Second Order Forward Mode: Derivative Values: 5.3.3: forward_two
            Multiple Order Forward Mode: 5.3.4: forward_order
                Forward Mode: Example and Test: 5.3.4.1: forward.cpp
                Forward Mode: Example and Test of Multiple Orders: 5.3.4.2: forward_order.cpp
            Multiple Directions Forward Mode: 5.3.5: forward_dir
                Forward Mode: Example and Test of Multiple Directions: 5.3.5.1: forward_dir.cpp
            Number Taylor Coefficient Orders Currently Stored: 5.3.6: size_order
            Comparison Changes Between Taping and Zero Order Forward: 5.3.7: compare_change
                CompareChange and Re-Tape: Example and Test: 5.3.7.1: compare_change.cpp
            Controlling Taylor Coefficients Memory Allocation: 5.3.8: capacity_order
                Controlling Taylor Coefficient Memory Allocation: Example and Test: 5.3.8.1: capacity_order.cpp
            Number of Variables that Can be Skipped: 5.3.9: number_skip
                Number of Variables That Can be Skipped: Example and Test: 5.3.9.1: number_skip.cpp
        Reverse Mode: 5.4: Reverse
            First Order Reverse Mode: 5.4.1: reverse_one
                First Order Reverse Mode: Example and Test: 5.4.1.1: reverse_one.cpp
            Second Order Reverse Mode: 5.4.2: reverse_two
                Second Order Reverse ModeExample and Test: 5.4.2.1: reverse_two.cpp
                Hessian Times Direction: Example and Test: 5.4.2.2: hes_times_dir.cpp
            Any Order Reverse Mode: 5.4.3: reverse_any
                Third Order Reverse Mode: Example and Test: 5.4.3.1: reverse_three.cpp
                Reverse Mode General Case (Checkpointing): Example and Test: 5.4.3.2: reverse_checkpoint.cpp
            Reverse Mode Using Subgraphs: 5.4.4: subgraph_reverse
                Computing Reverse Mode on Subgraphs: Example and Test: 5.4.4.1: subgraph_reverse.cpp
        Calculating Sparsity Patterns: 5.5: sparsity_pattern
            Forward Mode Jacobian Sparsity Patterns: 5.5.1: for_jac_sparsity
                Forward Mode Jacobian Sparsity: Example and Test: 5.5.1.1: for_jac_sparsity.cpp
            Jacobian Sparsity Pattern: Forward Mode: 5.5.2: ForSparseJac
                Forward Mode Jacobian Sparsity: Example and Test: 5.5.2.1: for_sparse_jac.cpp
            Reverse Mode Jacobian Sparsity Patterns: 5.5.3: rev_jac_sparsity
                Reverse Mode Jacobian Sparsity: Example and Test: 5.5.3.1: rev_jac_sparsity.cpp
            Jacobian Sparsity Pattern: Reverse Mode: 5.5.4: RevSparseJac
                Reverse Mode Jacobian Sparsity: Example and Test: 5.5.4.1: rev_sparse_jac.cpp
            Reverse Mode Hessian Sparsity Patterns: 5.5.5: rev_hes_sparsity
                Reverse Mode Hessian Sparsity: Example and Test: 5.5.5.1: rev_hes_sparsity.cpp
            Hessian Sparsity Pattern: Reverse Mode: 5.5.6: RevSparseHes
                Reverse Mode Hessian Sparsity: Example and Test: 5.5.6.1: rev_sparse_hes.cpp
                Sparsity Patterns For a Subset of Variables: Example and Test: 5.5.6.2: sparsity_sub.cpp
            Forward Mode Hessian Sparsity Patterns: 5.5.7: for_hes_sparsity
                Forward Mode Hessian Sparsity: Example and Test: 5.5.7.1: for_hes_sparsity.cpp
            Hessian Sparsity Pattern: Forward Mode: 5.5.8: ForSparseHes
                Forward Mode Hessian Sparsity: Example and Test: 5.5.8.1: for_sparse_hes.cpp
            Computing Dependency: Example and Test: 5.5.9: dependency.cpp
            Preferred Sparsity Patterns: Row and Column Indices: Example and Test: 5.5.10: rc_sparsity.cpp
            Subgraph Dependency Sparsity Patterns: 5.5.11: subgraph_sparsity
                Subgraph Dependency Sparsity Patterns: Example and Test: 5.5.11.1: subgraph_sparsity.cpp
        Calculating Sparse Derivatives: 5.6: sparse_derivative
            Computing Sparse Jacobians: 5.6.1: sparse_jac
                Computing Sparse Jacobian Using Forward Mode: Example and Test: 5.6.1.1: sparse_jac_for.cpp
                Computing Sparse Jacobian Using Reverse Mode: Example and Test: 5.6.1.2: sparse_jac_rev.cpp
            Sparse Jacobian: 5.6.2: sparse_jacobian
                Sparse Jacobian: Example and Test: 5.6.2.1: sparse_jacobian.cpp
            Computing Sparse Hessians: 5.6.3: sparse_hes
                Computing Sparse Hessian: Example and Test: 5.6.3.1: sparse_hes.cpp
            Sparse Hessian: 5.6.4: sparse_hessian
                Sparse Hessian: Example and Test: 5.6.4.1: sparse_hessian.cpp
                Computing Sparse Hessian for a Subset of Variables: 5.6.4.2: sub_sparse_hes.cpp
                Subset of a Sparse Hessian: Example and Test: 5.6.4.3: sparse_sub_hes.cpp
            Compute Sparse Jacobians Using Subgraphs: 5.6.5: subgraph_jac_rev
                Computing Sparse Jacobian Using Reverse Mode: Example and Test: 5.6.5.1: subgraph_jac_rev.cpp
                Sparse Hessian Using Subgraphs and Jacobian: Example and Test: 5.6.5.2: subgraph_hes2jac.cpp
        Optimize an ADFun Object Tape: 5.7: optimize
            Example Optimization and Forward Activity Analysis: 5.7.1: optimize_forward_active.cpp
            Example Optimization and Reverse Activity Analysis: 5.7.2: optimize_reverse_active.cpp
            Example Optimization and Comparison Operators: 5.7.3: optimize_compare_op.cpp
            Example Optimization and Print Forward Operators: 5.7.4: optimize_print_for.cpp
            Example Optimization and Conditional Expressions: 5.7.5: optimize_conditional_skip.cpp
            Example Optimization and Nested Conditional Expressions: 5.7.6: optimize_nest_conditional.cpp
            Example Optimization and Cumulative Sum Operations: 5.7.7: optimize_cumulative_sum.cpp
        Abs-normal Representation of Non-Smooth Functions: 5.8: abs_normal
            Create An Abs-normal Representation of a Function: 5.8.1: abs_normal_fun
                abs_normal Getting Started: Example and Test: 5.8.1.1: abs_get_started.cpp
            abs_normal: Print a Vector or Matrix: 5.8.2: abs_print_mat
            abs_normal: Evaluate First Order Approximation: 5.8.3: abs_eval
                abs_eval: Example and Test: 5.8.3.1: abs_eval.cpp
                abs_eval Source Code: 5.8.3.2: abs_eval.hpp
            abs_normal: Solve a Linear Program Using Simplex Method: 5.8.4: simplex_method
                abs_normal simplex_method: Example and Test: 5.8.4.1: simplex_method.cpp
                simplex_method Source Code: 5.8.4.2: simplex_method.hpp
            abs_normal: Solve a Linear Program With Box Constraints: 5.8.5: lp_box
                abs_normal lp_box: Example and Test: 5.8.5.1: lp_box.cpp
                lp_box Source Code: 5.8.5.2: lp_box.hpp
            abs_normal: Minimize a Linear Abs-normal Approximation: 5.8.6: abs_min_linear
                abs_min_linear: Example and Test: 5.8.6.1: abs_min_linear.cpp
                abs_min_linear Source Code: 5.8.6.2: abs_min_linear.hpp
            Non-Smooth Optimization Using Abs-normal Linear Approximations: 5.8.7: min_nso_linear
                abs_normal min_nso_linear: Example and Test: 5.8.7.1: min_nso_linear.cpp
                min_nso_linear Source Code: 5.8.7.2: min_nso_linear.hpp
            Solve a Quadratic Program Using Interior Point Method: 5.8.8: qp_interior
                abs_normal qp_interior: Example and Test: 5.8.8.1: qp_interior.cpp
                qp_interior Source Code: 5.8.8.2: qp_interior.hpp
            abs_normal: Solve a Quadratic Program With Box Constraints: 5.8.9: qp_box
                abs_normal qp_box: Example and Test: 5.8.9.1: qp_box.cpp
                qp_box Source Code: 5.8.9.2: qp_box.hpp
            abs_normal: Minimize a Linear Abs-normal Approximation: 5.8.10: abs_min_quad
                abs_min_quad: Example and Test: 5.8.10.1: abs_min_quad.cpp
                abs_min_quad Source Code: 5.8.10.2: abs_min_quad.hpp
            Non-Smooth Optimization Using Abs-normal Quadratic Approximations: 5.8.11: min_nso_quad
                abs_normal min_nso_quad: Example and Test: 5.8.11.1: min_nso_quad.cpp
                min_nso_quad Source Code: 5.8.11.2: min_nso_quad.hpp
        Check an ADFun Sequence of Operations: 5.9: FunCheck
            ADFun Check and Re-Tape: Example and Test: 5.9.1: fun_check.cpp
        Check an ADFun Object For Nan Results: 5.10: check_for_nan
            ADFun Checking For Nan: Example and Test: 5.10.1: check_for_nan.cpp
    CppAD API Preprocessor Symbols: 6: preprocessor
    Using CppAD in a Multi-Threading Environment: 7: multi_thread
        Enable AD Calculations During Parallel Mode: 7.1: parallel_ad
        Run Multi-Threading Examples and Speed Tests: 7.2: thread_test.cpp
            A Simple OpenMP Example and Test: 7.2.1: a11c_openmp.cpp
            A Simple Boost Thread Example and Test: 7.2.2: a11c_bthread.cpp
            A Simple Parallel Pthread Example and Test: 7.2.3: a11c_pthread.cpp
            A Simple OpenMP AD: Example and Test: 7.2.4: simple_ad_openmp.cpp
            A Simple Boost Threading AD: Example and Test: 7.2.5: simple_ad_bthread.cpp
            A Simple pthread AD: Example and Test: 7.2.6: simple_ad_pthread.cpp
            Using a Team of AD Threads: Example and Test: 7.2.7: team_example.cpp
            Multi-Threading Harmonic Summation Example / Test: 7.2.8: harmonic.cpp
                Common Variables Used by Multi-threading Sum of 1/i: 7.2.8.1: harmonic_common
                Set Up Multi-threading Sum of 1/i: 7.2.8.2: harmonic_setup
                Do One Thread's Work for Sum of 1/i: 7.2.8.3: harmonic_worker
                Take Down Multi-threading Sum of 1/i: 7.2.8.4: harmonic_takedown
                Multi-Threaded Implementation of Summation of 1/i: 7.2.8.5: harmonic_sum
                Timing Test of Multi-Threaded Summation of 1/i: 7.2.8.6: harmonic_time
            Multi-Threading User Atomic Example / Test: 7.2.9: multi_atomic.cpp
                Defines a User Atomic Operation that Computes Square Root: 7.2.9.1: multi_atomic_user
                Multi-Threaded User Atomic Common Information: 7.2.9.2: multi_atomic_common
                Multi-Threaded User Atomic Set Up: 7.2.9.3: multi_atomic_setup
                Multi-Threaded User Atomic Worker: 7.2.9.4: multi_atomic_worker
                Multi-Threaded User Atomic Take Down: 7.2.9.5: multi_atomic_takedown
                Run Multi-Threaded User Atomic Calculation: 7.2.9.6: multi_atomic_run
                Timing Test for Multi-Threaded User Atomic Calculation: 7.2.9.7: multi_atomic_time
            Multi-Threaded Newton Method Example / Test: 7.2.10: multi_newton.cpp
                Common Variables use by Multi-Threaded Newton Method: 7.2.10.1: multi_newton_common
                Set Up Multi-Threaded Newton Method: 7.2.10.2: multi_newton_setup
                Do One Thread's Work for Multi-Threaded Newton Method: 7.2.10.3: multi_newton_worker
                Take Down Multi-threaded Newton Method: 7.2.10.4: multi_newton_takedown
                A Multi-Threaded Newton's Method: 7.2.10.5: multi_newton_run
                Timing Test of Multi-Threaded Newton Method: 7.2.10.6: multi_newton_time
            Specifications for A Team of AD Threads: 7.2.11: team_thread.hpp
                OpenMP Implementation of a Team of AD Threads: 7.2.11.1: team_openmp.cpp
                Boost Thread Implementation of a Team of AD Threads: 7.2.11.2: team_bthread.cpp
                Pthread Implementation of a Team of AD Threads: 7.2.11.3: team_pthread.cpp
    Some General Purpose Utilities: 8: utility
        Replacing the CppAD Error Handler: 8.1: ErrorHandler
            Replacing The CppAD Error Handler: Example and Test: 8.1.1: error_handler.cpp
            CppAD Assertions During Execution: 8.1.2: cppad_assert
        Determine if Two Values Are Nearly Equal: 8.2: NearEqual
            NearEqual Function: Example and Test: 8.2.1: near_equal.cpp
        Run One Speed Test and Return Results: 8.3: speed_test
            speed_test: Example and test: 8.3.1: speed_test.cpp
        Run One Speed Test and Print Results: 8.4: SpeedTest
            Example Use of SpeedTest: 8.4.1: speed_program.cpp
        Determine Amount of Time to Execute a Test: 8.5: time_test
            Returns Elapsed Number of Seconds: 8.5.1: elapsed_seconds
                Elapsed Seconds: Example and Test: 8.5.1.1: elapsed_seconds.cpp
            time_test: Example and test: 8.5.2: time_test.cpp
        Object that Runs a Group of Tests: 8.6: test_boolofvoid
        Definition of a Numeric Type: 8.7: NumericType
            The NumericType: Example and Test: 8.7.1: numeric_type.cpp
        Check NumericType Class Concept: 8.8: CheckNumericType
            The CheckNumericType Function: Example and Test: 8.8.1: check_numeric_type.cpp
        Definition of a Simple Vector: 8.9: SimpleVector
            Simple Vector Template Class: Example and Test: 8.9.1: simple_vector.cpp
        Check Simple Vector Concept: 8.10: CheckSimpleVector
            The CheckSimpleVector Function: Example and Test: 8.10.1: check_simple_vector.cpp
        Obtain Nan or Determine if a Value is Nan: 8.11: nan
            nan: Example and Test: 8.11.1: nan.cpp
        The Integer Power Function: 8.12: pow_int
            The Pow Integer Exponent: Example and Test: 8.12.1: pow_int.cpp
        Evaluate a Polynomial or its Derivative: 8.13: Poly
            Polynomial Evaluation: Example and Test: 8.13.1: poly.cpp
            Source: Poly: 8.13.2: poly.hpp
        Compute Determinants and Solve Equations by LU Factorization: 8.14: LuDetAndSolve
            Compute Determinant and Solve Linear Equations: 8.14.1: LuSolve
                LuSolve With Complex Arguments: Example and Test: 8.14.1.1: lu_solve.cpp
                Source: LuSolve: 8.14.1.2: lu_solve.hpp
            LU Factorization of A Square Matrix: 8.14.2: LuFactor
                LuFactor: Example and Test: 8.14.2.1: lu_factor.cpp
                Source: LuFactor: 8.14.2.2: lu_factor.hpp
            Invert an LU Factored Equation: 8.14.3: LuInvert
                LuInvert: Example and Test: 8.14.3.1: lu_invert.cpp
                Source: LuInvert: 8.14.3.2: lu_invert.hpp
        One DimensionalRomberg Integration: 8.15: RombergOne
            One Dimensional Romberg Integration: Example and Test: 8.15.1: romberg_one.cpp
        Multi-dimensional Romberg Integration: 8.16: RombergMul
            One Dimensional Romberg Integration: Example and Test: 8.16.1: Rombergmul.cpp
        An Embedded 4th and 5th Order Runge-Kutta ODE Solver: 8.17: Runge45
            Runge45: Example and Test: 8.17.1: runge45_1.cpp
            Runge45: Example and Test: 8.17.2: runge45_2.cpp
        A 3rd and 4th Order Rosenbrock ODE Solver: 8.18: Rosen34
            Rosen34: Example and Test: 8.18.1: rosen_34.cpp
        An Error Controller for ODE Solvers: 8.19: OdeErrControl
            OdeErrControl: Example and Test: 8.19.1: ode_err_control.cpp
            OdeErrControl: Example and Test Using Maxabs Argument: 8.19.2: ode_err_maxabs.cpp
        An Arbitrary Order Gear Method: 8.20: OdeGear
            OdeGear: Example and Test: 8.20.1: ode_gear.cpp
        An Error Controller for Gear's Ode Solvers: 8.21: OdeGearControl
            OdeGearControl: Example and Test: 8.21.1: ode_gear_control.cpp
        The CppAD::vector Template Class: 8.22: CppAD_vector
            CppAD::vector Template Class: Example and Test: 8.22.1: cppad_vector.cpp
            CppAD::vectorBool Class: Example and Test: 8.22.2: vector_bool.cpp
        A Fast Multi-Threading Memory Allocator: 8.23: thread_alloc
            Fast Multi-Threading Memory Allocator: Example and Test: 8.23.1: thread_alloc.cpp
            Setup thread_alloc For Use in Multi-Threading Environment: 8.23.2: ta_parallel_setup
            Get Number of Threads: 8.23.3: ta_num_threads
            Is The Current Execution in Parallel Mode: 8.23.4: ta_in_parallel
            Get the Current Thread Number: 8.23.5: ta_thread_num
            Get At Least A Specified Amount of Memory: 8.23.6: ta_get_memory
            Return Memory to thread_alloc: 8.23.7: ta_return_memory
            Free Memory Currently Available for Quick Use by a Thread: 8.23.8: ta_free_available
            Control When Thread Alloc Retains Memory For Future Use: 8.23.9: ta_hold_memory
            Amount of Memory a Thread is Currently Using: 8.23.10: ta_inuse
            Amount of Memory Available for Quick Use by a Thread: 8.23.11: ta_available
            Allocate An Array and Call Default Constructor for its Elements: 8.23.12: ta_create_array
            Deallocate An Array and Call Destructor for its Elements: 8.23.13: ta_delete_array
            Free All Memory That Was Allocated for Use by thread_alloc: 8.23.14: ta_free_all
        Returns Indices that Sort a Vector: 8.24: index_sort
            Index Sort: Example and Test: 8.24.1: index_sort.cpp
        Convert Certain Types to a String: 8.25: to_string
            to_string: Example and Test: 8.25.1: to_string.cpp
        Union of Standard Sets: 8.26: set_union
            Set Union: Example and Test: 8.26.1: set_union.cpp
        Row and Column Index Sparsity Patterns: 8.27: sparse_rc
            sparse_rc: Example and Test: 8.27.1: sparse_rc.cpp
        Sparse Matrix Row, Column, Value Representation: 8.28: sparse_rcv
            sparse_rcv: Example and Test: 8.28.1: sparse_rcv.cpp
    Use Ipopt to Solve a Nonlinear Programming Problem: 9: ipopt_solve
        Nonlinear Programming Using CppAD and Ipopt: Example and Test: 9.1: ipopt_solve_get_started.cpp
        Nonlinear Programming Retaping: Example and Test: 9.2: ipopt_solve_retape.cpp
        ODE Inverse Problem Definitions: Source Code: 9.3: ipopt_solve_ode_inverse.cpp
    Examples: 10: Example
        Getting Started Using CppAD to Compute Derivatives: 10.1: get_started.cpp
        General Examples: 10.2: General
            Creating Your Own Interface to an ADFun Object: 10.2.1: ad_fun.cpp
            Example and Test Linking CppAD to Languages Other than C++: 10.2.2: ad_in_c.cpp
            Differentiate Conjugate Gradient Algorithm: Example and Test: 10.2.3: conj_grad.cpp
            Enable Use of Eigen Linear Algebra Package with CppAD: 10.2.4: cppad_eigen.hpp
                Source Code for eigen_plugin.hpp: 10.2.4.1: eigen_plugin.hpp
                Using Eigen Arrays: Example and Test: 10.2.4.2: eigen_array.cpp
                Using Eigen To Compute Determinant: Example and Test: 10.2.4.3: eigen_det.cpp
            Gradient of Determinant Using Expansion by Minors: Example and Test: 10.2.5: hes_minor_det.cpp
            Gradient of Determinant Using LU Factorization: Example and Test: 10.2.6: hes_lu_det.cpp
            Interfacing to C: Example and Test: 10.2.7: interface2c.cpp
            Gradient of Determinant Using Expansion by Minors: Example and Test: 10.2.8: jac_minor_det.cpp
            Gradient of Determinant Using Lu Factorization: Example and Test: 10.2.9: jac_lu_det.cpp
            Using Multiple Levels of AD: 10.2.10: mul_level
                Multiple Level of AD: Example and Test: 10.2.10.1: mul_level.cpp
                Computing a Jacobian With Constants that Change: 10.2.10.2: change_param.cpp
            A Stiff Ode: Example and Test: 10.2.11: ode_stiff.cpp
            Taylor's Ode Solver: A Multi-Level AD Example and Test: 10.2.12: mul_level_ode.cpp
            Taylor's Ode Solver: A Multi-Level Adolc Example and Test: 10.2.13: mul_level_adolc_ode.cpp
            Taylor's Ode Solver: An Example and Test: 10.2.14: ode_taylor.cpp
            Example Differentiating a Stack Machine Interpreter: 10.2.15: stack_machine.cpp
        Utility Routines used by CppAD Examples: 10.3: ExampleUtility
            CppAD Examples and Tests: 10.3.1: general.cpp
            Run the Speed Examples: 10.3.2: speed_example.cpp
            Lu Factor and Solve with Recorded Pivoting: 10.3.3: lu_vec_ad.cpp
                Lu Factor and Solve With Recorded Pivoting: Example and Test: 10.3.3.1: lu_vec_ad_ok.cpp
        List All (Except Deprecated) CppAD Examples: 10.4: ListAllExamples
        Using The CppAD Test Vector Template Class: 10.5: testvector
        Suppress Suspect Implicit Conversion Warnings: 10.6: wno_conversion
    Speed Test an Operator Overloading AD Package: 11: speed
        Running the Speed Test Program: 11.1: speed_main
            Speed Testing Gradient of Determinant Using Lu Factorization: 11.1.1: link_det_lu
            Speed Testing Gradient of Determinant by Minor Expansion: 11.1.2: link_det_minor
            Speed Testing Derivative of Matrix Multiply: 11.1.3: link_mat_mul
            Speed Testing the Jacobian of Ode Solution: 11.1.4: link_ode
            Speed Testing Second Derivative of a Polynomial: 11.1.5: link_poly
            Speed Testing Sparse Hessian: 11.1.6: link_sparse_hessian
            Speed Testing Sparse Jacobian: 11.1.7: link_sparse_jacobian
            Microsoft Version of Elapsed Number of Seconds: 11.1.8: microsoft_timer
        Speed Testing Utilities: 11.2: speed_utility
            Determinant Using Expansion by Lu Factorization: 11.2.1: det_by_lu
                Determinant Using Lu Factorization: Example and Test: 11.2.1.1: det_by_lu.cpp
                Source: det_by_lu: 11.2.1.2: det_by_lu.hpp
            Determinant of a Minor: 11.2.2: det_of_minor
                Determinant of a Minor: Example and Test: 11.2.2.1: det_of_minor.cpp
                Source: det_of_minor: 11.2.2.2: det_of_minor.hpp
            Determinant Using Expansion by Minors: 11.2.3: det_by_minor
                Determinant Using Expansion by Minors: Example and Test: 11.2.3.1: det_by_minor.cpp
                Source: det_by_minor: 11.2.3.2: det_by_minor.hpp
            Check Determinant of 3 by 3 matrix: 11.2.4: det_33
                Source: det_33: 11.2.4.1: det_33.hpp
            Check Gradient of Determinant of 3 by 3 matrix: 11.2.5: det_grad_33
                Source: det_grad_33: 11.2.5.1: det_grad_33.hpp
            Sum Elements of a Matrix Times Itself: 11.2.6: mat_sum_sq
                Sum of the Elements of the Square of a Matrix: Example and Test: 11.2.6.1: mat_sum_sq.cpp
                Source: mat_sum_sq: 11.2.6.2: mat_sum_sq.hpp
            Evaluate a Function Defined in Terms of an ODE: 11.2.7: ode_evaluate
                ode_evaluate: Example and test: 11.2.7.1: ode_evaluate.cpp
                Source: ode_evaluate: 11.2.7.2: ode_evaluate.hpp
            Evaluate a Function That Has a Sparse Jacobian: 11.2.8: sparse_jac_fun
                sparse_jac_fun: Example and test: 11.2.8.1: sparse_jac_fun.cpp
                Source: sparse_jac_fun: 11.2.8.2: sparse_jac_fun.hpp
            Evaluate a Function That Has a Sparse Hessian: 11.2.9: sparse_hes_fun
                sparse_hes_fun: Example and test: 11.2.9.1: sparse_hes_fun.cpp
                Source: sparse_hes_fun: 11.2.9.2: sparse_hes_fun.hpp
            Simulate a [0,1] Uniform Random Variate: 11.2.10: uniform_01
                Source: uniform_01: 11.2.10.1: uniform_01.hpp
        Speed Test of Functions in Double: 11.3: speed_double
            Double Speed: Determinant by Minor Expansion: 11.3.1: double_det_minor.cpp
            Double Speed: Determinant Using Lu Factorization: 11.3.2: double_det_lu.cpp
            CppAD Speed: Matrix Multiplication (Double Version): 11.3.3: double_mat_mul.cpp
            Double Speed: Ode Solution: 11.3.4: double_ode.cpp
            Double Speed: Evaluate a Polynomial: 11.3.5: double_poly.cpp
            Double Speed: Sparse Hessian: 11.3.6: double_sparse_hessian.cpp
            Double Speed: Sparse Jacobian: 11.3.7: double_sparse_jacobian.cpp
        Speed Test of Derivatives Using Adolc: 11.4: speed_adolc
            Adolc Speed: Gradient of Determinant by Minor Expansion: 11.4.1: adolc_det_minor.cpp
            Adolc Speed: Gradient of Determinant Using Lu Factorization: 11.4.2: adolc_det_lu.cpp
            Adolc Speed: Matrix Multiplication: 11.4.3: adolc_mat_mul.cpp
            Adolc Speed: Ode: 11.4.4: adolc_ode.cpp
            Adolc Speed: Second Derivative of a Polynomial: 11.4.5: adolc_poly.cpp
            Adolc Speed: Sparse Hessian: 11.4.6: adolc_sparse_hessian.cpp
            adolc Speed: Sparse Jacobian: 11.4.7: adolc_sparse_jacobian.cpp
            Adolc Test Utility: Allocate and Free Memory For a Matrix: 11.4.8: adolc_alloc_mat
        Speed Test Derivatives Using CppAD: 11.5: speed_cppad
            CppAD Speed: Gradient of Determinant by Minor Expansion: 11.5.1: cppad_det_minor.cpp
            CppAD Speed: Gradient of Determinant Using Lu Factorization: 11.5.2: cppad_det_lu.cpp
            CppAD Speed, Matrix Multiplication: 11.5.3: cppad_mat_mul.cpp
            CppAD Speed: Gradient of Ode Solution: 11.5.4: cppad_ode.cpp
            CppAD Speed: Second Derivative of a Polynomial: 11.5.5: cppad_poly.cpp
            CppAD Speed: Sparse Hessian: 11.5.6: cppad_sparse_hessian.cpp
            CppAD Speed: Sparse Jacobian: 11.5.7: cppad_sparse_jacobian.cpp
        Speed Test Derivatives Using Fadbad: 11.6: speed_fadbad
            Fadbad Speed: Gradient of Determinant by Minor Expansion: 11.6.1: fadbad_det_minor.cpp
            Fadbad Speed: Gradient of Determinant Using Lu Factorization: 11.6.2: fadbad_det_lu.cpp
            Fadbad Speed: Matrix Multiplication: 11.6.3: fadbad_mat_mul.cpp
            Fadbad Speed: Ode: 11.6.4: fadbad_ode.cpp
            Fadbad Speed: Second Derivative of a Polynomial: 11.6.5: fadbad_poly.cpp
            Fadbad Speed: Sparse Hessian: 11.6.6: fadbad_sparse_hessian.cpp
            fadbad Speed: sparse_jacobian: 11.6.7: fadbad_sparse_jacobian.cpp
        Speed Test Derivatives Using Sacado: 11.7: speed_sacado
            Sacado Speed: Gradient of Determinant by Minor Expansion: 11.7.1: sacado_det_minor.cpp
            Sacado Speed: Gradient of Determinant Using Lu Factorization: 11.7.2: sacado_det_lu.cpp
            Sacado Speed: Matrix Multiplication: 11.7.3: sacado_mat_mul.cpp
            Sacado Speed: Gradient of Ode Solution: 11.7.4: sacado_ode.cpp
            Sacado Speed: Second Derivative of a Polynomial: 11.7.5: sacado_poly.cpp
            Sacado Speed: Sparse Hessian: 11.7.6: sacado_sparse_hessian.cpp
            sacado Speed: sparse_jacobian: 11.7.7: sacado_sparse_jacobian.cpp
    Appendix: 12: Appendix
        Frequently Asked Questions and Answers: 12.1: Faq
        Directory Structure: 12.2: directory
        The Theory of Derivative Calculations: 12.3: Theory
            The Theory of Forward Mode: 12.3.1: ForwardTheory
                Exponential Function Forward Mode Theory: 12.3.1.1: exp_forward
                Logarithm Function Forward Mode Theory: 12.3.1.2: log_forward
                Square Root Function Forward Mode Theory: 12.3.1.3: sqrt_forward
                Trigonometric and Hyperbolic Sine and Cosine Forward Theory: 12.3.1.4: sin_cos_forward
                Inverse Tangent and Hyperbolic Tangent Forward Mode Theory: 12.3.1.5: atan_forward
                Inverse Sine and Hyperbolic Sine Forward Mode Theory: 12.3.1.6: asin_forward
                Inverse Cosine and Hyperbolic Cosine Forward Mode Theory: 12.3.1.7: acos_forward
                Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory: 12.3.1.8: tan_forward
                Error Function Forward Taylor Polynomial Theory: 12.3.1.9: erf_forward
            The Theory of Reverse Mode: 12.3.2: ReverseTheory
                Exponential Function Reverse Mode Theory: 12.3.2.1: exp_reverse
                Logarithm Function Reverse Mode Theory: 12.3.2.2: log_reverse
                Square Root Function Reverse Mode Theory: 12.3.2.3: sqrt_reverse
                Trigonometric and Hyperbolic Sine and Cosine Reverse Theory: 12.3.2.4: sin_cos_reverse
                Inverse Tangent and Hyperbolic Tangent Reverse Mode Theory: 12.3.2.5: atan_reverse
                Inverse Sine and Hyperbolic Sine Reverse Mode Theory: 12.3.2.6: asin_reverse
                Inverse Cosine and Hyperbolic Cosine Reverse Mode Theory: 12.3.2.7: acos_reverse
                Tangent and Hyperbolic Tangent Reverse Mode Theory: 12.3.2.8: tan_reverse
                Error Function Reverse Mode Theory: 12.3.2.9: erf_reverse
            An Important Reverse Mode Identity: 12.3.3: reverse_identity
        Glossary: 12.4: glossary
        Bibliography: 12.5: Bib
        The CppAD Wish List: 12.6: wish_list
        Changes and Additions to CppAD: 12.7: whats_new
            Changes and Additions to CppAD During 2017: 12.7.1: whats_new_17
            Changes and Additions to CppAD During 2016: 12.7.2: whats_new_16
            CppAD Changes and Additions During 2015: 12.7.3: whats_new_15
            CppAD Changes and Additions During 2014: 12.7.4: whats_new_14
            CppAD Changes and Additions During 2013: 12.7.5: whats_new_13
            CppAD Changes and Additions During 2012: 12.7.6: whats_new_12
            Changes and Additions to CppAD During 2011: 12.7.7: whats_new_11
            Changes and Additions to CppAD During 2010: 12.7.8: whats_new_10
            Changes and Additions to CppAD During 2009: 12.7.9: whats_new_09
            Changes and Additions to CppAD During 2008: 12.7.10: whats_new_08
            Changes and Additions to CppAD During 2007: 12.7.11: whats_new_07
            Changes and Additions to CppAD During 2006: 12.7.12: whats_new_06
            Changes and Additions to CppAD During 2005: 12.7.13: whats_new_05
            Changes and Additions to CppAD During 2004: 12.7.14: whats_new_04
            Changes and Additions to CppAD During 2003: 12.7.15: whats_new_03
        CppAD Deprecated API Features: 12.8: deprecated
            Deprecated Include Files: 12.8.1: include_deprecated
            ADFun Object Deprecated Member Functions: 12.8.2: FunDeprecated
            Comparison Changes During Zero Order Forward Mode: 12.8.3: CompareChange
            OpenMP Parallel Setup: 12.8.4: omp_max_thread
            Routines That Track Use of New and Delete: 12.8.5: TrackNewDel
                Tracking Use of New and Delete: Example and Test: 12.8.5.1: TrackNewDel.cpp
            A Quick OpenMP Memory Allocator Used by CppAD: 12.8.6: omp_alloc
                Set and Get Maximum Number of Threads for omp_alloc Allocator: 12.8.6.1: omp_max_num_threads
                Is The Current Execution in OpenMP Parallel Mode: 12.8.6.2: omp_in_parallel
                Get the Current OpenMP Thread Number: 12.8.6.3: omp_get_thread_num
                Get At Least A Specified Amount of Memory: 12.8.6.4: omp_get_memory
                Return Memory to omp_alloc: 12.8.6.5: omp_return_memory
                Free Memory Currently Available for Quick Use by a Thread: 12.8.6.6: omp_free_available
                Amount of Memory a Thread is Currently Using: 12.8.6.7: omp_inuse
                Amount of Memory Available for Quick Use by a Thread: 12.8.6.8: omp_available
                Allocate Memory and Create A Raw Array: 12.8.6.9: omp_create_array
                Return A Raw Array to The Available Memory for a Thread: 12.8.6.10: omp_delete_array
                Check If A Memory Allocation is Efficient for Another Use: 12.8.6.11: omp_efficient
                Set Maximum Number of Threads for omp_alloc Allocator: 12.8.6.12: old_max_num_threads
                OpenMP Memory Allocator: Example and Test: 12.8.6.13: omp_alloc.cpp
            Memory Leak Detection: 12.8.7: memory_leak
            Machine Epsilon For AD Types: 12.8.8: epsilon
            Choosing The Vector Testing Template Class: 12.8.9: test_vector
            Nonlinear Programming Using the CppAD Interface to Ipopt: 12.8.10: cppad_ipopt_nlp
                Nonlinear Programming Using CppAD and Ipopt: Example and Test: 12.8.10.1: ipopt_nlp_get_started.cpp
                Example Simultaneous Solution of Forward and Inverse Problem: 12.8.10.2: ipopt_nlp_ode
                    An ODE Inverse Problem Example: 12.8.10.2.1: ipopt_nlp_ode_problem
                        ODE Inverse Problem Definitions: Source Code: 12.8.10.2.1.1: ipopt_nlp_ode_problem.hpp
                    ODE Fitting Using Simple Representation: 12.8.10.2.2: ipopt_nlp_ode_simple
                        ODE Fitting Using Simple Representation: 12.8.10.2.2.1: ipopt_nlp_ode_simple.hpp
                    ODE Fitting Using Fast Representation: 12.8.10.2.3: ipopt_nlp_ode_fast
                        ODE Fitting Using Fast Representation: 12.8.10.2.3.1: ipopt_nlp_ode_fast.hpp
                    Driver for Running the Ipopt ODE Example: 12.8.10.2.4: ipopt_nlp_ode_run.hpp
                    Correctness Check for Both Simple and Fast Representations: 12.8.10.2.5: ipopt_nlp_ode_check.cpp
                Speed Test for Both Simple and Fast Representations: 12.8.10.3: ipopt_ode_speed.cpp
            User Defined Atomic AD Functions: 12.8.11: old_atomic
                Old Atomic Operation Reciprocal: Example and Test: 12.8.11.1: old_reciprocal.cpp
                Using AD to Compute Atomic Function Derivatives: 12.8.11.2: old_usead_1.cpp
                Using AD to Compute Atomic Function Derivatives: 12.8.11.3: old_usead_2.cpp
                Old Tan and Tanh as User Atomic Operations: Example and Test: 12.8.11.4: old_tan.cpp
                Old Matrix Multiply as a User Atomic Operation: Example and Test: 12.8.11.5: old_mat_mul.cpp
                    Define Matrix Multiply as a User Atomic Operation: 12.8.11.5.1: old_mat_mul.hpp
            zdouble: An AD Base Type With Absolute Zero: 12.8.12: zdouble
                zdouble: Example and Test: 12.8.12.1: zdouble.cpp
            Autotools Unix Test and Installation: 12.8.13: autotools
        Compare Speed of C and C++: 12.9: compare_c
            Determinant of a Minor: 12.9.1: det_of_minor_c
            Compute Determinant using Expansion by Minors: 12.9.2: det_by_minor_c
            Simulate a [0,1] Uniform Random Variate: 12.9.3: uniform_01_c
            Correctness Test of det_by_minor Routine: 12.9.4: correct_det_by_minor_c
            Repeat det_by_minor Routine A Specified Number of Times: 12.9.5: repeat_det_by_minor_c
            Returns Elapsed Number of Seconds: 12.9.6: elapsed_seconds_c
            Determine Amount of Time to Execute det_by_minor: 12.9.7: time_det_by_minor_c
            Main Program For Comparing C and C++ Speed: 12.9.8: main_compare_c
        Some Numerical AD Utilities: 12.10: numeric_ad
            Computing Jacobian and Hessian of Bender's Reduced Objective: 12.10.1: BenderQuad
                BenderQuad: Example and Test: 12.10.1.1: bender_quad.cpp
            Jacobian and Hessian of Optimal Values: 12.10.2: opt_val_hes
                opt_val_hes: Example and Test: 12.10.2.1: opt_val_hes.cpp
            LU Factorization of A Square Matrix and Stability Calculation: 12.10.3: LuRatio
                LuRatio: Example and Test: 12.10.3.1: lu_ratio.cpp
        CppAD Addons: 12.11: addon
        Your License for the CppAD Software: 12.12: License
    Alphabetic Listing of Cross Reference Tags: 13: _reference
    Keyword Index: 14: _index
    External Internet References: 15: _external

 
     make install

 
     nmake install

1. Download and install the open source program http://www.7-zip.org .
2. Download and install the Visual Studio Express; for example Visual Studio 2013 (http://www.microsoft.com/en-us/download/confirmation.aspx?id=44914)
3. In a command window, execute the following commands:
     set PATH=path_to_7_zip;%PATH%
     set PATH=path_to_cmake;%PATH%
     set VCDIR=path_to_vcdir;%PATH%
     call "%VCDIR%\vcvarsall.bat" x86
For example, on one machine these paths had the following values:
     path_to_7_zip=C:\Program Files\7-zip
     path_to_cmake=C:\Program Files (x86)\CMake\bin
     path_to_vcdir=C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC

4. Use the following commands to extract the distribution from the compressed archive:
     7z x cppad-version.lic.tgz
     7z x cppad-version.lic.tar

5. To see if this has been done correctly, check for the following file:
     cppad-version\cppad\cppad.hpp

6. The commands below are optional. They run the CppAD tests using the default 2.2: cmake settings (except for the 2.2.e: generator option)
     mkdir build
     cd build
     cmake -G "NMake Makefiles" ..
     nmake check


 
     which omhelp

 
     grep 'make check' cmake.log

 
     -D cppad_cxx_flags="-Wall -ansi -pedantic-errors -std=c++11 -Wshadow"

# include <cppad/cppad.hpp>
bool colpack_jac(void)
{     bool ok = true;
     using CppAD::AD;
     using CppAD::NearEqual;
     typedef CPPAD_TESTVECTOR(AD<double>)            a_vector;
     typedef CPPAD_TESTVECTOR(double)                d_vector;
     typedef CppAD::vector<size_t>                   i_vector;
     typedef CppAD::sparse_rc<i_vector>              sparsity;
     typedef CppAD::sparse_rcv<i_vector, d_vector>   sparse_matrix;

     // domain space vector
     size_t n = 4;
     a_vector  a_x(n);
     for(size_t j = 0; j < n; j++)
          a_x[j] = AD<double> (0);

     // declare independent variables and starting recording
     CppAD::Independent(a_x);

     size_t m = 3;
     a_vector  a_y(m);
     a_y[0] = a_x[0] + a_x[1];
     a_y[1] = a_x[2] + a_x[3];
     a_y[2] = a_x[0] + a_x[1] + a_x[2] + a_x[3] * a_x[3] / 2.;

     // create f: x -> y and stop tape recording
     CppAD::ADFun<double> f(a_x, a_y);

     // new value for the independent variable vector
     d_vector x(n);
     for(size_t j = 0; j < n; j++)
          x[j] = double(j);

     /*
           [ 1 1 0 0  ]
     jac = [ 0 0 1 1  ]
           [ 1 1 1 x_3]
     */
     // Normally one would use CppAD to compute sparsity pattern, but for this
     // example we set it directly
     size_t nr  = m;
     size_t nc  = n;
     size_t nnz = 8;
     sparsity pattern(nr, nc, nnz);
     d_vector check(nnz);
     for(size_t k = 0; k < nnz; k++)
     {     size_t r, c;
          if( k < 2 )
          {     r = 0;
               c = k;
          }
          else if( k < 4 )
          {     r = 1;
               c = k;
          }
          else
          {     r = 2;
               c = k - 4;
          }
          pattern.set(k, r, c);
          if( k == nnz - 1 )
               check[k] = x[3];
          else
               check[k] = 1.0;
     }

     // using row and column indices to compute non-zero in rows 1 and 2
     sparse_matrix subset( pattern );

     // check results for both CppAD and Colpack
     for(size_t i_method = 0; i_method < 4; i_method++)
     {     // coloring method
          std::string coloring;
          if( i_method % 2 == 0 )
               coloring = "cppad";
          else
               coloring = "colpack";
          //
          CppAD::sparse_jac_work work;
          size_t group_max = 1;
          if( i_method / 2 == 0 )
          {     size_t n_sweep = f.sparse_jac_for(
                    group_max, x, subset, pattern, coloring, work
               );
               ok &= n_sweep == 4;
          }
          else
          {     size_t n_sweep = f.sparse_jac_rev(
                    x, subset, pattern, coloring, work
               );
               ok &= n_sweep == 2;
          }
          const d_vector& hes( subset.val() );
          for(size_t k = 0; k < nnz; k++)
               ok &= check[k] == hes[k];
     }
     return ok;
}

# include <cppad/cppad.hpp>
bool colpack_jacobian(void)
{     bool ok = true;
     using CppAD::AD;
     using CppAD::NearEqual;
     typedef CPPAD_TESTVECTOR(AD<double>) a_vector;
     typedef CPPAD_TESTVECTOR(double)     d_vector;
     typedef CppAD::vector<size_t>        i_vector;
     size_t i, j, k, ell;
     double eps = 10. * CppAD::numeric_limits<double>::epsilon();

     // domain space vector
     size_t n = 4;
     a_vector  a_x(n);
     for(j = 0; j < n; j++)
          a_x[j] = AD<double> (0);

     // declare independent variables and starting recording
     CppAD::Independent(a_x);

     size_t m = 3;
     a_vector  a_y(m);
     a_y[0] = a_x[0] + a_x[1];
     a_y[1] = a_x[2] + a_x[3];
     a_y[2] = a_x[0] + a_x[1] + a_x[2] + a_x[3] * a_x[3] / 2.;

     // create f: x -> y and stop tape recording
     CppAD::ADFun<double> f(a_x, a_y);

     // new value for the independent variable vector
     d_vector x(n);
     for(j = 0; j < n; j++)
          x[j] = double(j);

     /*
           [ 1 1 0 0  ]
     jac = [ 0 0 1 1  ]
           [ 1 1 1 x_3]
     */
     d_vector check(m * n);
     check[0] = 1.; check[1] = 1.; check[2]  = 0.; check[3]  = 0.;
     check[4] = 0.; check[5] = 0.; check[6]  = 1.; check[7]  = 1.;
     check[8] = 1.; check[9] = 1.; check[10] = 1.; check[11] = x[3];

     // Normally one would use f.ForSparseJac or f.RevSparseJac to compute
     // sparsity pattern, but for this example we extract it from check.
     std::vector< std::set<size_t> >  p(m);

     // using row and column indices to compute non-zero in rows 1 and 2
     i_vector row, col;
     for(i = 0; i < m; i++)
     {     for(j = 0; j < n; j++)
          {     ell = i * n + j;
               if( check[ell] != 0. )
               {     row.push_back(i);
                    col.push_back(j);
                    p[i].insert(j);
               }
          }
     }
     size_t K = row.size();
     d_vector jac(K);

     // empty work structure
     CppAD::sparse_jacobian_work work;
     ok &= work.color_method == "cppad";

     // choose to use ColPack
     work.color_method = "colpack";

     // forward mode
     size_t n_sweep = f.SparseJacobianForward(x, p, row, col, jac, work);
     for(k = 0; k < K; k++)
     {     ell = row[k] * n + col[k];
          ok &= NearEqual(check[ell], jac[k], eps, eps);
     }
     ok &= n_sweep == 4;

     // reverse mode
     work.clear();
     work.color_method = "colpack";
     n_sweep = f.SparseJacobianReverse(x, p, row, col, jac, work);
     for(k = 0; k < K; k++)
     {     ell = row[k] * n + col[k];
          ok &= NearEqual(check[ell], jac[k], eps, eps);
     }
     ok &= n_sweep == 2;

     return ok;
}

# include <cppad/cppad.hpp>
bool colpack_hes(void)
{     bool ok = true;
     using CppAD::AD;
     using CppAD::NearEqual;
     typedef CPPAD_TESTVECTOR(AD<double>)            a_vector;
     typedef CPPAD_TESTVECTOR(double)                d_vector;
     typedef CppAD::vector<size_t>                   i_vector;
     typedef CppAD::sparse_rc<i_vector>              sparsity;
     typedef CppAD::sparse_rcv<i_vector, d_vector>   sparse_matrix;
     double eps = 10. * CppAD::numeric_limits<double>::epsilon();
     //
     // domain space vector
     size_t n = 5;
     a_vector  a_x(n);
     for(size_t j = 0; j < n; j++)
          a_x[j] = AD<double> (0);
     //
     // declare independent variables and starting recording
     CppAD::Independent(a_x);

     // colpack example case where hessian is a spear head
     // i.e, H(i, j) non zero implies i = 0, j = 0, or i = j
     AD<double> sum = 0.0;
     // partial_0 partial_j = x[j]
     // partial_j partial_j = x[0]
     for(size_t j = 1; j < n; j++)
          sum += a_x[0] * a_x[j] * a_x[j] / 2.0;
     //
     // partial_i partial_i = 2 * x[i]
     for(size_t i = 0; i < n; i++)
          sum += a_x[i] * a_x[i] * a_x[i] / 3.0;

     // declare dependent variables
     size_t m = 1;
     a_vector  a_y(m);
     a_y[0] = sum;

     // create f: x -> y and stop tape recording
     CppAD::ADFun<double> f(a_x, a_y);

     // new value for the independent variable vector
     d_vector x(n);
     for(size_t j = 0; j < n; j++)
          x[j] = double(j + 1);

     /*
           [ 2  2  3  4  5 ]
     hes = [ 2  5  0  0  0 ]
           [ 3  0  7  0  0 ]
           [ 4  0  0  9  0 ]
           [ 5  0  0  0 11 ]
     */
     // Normally one would use CppAD to compute sparsity pattern, but for this
     // example we set it directly
     size_t nr  = n;
     size_t nc  = n;
     size_t nnz = n + 2 * (n - 1);
     sparsity pattern(nr, nc, nnz);
     for(size_t k = 0; k < n; k++)
     {     size_t r = k;
          size_t c = k;
          pattern.set(k, r, c);
     }
     for(size_t i = 1; i < n; i++)
     {     size_t k = n + 2 * (i - 1);
          size_t r = i;
          size_t c = 0;
          pattern.set(k,   r, c);
          pattern.set(k+1, c, r);
     }

     // subset of elements to compute
     // (only compute lower traingle)
     nnz = n + (n - 1);
     sparsity lower_triangle(nr, nc, nnz);
     d_vector check(nnz);
     for(size_t k = 0; k < n; k++)
     {     size_t r = k;
          size_t c = k;
          lower_triangle.set(k, r, c);
          check[k] = 2.0 * x[k];
          if( k > 0 )
               check[k] += x[0];
     }
     for(size_t j = 1; j < n; j++)
     {     size_t k = n + (j - 1);
          size_t r = 0;
          size_t c = j;
          lower_triangle.set(k, r, c);
          check[k] = x[c];
     }
     sparse_matrix subset( lower_triangle );

     // check results for both CppAD and Colpack
     for(size_t i_method = 0; i_method < 4; i_method++)
     {     // coloring method
          std::string coloring;
          switch(i_method)
          {     case 0:
               coloring = "cppad.symmetric";
               break;

               case 1:
               coloring = "cppad.general";
               break;

               case 2:
               coloring = "colpack.symmetric";
               break;

               case 3:
               coloring = "colpack.general";
               break;
          }
          //
          // compute Hessian
          CppAD::sparse_hes_work work;
          d_vector w(m);
          w[0] = 1.0;
          size_t n_sweep = f.sparse_hes(
               x, w, subset, pattern, coloring, work
          );
          //
          // check result
          const d_vector& hes( subset.val() );
          for(size_t k = 0; k < nnz; k++)
               ok &= NearEqual(check[k], hes[k], eps, eps);
          if(
               coloring == "cppad.symmetric"
          ||     coloring == "colpack.symmetric"
          )
               ok &= n_sweep == 2;
          else
               ok &= n_sweep == 5;
     }

     return ok;
}

# include <cppad/cppad.hpp>
bool colpack_hessian(void)
{     bool ok = true;
     using CppAD::AD;
     using CppAD::NearEqual;
     typedef CPPAD_TESTVECTOR(AD<double>) a_vector;
     typedef CPPAD_TESTVECTOR(double)     d_vector;
     typedef CppAD::vector<size_t>        i_vector;
     size_t i, j, k, ell;
     double eps = 10. * CppAD::numeric_limits<double>::epsilon();

     // domain space vector
     size_t n = 5;
     a_vector  a_x(n);
     for(j = 0; j < n; j++)
          a_x[j] = AD<double> (0);

     // declare independent variables and starting recording
     CppAD::Independent(a_x);

     // colpack example case where hessian is a spear head
     // i.e, H(i, j) non zero implies i = 0, j = 0, or i = j
     AD<double> sum = 0.0;
     // partial_0 partial_j = x[j]
     // partial_j partial_j = x[0]
     for(j = 1; j < n; j++)
          sum += a_x[0] * a_x[j] * a_x[j] / 2.0;
     //
     // partial_i partial_i = 2 * x[i]
     for(i = 0; i < n; i++)
          sum += a_x[i] * a_x[i] * a_x[i] / 3.0;

     // declare dependent variables
     size_t m = 1;
     a_vector  a_y(m);
     a_y[0] = sum;

     // create f: x -> y and stop tape recording
     CppAD::ADFun<double> f(a_x, a_y);

     // new value for the independent variable vector
     d_vector x(n);
     for(j = 0; j < n; j++)
          x[j] = double(j + 1);

     /*
           [ 2  2  3  4  5 ]
     hes = [ 2  5  0  0  0 ]
           [ 3  0  7  0  0 ]
           [ 4  0  0  9  0 ]
           [ 5  0  0  0 11 ]
     */
     d_vector check(n * n);
     for(i = 0; i < n; i++)
     {     for(j = 0; j < n; j++)
          {     size_t index = i * n + j;
               check[index] = 0.0;
               if( i == 0 && 1 <= j )
                    check[index] += x[j];
               if( 1 <= i && j == 0 )
                    check[index] += x[i];
               if( i == j )
               {     check[index] += 2.0 * x[i];
                    if( i != 0 )
                         check[index] += x[0];
               }
          }
     }
     // Normally one would use f.RevSparseHes to compute
     // sparsity pattern, but for this example we extract it from check.
     std::vector< std::set<size_t> >  p(n);
     i_vector row, col;
     for(i = 0; i < n; i++)
     {     for(j = 0; j < n; j++)
          {     ell = i * n + j;
               if( check[ell] != 0. )
               {     // insert this non-zero entry in sparsity pattern
                    p[i].insert(j);

                    // the Hessian is symmetric, so only lower triangle
                    if( j <= i )
                    {     row.push_back(i);
                         col.push_back(j);
                    }
               }
          }
     }
     size_t K = row.size();
     d_vector hes(K);

     // default coloring method is cppad.symmetric
     CppAD::sparse_hessian_work work;
     ok &= work.color_method == "cppad.symmetric";

     // contrast and check results for both CppAD and Colpack
     for(size_t i_method = 0; i_method < 4; i_method++)
     {     // empty work structure
          switch(i_method)
          {     case 0:
               work.color_method = "cppad.symmetric";
               break;

               case 1:
               work.color_method = "cppad.general";
               break;

               case 2:
               work.color_method = "colpack.symmetric";
               break;

               case 3:
               work.color_method = "colpack.general";
               break;
          }

          // compute Hessian
          d_vector w(m);
          w[0] = 1.0;
          size_t n_sweep = f.SparseHessian(x, w, p, row, col, hes, work);
          //
          // check result
          for(k = 0; k < K; k++)
          {     ell = row[k] * n + col[k];
               ok &= NearEqual(check[ell], hes[k], eps, eps);
          }
          if(
               work.color_method == "cppad.symmetric"
          ||     work.color_method == "colpack.symmetric"
          )
               ok &= n_sweep == 2;
          else
               ok &= n_sweep == 5;
          //
          // check that clear resets color_method to cppad.symmetric
          work.clear();
          ok &= work.color_method == "cppad.symmetric";
     }

     return ok;
}

 
     make check

 
     pkg-config --cflags cppad

 
     pkg-config --libs cppad

1. Demonstrate the use of CppAD to calculate derivatives of a polynomial: 10.1: get_started.cpp .
2. Present two algorithms that approximate the exponential function. The first algorithm 3.1.1: exp_2.hpp is simpler and does not include any logical variables or loops. The second algorithm 3.2.1: exp_eps.hpp includes logical operations and a while loop. For each of these algorithms, do the following:
   1. Define the mathematical function corresponding to the algorithm (3.1: exp_2 and 3.2: exp_eps ).
   2. Write out the floating point operation sequence, and corresponding values, that correspond to executing the algorithm for a specific input (3.1.3: exp_2_for0 and 3.2.3: exp_eps_for0 ).
   3. Compute a forward sweep derivative of the operation sequence (3.1.4: exp_2_for1 and 3.2.4: exp_eps_for1 ).
   4. Compute a reverse sweep derivative of the operation sequence (3.1.5: exp_2_rev1 and 3.2.5: exp_eps_rev1 ).
   5. Use CppAD to compute both a forward and reverse sweep of the operation sequence (3.1.8: exp_2_cppad and 3.2.8: exp_eps_cppad ).
3. The program 3.3: exp_apx.cpp runs all of the test routines that validate the calculations in the 3.1: exp_2 and 3.2: exp_eps presentation.

1. Suppose that we make the call

    
        double x = .1;
        double y = exp_2(x);
   

   What is the value assigned to v1, v2, ... ,v5 in 3.1.1: exp_2.hpp ?
2. Extend the routine exp_2.hpp to a routine exp_3.hpp that computes @[@ 1 + x^2 / 2 ! + x^3 / 3 ! @]@ Do this in a way that only assigns one value to each variable (as exp_2 does).
3. Suppose that we make the call

    
        double x = .5;
        double y = exp_3(x);
   

   using exp_3 created in the previous problem. What is the value assigned to the new variables in exp_3 (variables that are in exp_3 and not in exp_2) ?

template <class Type>
Type exp_2(const Type &x)
{       Type v1  = x;                // v1 = x
        Type v2  = Type(1) + v1;     // v2 = 1 + x
        Type v3  = v1 * v1;          // v3 = x^2
        Type v4  = v3 / Type(2);     // v4 = x^2 / 2
        Type v5  = v2 + v4;          // v5 = 1 + x + x^2 / 2
        return v5;                   // exp_2(x) = 1 + x + x^2 / 2
}

# include <cmath>           // define fabs function
# include "exp_2.hpp"       // definition of exp_2 algorithm
bool exp_2(void)
{     double x     = .5;
     double check = 1 + x + x * x / 2.;
     bool   ok    = std::fabs( exp_2(x) - check ) <= 1e-10;
     return ok;
}

1. Suppose that @(@ x^{(0)} = .2 @)@, what is the result of a zero order forward sweep for the operation sequence above; i.e., what are the corresponding values for @[@ v_1^{(0)} , v_2^{(0)} , \cdots , v_5^{(0)} @]@
2. Create a modified version of 3.1.3.1: exp_2_for0.cpp that verifies the values you obtained for the previous exercise.
3. Create and run a main program that reports the result of calling the modified version of 3.1.3.1: exp_2_for0.cpp in the previous exercise.

# include <cmath>            // for fabs function
bool exp_2_for0(double *v0)  // double v0[6]
{     bool  ok = true;
     double x = .5;

     v0[1] = x;                                  // v1 = x
     ok  &= std::fabs( v0[1] - 0.5) < 1e-10;

     v0[2] = 1. + v0[1];                         // v2 = 1 + v1
     ok  &= std::fabs( v0[2] - 1.5) < 1e-10;

     v0[3] = v0[1] * v0[1];                      // v3 = v1 * v1
     ok  &= std::fabs( v0[3] - 0.25) < 1e-10;

     v0[4] = v0[3] / 2.;                         // v4 = v3 / 2
     ok  &= std::fabs( v0[4] - 0.125) < 1e-10;

     v0[5] = v0[2] + v0[4];                      // v5  = v2 + v4
     ok  &= std::fabs( v0[5] - 1.625) < 1e-10;

     return ok;
}
bool exp_2_for0(void)
{     double v0[6];
     return exp_2_for0(v0);
}

1. Which statement in the routine defined by 3.1.4.1: exp_2_for1.cpp uses the values that are calculated by the routine defined by 3.1.3.1: exp_2_for0.cpp ?
2. Suppose that @(@ x = .1 @)@, what are the results of a zero and first order forward sweep for the operation sequence above; i.e., what are the corresponding values for @(@ v_1^{(0)}, v_2^{(0)}, \cdots , v_5^{(0)} @)@ and @(@ v_1^{(1)}, v_2^{(1)}, \cdots , v_5^{(1)} @)@ ?
3. Create a modified version of 3.1.4.1: exp_2_for1.cpp that verifies the derivative values from the previous exercise. Also create and run a main program that reports the result of calling the modified version of 3.1.4.1: exp_2_for1.cpp .

# include <cmath>                   // prototype for fabs
extern bool exp_2_for0(double *v0); // computes zero order forward sweep
bool exp_2_for1(double *v1)         // double v1[6]
{     bool ok = true;
     double v0[6];

     // set the value of v0[j] for j = 1 , ... , 5
     ok &= exp_2_for0(v0);

     v1[1] = 1.;                                     // v1 = x
     ok    &= std::fabs( v1[1] - 1. ) <= 1e-10;

     v1[2] = v1[1];                                  // v2 = 1 + v1
     ok    &= std::fabs( v1[2] - 1. ) <= 1e-10;

     v1[3] = v1[1] * v0[1] + v0[1] * v1[1];          // v3 = v1 * v1
     ok    &= std::fabs( v1[3] - 1. ) <= 1e-10;

     v1[4] = v1[3] / 2.;                             // v4 = v3 / 2
     ok    &= std::fabs( v1[4] - 0.5) <= 1e-10;

     v1[5] = v1[2] + v1[4];                          // v5 = v2 + v4
     ok    &= std::fabs( v1[5] - 1.5) <= 1e-10;

     return ok;
}
bool exp_2_for1(void)
{     double v1[6];
     return exp_2_for1(v1);
}

1. Which statement in the routine defined by 3.1.5.1: exp_2_rev1.cpp uses the values that are calculated by the routine defined by 3.1.3.1: exp_2_for0.cpp ?
2. Consider the case where @(@ x = .1 @)@ and we first preform a zero order forward sweep for the operation sequence used above. What are the results of a first order reverse sweep; i.e., what are the corresponding derivatives of @(@ f_5 , f_4 , \ldots , f_1 @)@.
3. Create a modified version of 3.1.5.1: exp_2_rev1.cpp that verifies the values you obtained for the previous exercise. Also create and run a main program that reports the result of calling the modified version of 3.1.5.1: exp_2_rev1.cpp .

# include <cstddef>                 // define size_t
# include <cmath>                   // prototype for fabs
extern bool exp_2_for0(double *v0); // computes zero order forward sweep
bool exp_2_rev1(void)
{     bool ok = true;

     // set the value of v0[j] for j = 1 , ... , 5
     double v0[6];
     ok &= exp_2_for0(v0);

     // initial all partial derivatives as zero
     double f_v[6];
     size_t j;
     for(j = 0; j < 6; j++)
          f_v[j] = 0.;

     // set partial derivative for f5
     f_v[5] = 1.;
     ok &= std::fabs( f_v[5] - 1. ) <= 1e-10; // f5_v5

     // f4 = f5( v1 , v2 , v3 , v4 , v2 + v4 )
     f_v[2] += f_v[5] * 1.;
     f_v[4] += f_v[5] * 1.;
     ok &= std::fabs( f_v[2] - 1. ) <= 1e-10; // f4_v2
     ok &= std::fabs( f_v[4] - 1. ) <= 1e-10; // f4_v4

     // f3 = f4( v1 , v2 , v3 , v3 / 2 )
     f_v[3] += f_v[4] / 2.;
     ok &= std::fabs( f_v[3] - 0.5) <= 1e-10; // f3_v3

     // f2 = f3( v1 , v2 , v1 * v1 )
     f_v[1] += f_v[3] * 2. * v0[1];
     ok &= std::fabs( f_v[1] - 0.5) <= 1e-10; // f2_v1

     // f1 = f2( v1 , 1 + v1 )
     f_v[1] += f_v[2] * 1.;
     ok &= std::fabs( f_v[1] - 1.5) <= 1e-10; // f1_v1

     return ok;
}

1. Which statement in the routine defined by 3.1.6.1: exp_2_for2.cpp uses the values that are calculated by the routine defined by 3.1.4.1: exp_2_for1.cpp ?
2. Suppose that @(@ x = .1 @)@, what are the results of a zero, first, and second order forward sweep for the operation sequence above; i.e., what are the corresponding values for @(@ v_i^{(k)} @)@ for @(@ i = 1, \ldots , 5 @)@ and @(@ k = 0, 1, 2 @)@.
3. Create a modified version of 3.1.6.1: exp_2_for2.cpp that verifies the derivative values from the previous exercise. Also create and run a main program that reports the result of calling the modified version of 3.1.6.1: exp_2_for2.cpp .

# include <cmath>                   // prototype for fabs
extern bool exp_2_for0(double *v0); // computes zero order forward sweep
extern bool exp_2_for1(double *v1); // computes first order forward sweep
bool exp_2_for2(void)
{     bool ok = true;
     double v0[6], v1[6], v2[6];

     // set the value of v0[j], v1[j], for j = 1 , ... , 5
     ok &= exp_2_for0(v0);
     ok &= exp_2_for1(v1);

     v2[1] = 0.;                                     // v1 = x
     ok    &= std::fabs( v2[1] - 0. ) <= 1e-10;

     v2[2] = v2[1];                                  // v2 = 1 + v1
     ok    &= std::fabs( v2[2] - 0. ) <= 1e-10;

     v2[3] = 2.*(v0[1]*v2[1] + v1[1]*v1[1]);         // v3 = v1 * v1
     ok    &= std::fabs( v2[3] - 2. ) <= 1e-10;

     v2[4] = v2[3] / 2.;                             // v4 = v3 / 2
     ok    &= std::fabs( v2[4] - 1. ) <= 1e-10;

     v2[5] = v2[2] + v2[4];                          // v5 = v2 + v4
     ok    &= std::fabs( v2[5] - 1. ) <= 1e-10;

     return ok;
}