One web page per Section | All as one web page | |
(fast to load) | (slow to load) | |
Math displayed using Latex |
cppad.htm
| _printable.htm |
Math displayed using MathML |
cppad.xml
| _printable.xml |
# include <cppad/cppad.hpp>
# include <cppad/cppad.hpp>
CppAD or CPPAD_.
CppAD namespace; for example, you can access the 4: AD
types as
size_t n = 2;
CppAD::vector< CppAD::AD<> > x(n)
You can abbreviate access to one object or function a using
command of the form
using CppAD::AD
CppAD::vector< AD<> > x(n)
You can abbreviate access to all CppAD objects and functions
with a command of the form
using namespace CppAD
vector< AD<> > x(n)
If you include other namespaces in a similar manner,
this can cause naming conflicts.
| _contents: 1 | Table of Contents |
| Install: 2 | CppAD Download, Test, and Installation Instructions |
| Introduction: 3 | An Introduction by Example to Algorithmic Differentiation |
| AD: 4 | AD Objects |
| ADFun: 5 | ADFun Objects |
| multi_thread: 6 | Using CppAD in a Multi-Threading Environment |
| library: 7 | The CppAD General Purpose Library |
| cppad_ipopt_nlp: 8 | Nonlinear Programming Using the CppAD Interface to Ipopt |
| Example: 9 | Examples |
| preprocessor: 10 | CppAD API Preprocessor Symbols |
| Appendix: 11 | Appendix |
| _reference: 12 | Alphabetic Listing of Cross Reference Tags |
| _index: 13 | Keyword Index |
| _external: 14 | External Internet References |
cppad-20120203: A Package for Differentiation of C++ Algorithms: : CppAD
Table of Contents: 1: _contents
CppAD Download, Test, and Installation Instructions: 2: Install
Unix Download, Test and Installation: 2.1: InstallUnix
Using Subversion To Download Source Code: 2.1.1: subversion
CppAD pkg-config Files: 2.2: pkgconfig
Windows Download and Test: 2.3: InstallWindows
An Introduction by Example to Algorithmic Differentiation: 3: Introduction
Getting Started Using CppAD to Compute Derivatives: 3.1: get_started.cpp
Second Order Exponential Approximation: 3.2: exp_2
exp_2: Implementation: 3.2.1: exp_2.hpp
exp_2: Test: 3.2.2: exp_2.cpp
exp_2: Operation Sequence and Zero Order Forward Mode: 3.2.3: exp_2_for0
exp_2: Verify Zero Order Forward Sweep: 3.2.3.1: exp_2_for0.cpp
exp_2: First Order Forward Mode: 3.2.4: exp_2_for1
exp_2: Verify First Order Forward Sweep: 3.2.4.1: exp_2_for1.cpp
exp_2: First Order Reverse Mode: 3.2.5: exp_2_rev1
exp_2: Verify First Order Reverse Sweep: 3.2.5.1: exp_2_rev1.cpp
exp_2: Second Order Forward Mode: 3.2.6: exp_2_for2
exp_2: Verify Second Order Forward Sweep: 3.2.6.1: exp_2_for2.cpp
exp_2: Second Order Reverse Mode: 3.2.7: exp_2_rev2
exp_2: Verify Second Order Reverse Sweep: 3.2.7.1: exp_2_rev2.cpp
exp_2: CppAD Forward and Reverse Sweeps: 3.2.8: exp_2_cppad
An Epsilon Accurate Exponential Approximation: 3.3: exp_eps
exp_eps: Implementation: 3.3.1: exp_eps.hpp
exp_eps: Test of exp_eps: 3.3.2: exp_eps.cpp
exp_eps: Operation Sequence and Zero Order Forward Sweep: 3.3.3: exp_eps_for0
exp_eps: Verify Zero Order Forward Sweep: 3.3.3.1: exp_eps_for0.cpp
exp_eps: First Order Forward Sweep: 3.3.4: exp_eps_for1
exp_eps: Verify First Order Forward Sweep: 3.3.4.1: exp_eps_for1.cpp
exp_eps: First Order Reverse Sweep: 3.3.5: exp_eps_rev1
exp_eps: Verify First Order Reverse Sweep: 3.3.5.1: exp_eps_rev1.cpp
exp_eps: Second Order Forward Mode: 3.3.6: exp_eps_for2
exp_eps: Verify Second Order Forward Sweep: 3.3.6.1: exp_eps_for2.cpp
exp_eps: Second Order Reverse Sweep: 3.3.7: exp_eps_rev2
exp_eps: Verify Second Order Reverse Sweep: 3.3.7.1: exp_eps_rev2.cpp
exp_eps: CppAD Forward and Reverse Sweeps: 3.3.8: exp_eps_cppad
Correctness Tests For Exponential Approximation in Introduction: 3.4: exp_apx_main.cpp
AD Objects: 4: AD
AD Default Constructor: 4.1: Default
Default AD Constructor: Example and Test: 4.1.1: Default.cpp
AD Copy Constructor and Assignment Operator: 4.2: ad_copy
AD Copy Constructor: Example and Test: 4.2.1: CopyAD.cpp
AD Constructor From Base Type: Example and Test: 4.2.2: CopyBase.cpp
AD Assignment Operator: Example and Test: 4.2.3: Eq.cpp
Conversion and Printing 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
AD Output Stream Operator: 4.3.3: Output
AD Output Operator: Example and Test: 4.3.3.1: Output.cpp
Printing AD Values During Forward Mode: 4.3.4: PrintFor
Printing During Forward Mode: Example and Test: 4.3.4.1: print_for_cout.cpp
Print During Zero Order Forward Mode: Example and Test: 4.3.4.2: print_for_string.cpp
Convert an AD Variable to a Parameter: 4.3.5: Var2Par
Convert an AD Variable to a Parameter: Example and Test: 4.3.5.1: Var2Par.cpp
AD Valued Operations and Functions: 4.4: ADValued
AD Arithmetic Operators and Computed 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: UnaryPlus.cpp
AD Unary Minus Operator: 4.4.1.2: UnaryMinus
AD Unary Minus Operator: Example and Test: 4.4.1.2.1: UnaryMinus.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 Computed Assignment Operators: 4.4.1.4: compute_assign
AD Computed Assignment Addition: Example and Test: 4.4.1.4.1: AddEq.cpp
AD Computed Assignment Subtraction: Example and Test: 4.4.1.4.2: SubEq.cpp
AD Computed Assignment Multiplication: Example and Test: 4.4.1.4.3: MulEq.cpp
AD Computed Assignment Division: Example and Test: 4.4.1.4.4: DivEq.cpp
AD Standard Math Unary Functions: 4.4.2: std_math_ad
The AD acos Function: Example and Test: 4.4.2.1: Acos.cpp
The AD asin Function: Example and Test: 4.4.2.2: Asin.cpp
The AD atan Function: Example and Test: 4.4.2.3: Atan.cpp
The AD cos Function: Example and Test: 4.4.2.4: Cos.cpp
The AD cosh Function: Example and Test: 4.4.2.5: Cosh.cpp
The AD exp Function: Example and Test: 4.4.2.6: Exp.cpp
The AD log Function: Example and Test: 4.4.2.7: Log.cpp
The AD log10 Function: Example and Test: 4.4.2.8: Log10.cpp
The AD sin Function: Example and Test: 4.4.2.9: Sin.cpp
The AD sinh Function: Example and Test: 4.4.2.10: Sinh.cpp
The AD sqrt Function: Example and Test: 4.4.2.11: Sqrt.cpp
The AD tan Function: Example and Test: 4.4.2.12: Tan.cpp
The AD tanh Function: Example and Test: 4.4.2.13: Tanh.cpp
Other AD Math Functions: 4.4.3: MathOther
AD Absolute Value Function: 4.4.3.1: abs
AD Absolute Value Function: Example and Test: 4.4.3.1.1: abs.cpp
Sign Function: 4.4.3.2: sign
Sign Function: Example and Test: 4.4.3.2.1: sign.cpp
AD Two Argument Inverse Tangent Function: 4.4.3.3: atan2
The AD atan2 Function: Example and Test: 4.4.3.3.1: Atan2.cpp
Machine Epsilon For AD Types: 4.4.3.4: epsilon
Machine Epsilon: Example and Test: 4.4.3.4.1: epsilon.cpp
The AD Error Function: 4.4.3.5: erf
The AD erf Function: Example and Test: 4.4.3.5.1: Erf.cpp
The AD Power Function: 4.4.3.6: pow
The AD Power Function: Example and Test: 4.4.3.6.1: Pow.cpp
The Pow Integer Exponent: Example and Test: 4.4.3.6.2: pow_int.cpp
AD Conditional Expressions: 4.4.4: CondExp
Conditional Expressions: Example and Test: 4.4.4.1: CondExp.cpp
Discrete AD Functions: 4.4.5: Discrete
Taping Array Index Operation: Example and Test: 4.4.5.1: TapeIndex.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
User Defined Atomic AD Functions: 4.4.6: user_atomic
Tan and Tanh as User Atomic Operations: Example and Test: 4.4.6.1: user_tan.cpp
Matrix Multiply as a User Atomic Operation: Example and Test: 4.4.6.2: mat_mul.cpp
Define Matrix Multiply as a User Atomic Operation: 4.4.6.2.1: 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: NearEqualExt.cpp
AD Boolean Functions: 4.5.3: BoolFun
AD Boolean Functions: Example and Test: 4.5.3.1: BoolFun.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: ParVar.cpp
Check if Two Value are Identically Equal: 4.5.5: EqualOpSeq
EqualOpSeq: Example and Test: 4.5.5.1: EqualOpSeq.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 Base Type: 4.7: base_require
Base Type Requirements for Conditional Expressions: 4.7.1: base_cond_exp
Base Type Requirements for Identically Equal Comparisons: 4.7.2: base_identical
Base Type Requirements for Ordered Comparisons: 4.7.3: base_ordered
Base Type Requirements for Standard Math Functions: 4.7.4: base_std_math
Enable use of AD<Base> where Base is float: 4.7.5: base_float.hpp
Enable use of AD<Base> where Base is double: 4.7.6: base_double.hpp
Enable use of AD<Base> where Base is std::complex<double>: 4.7.7: base_complex.hpp
Complex Polynomial: Example and Test: 4.7.7.1: ComplexPoly.cpp
Not Complex Differentiable: Example and Test: 4.7.7.2: not_complex_ad.cpp
Enable use of AD<Base> where Base is Adolc's adouble Type: 4.7.8: base_adolc.hpp
Using Adolc with Multiple Levels of Taping: Example and Test: 4.7.8.1: mul_level_adolc.cpp
ADFun Objects: 5: ADFun
Declare Independent Variables and Start Recording: 5.1: Independent
Independent and ADFun Constructor: Example and Test: 5.1.1: Independent.cpp
Construct an ADFun Object and Stop Recording: 5.2: FunConstruct
ADFun Assignment: Example and Test: 5.2.1: fun_assign.cpp
Stop Recording and Store Operation Sequence: 5.3: Dependent
Abort Recording of an Operation Sequence: 5.4: abort_recording
Abort Current Recording: Example and Test: 5.4.1: abort_recording.cpp
ADFun Sequence Properties: 5.5: seq_property
ADFun Sequence Properties: Example and Test: 5.5.1: seq_property.cpp
Evaluate ADFun Functions, Derivatives, and Sparsity Patterns: 5.6: FunEval
Forward Mode: 5.6.1: Forward
Zero Order Forward Mode: Function Values: 5.6.1.1: ForwardZero
First Order Forward Mode: Derivative Values: 5.6.1.2: ForwardOne
Any Order Forward Mode: 5.6.1.3: ForwardAny
Number Taylor Coefficients, Per Variable, Currently Stored: 5.6.1.4: size_taylor
Comparison Changes During Zero Order Forward Mode: 5.6.1.5: CompareChange
CompareChange and Re-Tape: Example and Test: 5.6.1.5.1: CompareChange.cpp
Controlling Taylor Coefficients Memory Allocation: 5.6.1.6: capacity_taylor
Forward Mode: Example and Test: 5.6.1.7: Forward.cpp
Reverse Mode: 5.6.2: Reverse
First Order Reverse Mode: 5.6.2.1: reverse_one
First Order Reverse Mode: Example and Test: 5.6.2.1.1: reverse_one.cpp
Second Order Reverse Mode: 5.6.2.2: reverse_two
Second Order Reverse ModeExample and Test: 5.6.2.2.1: reverse_two.cpp
Hessian Times Direction: Example and Test: 5.6.2.2.2: HesTimesDir.cpp
Any Order Reverse Mode: 5.6.2.3: reverse_any
Third Order Reverse Mode: Example and Test: 5.6.2.3.1: reverse_three.cpp
Reverse Mode General Case: Example and Test: 5.6.2.3.2: reverse_any.cpp
Checkpoint and Function Composition: Example and Test: 5.6.2.3.3: checkpoint.cpp
Calculating Sparsity Patterns: 5.6.3: Sparse
Jacobian Sparsity Pattern: Forward Mode: 5.6.3.1: ForSparseJac
Forward Mode Jacobian Sparsity: Example and Test: 5.6.3.1.1: ForSparseJac.cpp
Jacobian Sparsity Pattern: Reverse Mode: 5.6.3.2: RevSparseJac
Reverse Mode Jacobian Sparsity: Example and Test: 5.6.3.2.1: RevSparseJac.cpp
Hessian Sparsity Pattern: Reverse Mode: 5.6.3.3: RevSparseHes
Reverse Mode Hessian Sparsity: Example and Test: 5.6.3.3.1: RevSparseHes.cpp
First and Second Derivatives: Easy Drivers: 5.7: Drivers
Jacobian: Driver Routine: 5.7.1: Jacobian
Jacobian: Example and Test: 5.7.1.1: Jacobian.cpp
First Order Partial Derivative: Driver Routine: 5.7.2: ForOne
First Order Partial Driver: Example and Test: 5.7.2.1: ForOne.cpp
First Order Derivative: Driver Routine: 5.7.3: RevOne
First Order Derivative Driver: Example and Test: 5.7.3.1: RevOne.cpp
Hessian: Easy Driver: 5.7.4: Hessian
Hessian: Example and Test: 5.7.4.1: Hessian.cpp
Hessian of Lagrangian and ADFun Default Constructor: Example and Test: 5.7.4.2: HesLagrangian.cpp
Forward Mode Second Partial Derivative Driver: 5.7.5: ForTwo
Subset of Second Order Partials: Example and Test: 5.7.5.1: ForTwo.cpp
Reverse Mode Second Partial Derivative Driver: 5.7.6: RevTwo
Second Partials Reverse Driver: Example and Test: 5.7.6.1: RevTwo.cpp
Sparse Jacobian: Easy Driver: 5.7.7: sparse_jacobian
Sparse Jacobian: Example and Test: 5.7.7.1: sparse_jacobian.cpp
Sparse Hessian: Easy Driver: 5.7.8: sparse_hessian
Sparse Hessian: Example and Test: 5.7.8.1: sparse_hessian.cpp
Check an ADFun Sequence of Operations: 5.8: FunCheck
ADFun Check and Re-Tape: Example and Test: 5.8.1: FunCheck.cpp
Optimize an ADFun Object Tape: 5.9: optimize
ADFun Operation Sequence Optimization: Example and Test: 5.9.1: optimize.cpp
Using CppAD in a Multi-Threading Environment: 6: multi_thread
Enable AD Calculations During Parallel Mode: 6.1: parallel_ad
Specifications for A Team of AD Threads: 6.2: team_thread.hpp
OpenMP Implementation of a Team of AD Threads: 6.2.1: team_openmp.cpp
Boost Thread Implementation of a Team of AD Threads: 6.2.2: team_bthread.cpp
Pthread Implementation of a Team of AD Threads: 6.2.3: team_pthread.cpp
Run Multi-Threading Examples and Speed Tests: 6.3: thread_test.cpp
A Simple OpenMP Example and Test: 6.3.1: a11c_openmp.cpp
A Simple Boost Thread Example and Test: 6.3.2: a11c_bthread.cpp
A Simple Parallel Pthread Example and Test: 6.3.3: a11c_pthread.cpp
Simple Multi-Threading AD: Example and Test: 6.4: simple_ad.cpp
Two Argument Inverse Tangent Function: 6.4.1: arc_tan.cpp
Multi-Threaded Implementation of Summation of 1/i: 6.5: harmonic.cpp
Timing Test of Multi-Threaded Summation of 1/i: 6.5.1: harmonic_time.cpp
Multi-threading Sum of 1/i Utility Routines: 6.5.2: harmonic_work.cpp
A Multi-Threaded Newton's Method: 6.6: multi_newton.cpp
Timing Test of Multi-Threaded Newton Method: 6.6.1: multi_newton_time.cpp
Multi-threading Newton Method Utility Routines: 6.6.2: multi_newton_work.cpp
The CppAD General Purpose Library: 7: library
Replacing the CppAD Error Handler: 7.1: ErrorHandler
Replacing The CppAD Error Handler: Example and Test: 7.1.1: ErrorHandler.cpp
CppAD Assertions During Execution: 7.1.2: cppad_assert
Determine if Two Values Are Nearly Equal: 7.2: NearEqual
NearEqual Function: Example and Test: 7.2.1: Near_Equal.cpp
Run One Speed Test and Return Results: 7.3: speed_test
speed_test: Example and test: 7.3.1: speed_test.cpp
Run One Speed Test and Print Results: 7.4: SpeedTest
Example Use of SpeedTest: 7.4.1: speed_program.cpp
Determine Amount of Time to Execute a Test: 7.5: time_test
Returns Elapsed Number of Seconds: 7.5.1: elapsed_seconds
Elapsed Seconds: Example and Test: 7.5.1.1: elapsed_seconds.cpp
time_test: Example and test: 7.5.2: time_test.cpp
Definition of a Numeric Type: 7.6: NumericType
The NumericType: Example and Test: 7.6.1: NumericType.cpp
Check NumericType Class Concept: 7.7: CheckNumericType
The CheckNumericType Function: Example and Test: 7.7.1: CheckNumericType.cpp
Definition of a Simple Vector: 7.8: SimpleVector
Simple Vector Template Class: Example and Test: 7.8.1: SimpleVector.cpp
Check Simple Vector Concept: 7.9: CheckSimpleVector
The CheckSimpleVector Function: Example and Test: 7.9.1: CheckSimpleVector.cpp
Obtain Nan or Determine if a Value is Nan: 7.10: nan
nan: Example and Test: 7.10.1: nan.cpp
The Integer Power Function: 7.11: pow_int
Evaluate a Polynomial or its Derivative: 7.12: Poly
Polynomial Evaluation: Example and Test: 7.12.1: Poly.cpp
Source: Poly: 7.12.2: poly.hpp
Compute Determinants and Solve Equations by LU Factorization: 7.13: LuDetAndSolve
Compute Determinant and Solve Linear Equations: 7.13.1: LuSolve
LuSolve With Complex Arguments: Example and Test: 7.13.1.1: LuSolve.cpp
Source: LuSolve: 7.13.1.2: lu_solve.hpp
LU Factorization of A Square Matrix: 7.13.2: LuFactor
LuFactor: Example and Test: 7.13.2.1: LuFactor.cpp
Source: LuFactor: 7.13.2.2: lu_factor.hpp
Invert an LU Factored Equation: 7.13.3: LuInvert
LuInvert: Example and Test: 7.13.3.1: LuInvert.cpp
Source: LuInvert: 7.13.3.2: lu_invert.hpp
One DimensionalRomberg Integration: 7.14: RombergOne
One Dimensional Romberg Integration: Example and Test: 7.14.1: RombergOne.cpp
Multi-dimensional Romberg Integration: 7.15: RombergMul
One Dimensional Romberg Integration: Example and Test: 7.15.1: RombergMul.cpp
An Embedded 4th and 5th Order Runge-Kutta ODE Solver: 7.16: Runge45
Runge45: Example and Test: 7.16.1: runge_45_1.cpp
Runge45: Example and Test: 7.16.2: runge_45_2.cpp
A 3rd and 4th Order Rosenbrock ODE Solver: 7.17: Rosen34
Rosen34: Example and Test: 7.17.1: Rosen34.cpp
An Error Controller for ODE Solvers: 7.18: OdeErrControl
OdeErrControl: Example and Test: 7.18.1: OdeErrControl.cpp
OdeErrControl: Example and Test Using Maxabs Argument: 7.18.2: OdeErrMaxabs.cpp
An Arbitrary Order Gear Method: 7.19: OdeGear
OdeGear: Example and Test: 7.19.1: OdeGear.cpp
An Error Controller for Gear's Ode Solvers: 7.20: OdeGearControl
OdeGearControl: Example and Test: 7.20.1: OdeGearControl.cpp
Computing Jacobian and Hessian of Bender's Reduced Objective: 7.21: BenderQuad
BenderQuad: Example and Test: 7.21.1: BenderQuad.cpp
Jacobian and Hessian of Optimal Values: 7.22: opt_val_hes
opt_val_hes: Example and Test: 7.22.1: opt_val_hes.cpp
LU Factorization of A Square Matrix and Stability Calculation: 7.23: LuRatio
LuRatio: Example and Test: 7.23.1: LuRatio.cpp
The CppAD::vector Template Class: 7.24: CppAD_vector
CppAD::vector Template Class: Example and Test: 7.24.1: CppAD_vector.cpp
CppAD::vectorBool Class: Example and Test: 7.24.2: vectorBool.cpp
A Fast Multi-Threading Memory Allocator: 7.25: thread_alloc
Fast Multi-Threading Memory Allocator: Example and Test: 7.25.1: thread_alloc.cpp
Setup thread_alloc For Use in Multi-Threading Environment: 7.25.2: ta_parallel_setup
Get Number of Threads: 7.25.3: ta_num_threads
Is The Current Execution in Parallel Mode: 7.25.4: ta_in_parallel
Get the Current Thread Number: 7.25.5: ta_thread_num
Get At Least A Specified Amount of Memory: 7.25.6: ta_get_memory
Return Memory to thread_alloc: 7.25.7: ta_return_memory
Free Memory Currently Available for Quick Use by a Thread: 7.25.8: ta_free_available
Control When Thread Alloc Retains Memory For Future Use: 7.25.9: ta_hold_memory
Amount of Memory a Thread is Currently Using: 7.25.10: ta_inuse
Amount of Memory Available for Quick Use by a Thread: 7.25.11: ta_available
Allocate An Array and Call Default Constructor for its Elements: 7.25.12: ta_create_array
Deallocate An Array and Call Destructor for its Elements: 7.25.13: ta_delete_array
Memory Leak Detection: 7.26: memory_leak
Nonlinear Programming Using the CppAD Interface to Ipopt: 8: cppad_ipopt_nlp
Linking the CppAD Interface to Ipopt in Visual Studio 9.0: 8.1: cppad_ipopt_windows
Nonlinear Programming Using CppAD and Ipopt: Example and Test: 8.2: ipopt_get_started.cpp
Example Simultaneous Solution of Forward and Inverse Problem: 8.3: cppad_ipopt_ode
An ODE Inverse Problem Example: 8.3.1: ipopt_ode_problem
ODE Inverse Problem Definitions: Source Code: 8.3.1.1: ipopt_ode_problem.hpp
ODE Fitting Using Simple Representation: 8.3.2: ipopt_ode_simple
ODE Fitting Using Simple Representation: 8.3.2.1: ipopt_ode_simple.hpp
ODE Fitting Using Fast Representation: 8.3.3: ipopt_ode_fast
ODE Fitting Using Fast Representation: 8.3.3.1: ipopt_ode_fast.hpp
Driver for Running the Ipopt ODE Example: 8.3.4: ipopt_ode_run.hpp
Correctness Check for Both Simple and Fast Representations: 8.3.5: ipopt_ode_check.cpp
Speed Test for Both Simple and Fast Representations: 8.4: ipopt_ode_speed.cpp
Examples: 9: Example
General Examples: 9.1: General
Creating Your Own Interface to an ADFun Object: 9.1.1: ad_fun.cpp
Example and Test Linking CppAD to Languages Other than C++: 9.1.2: ad_in_c.cpp
Differentiate Conjugate Gradient Algorithm: Example and Test: 9.1.3: conj_grad.cpp
Gradient of Determinant Using Expansion by Minors: Example and Test: 9.1.4: HesMinorDet.cpp
Gradient of Determinant Using LU Factorization: Example and Test: 9.1.5: HesLuDet.cpp
Interfacing to C: Example and Test: 9.1.6: Interface2C.cpp
Gradient of Determinant Using Expansion by Minors: Example and Test: 9.1.7: JacMinorDet.cpp
Gradient of Determinant Using Lu Factorization: Example and Test: 9.1.8: JacLuDet.cpp
Using Multiple Levels of AD: 9.1.9: mul_level
Multiple Tapes: Example and Test: 9.1.9.1: mul_level.cpp
Computing a Jacobian With Constants that Change: 9.1.9.2: change_const.cpp
A Stiff Ode: Example and Test: 9.1.10: OdeStiff.cpp
Taylor's Ode Solver: An Example and Test: 9.1.11: ode_taylor.cpp
Using Adolc with Taylor's Ode Solver: An Example and Test: 9.1.12: ode_taylor_adolc.cpp
Example Differentiating a Stack Machine Interpreter: 9.1.13: StackMachine.cpp
Utility Routines used by CppAD Examples: 9.2: ExampleUtility
CppAD Examples and Tests: 9.2.1: example.cpp
Run the Speed Examples: 9.2.2: speed_example.cpp
Lu Factor and Solve with Recorded Pivoting: 9.2.3: LuVecAD
Lu Factor and Solve With Recorded Pivoting: Example and Test: 9.2.3.1: LuVecADOk.cpp
List of All the CppAD Examples: 9.3: ListAllExamples
Choosing The Vector Testing Template Class: 9.4: test_vector
CppAD API Preprocessor Symbols: 10: preprocessor
Appendix: 11: Appendix
Frequently Asked Questions and Answers: 11.1: Faq
Speed Test Routines: 11.2: speed
Speed Testing Main Program: 11.2.1: speed_main
Speed Testing Gradient of Determinant Using Lu Factorization: 11.2.1.1: link_det_lu
Speed Testing Gradient of Determinant by Minor Expansion: 11.2.1.2: link_det_minor
Speed Testing Derivative of Matrix Multiply: 11.2.1.3: link_mat_mul
Speed Testing the Jacobian of Ode Solution: 11.2.1.4: link_ode
Speed Testing Second Derivative of a Polynomial: 11.2.1.5: link_poly
Speed Testing Sparse Hessian: 11.2.1.6: link_sparse_hessian
Speed Testing Sparse Jacobian: 11.2.1.7: link_sparse_jacobian
Microsoft Version of Elapsed Number of Seconds: 11.2.1.8: microsoft_timer
Speed Testing Utilities: 11.2.2: speed_utility
Simulate a [0,1] Uniform Random Variate: 11.2.2.1: uniform_01
Source: uniform_01: 11.2.2.1.1: uniform_01.hpp
Determinant of a Minor: 11.2.2.2: det_of_minor
Determinant of a Minor: Example and Test: 11.2.2.2.1: det_of_minor.cpp
Source: det_of_minor: 11.2.2.2.2: det_of_minor.hpp
Determinant Using Expansion by Minors: 11.2.2.3: det_by_minor
Determinant Using Expansion by Minors: Example and Test: 11.2.2.3.1: det_by_minor.cpp
Source: det_by_minor: 11.2.2.3.2: det_by_minor.hpp
Determinant Using Expansion by Lu Factorization: 11.2.2.4: det_by_lu
Determinant Using Lu Factorization: Example and Test: 11.2.2.4.1: det_by_lu.cpp
Source: det_by_lu: 11.2.2.4.2: det_by_lu.hpp
Check Determinant of 3 by 3 matrix: 11.2.2.5: det_33
Source: det_33: 11.2.2.5.1: det_33.hpp
Check Gradient of Determinant of 3 by 3 matrix: 11.2.2.6: det_grad_33
Source: det_grad_33: 11.2.2.6.1: det_grad_33.hpp
Sum Elements of a Matrix Times Itself: 11.2.2.7: mat_sum_sq
Sum of the Elements of the Square of a Matrix: Example and Test: 11.2.2.7.1: mat_sum_sq.cpp
Source: mat_sum_sq: 11.2.2.7.2: mat_sum_sq.hpp
Evaluate a Function Defined in Terms of an ODE: 11.2.2.8: ode_evaluate
ode_evaluate: Example and test: 11.2.2.8.1: ode_evaluate.cpp
Source: ode_evaluate: 11.2.2.8.2: ode_evaluate.hpp
Evaluate a Function That Has a Sparse Hessian: 11.2.2.9: sparse_evaluate
sparse_evaluate: Example and test: 11.2.2.9.1: sparse_evaluate.cpp
Source: sparse_evaluate: 11.2.2.9.2: sparse_evaluate.hpp
Speed Test of Functions in Double: 11.2.3: speed_double
Double Speed: Determinant by Minor Expansion: 11.2.3.1: double_det_minor.cpp
Double Speed: Determinant Using Lu Factorization: 11.2.3.2: double_det_lu.cpp
CppAD Speed: Matrix Multiplication (Double Version): 11.2.3.3: double_mat_mul.cpp
Double Speed: Ode Solution: 11.2.3.4: double_ode.cpp
Double Speed: Evaluate a Polynomial: 11.2.3.5: double_poly.cpp
Double Speed: Sparse Hessian: 11.2.3.6: double_sparse_hessian.cpp
Double Speed: Sparse Jacobian: 11.2.3.7: double_sparse_jacobian.cpp
Speed Test of Derivatives Using Adolc: 11.2.4: speed_adolc
Adolc Speed: Gradient of Determinant by Minor Expansion: 11.2.4.1: adolc_det_minor.cpp
Adolc Speed: Gradient of Determinant Using Lu Factorization: 11.2.4.2: adolc_det_lu.cpp
Adolc Speed: Matrix Multiplication: 11.2.4.3: adolc_mat_mul.cpp
Adolc Speed: Ode: 11.2.4.4: adolc_ode.cpp
Adolc Speed: Second Derivative of a Polynomial: 11.2.4.5: adolc_poly.cpp
Adolc Speed: Sparse Hessian: 11.2.4.6: adolc_sparse_hessian.cpp
adolc Speed: sparse_jacobian: 11.2.4.7: adolc_sparse_jacobian.cpp
Speed Test Derivatives Using CppAD: 11.2.5: speed_cppad
CppAD Speed: Gradient of Determinant by Minor Expansion: 11.2.5.1: cppad_det_minor.cpp
CppAD Speed: Gradient of Determinant Using Lu Factorization: 11.2.5.2: cppad_det_lu.cpp
CppAD Speed: Matrix Multiplication: 11.2.5.3: cppad_mat_mul.cpp
CppAD Speed: Gradient of Ode Solution: 11.2.5.4: cppad_ode.cpp
CppAD Speed: Second Derivative of a Polynomial: 11.2.5.5: cppad_poly.cpp
CppAD Speed: Sparse Hessian: 11.2.5.6: cppad_sparse_hessian.cpp
CppAD Speed: Sparse Jacobian: 11.2.5.7: cppad_sparse_jacobian.cpp
Speed Test Derivatives Using Fadbad: 11.2.6: speed_fadbad
Fadbad Speed: Gradient of Determinant by Minor Expansion: 11.2.6.1: fadbad_det_minor.cpp
Fadbad Speed: Gradient of Determinant Using Lu Factorization: 11.2.6.2: fadbad_det_lu.cpp
Fadbad Speed: Matrix Multiplication: 11.2.6.3: fadbad_mat_mul.cpp
Fadbad Speed: Ode: 11.2.6.4: fadbad_ode.cpp
Fadbad Speed: Second Derivative of a Polynomial: 11.2.6.5: fadbad_poly.cpp
Fadbad Speed: Sparse Hessian: 11.2.6.6: fadbad_sparse_hessian.cpp
fadbad Speed: sparse_jacobian: 11.2.6.7: fadbad_sparse_jacobian.cpp
Speed Test Derivatives Using Sacado: 11.2.7: speed_sacado
Sacado Speed: Gradient of Determinant by Minor Expansion: 11.2.7.1: sacado_det_minor.cpp
Sacado Speed: Gradient of Determinant Using Lu Factorization: 11.2.7.2: sacado_det_lu.cpp
Sacado Speed: Matrix Multiplication: 11.2.7.3: sacado_mat_mul.cpp
Sacado Speed: Gradient of Ode Solution: 11.2.7.4: sacado_ode.cpp
Sacado Speed: Second Derivative of a Polynomial: 11.2.7.5: sacado_poly.cpp
Sacado Speed: Sparse Hessian: 11.2.7.6: sacado_sparse_hessian.cpp
sacado Speed: sparse_jacobian: 11.2.7.7: sacado_sparse_jacobian.cpp
The Theory of Derivative Calculations: 11.3: Theory
The Theory of Forward Mode: 11.3.1: ForwardTheory
Exponential Function Forward Taylor Polynomial Theory: 11.3.1.1: ExpForward
Logarithm Function Forward Taylor Polynomial Theory: 11.3.1.2: LogForward
Square Root Function Forward Taylor Polynomial Theory: 11.3.1.3: SqrtForward
Trigonometric and Hyperbolic Sine and Cosine Forward Theory: 11.3.1.4: SinCosForward
Arctangent Function Forward Taylor Polynomial Theory: 11.3.1.5: AtanForward
Arcsine Function Forward Taylor Polynomial Theory: 11.3.1.6: AsinForward
Arccosine Function Forward Taylor Polynomial Theory: 11.3.1.7: AcosForward
Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory: 11.3.1.8: tan_forward
The Theory of Reverse Mode: 11.3.2: ReverseTheory
Exponential Function Reverse Mode Theory: 11.3.2.1: ExpReverse
Logarithm Function Reverse Mode Theory: 11.3.2.2: LogReverse
Square Root Function Reverse Mode Theory: 11.3.2.3: SqrtReverse
Trigonometric and Hyperbolic Sine and Cosine Reverse Theory: 11.3.2.4: SinCosReverse
Arctangent Function Reverse Mode Theory: 11.3.2.5: AtanReverse
Arcsine Function Reverse Mode Theory: 11.3.2.6: AsinReverse
Arccosine Function Reverse Mode Theory: 11.3.2.7: AcosReverse
Tangent and Hyperbolic Tangent Reverse Mode Theory: 11.3.2.8: tan_reverse
An Important Reverse Mode Identity: 11.3.3: reverse_identity
Glossary: 11.4: glossary
Bibliography: 11.5: Bib
Know Bugs and Problems Using CppAD: 11.6: Bugs
The CppAD Wish List: 11.7: WishList
Changes and Additions to CppAD: 11.8: whats_new
CppAD Changes and Additions During 2012: 11.8.1: whats_new_12
Changes and Additions to CppAD During 2011: 11.8.2: whats_new_11
Changes and Additions to CppAD During 2010: 11.8.3: whats_new_10
Changes and Additions to CppAD During 2009: 11.8.4: whats_new_09
Changes and Additions to CppAD During 2008: 11.8.5: whats_new_08
Changes and Additions to CppAD During 2007: 11.8.6: whats_new_07
Changes and Additions to CppAD During 2006: 11.8.7: whats_new_06
Changes and Additions to CppAD During 2005: 11.8.8: whats_new_05
Changes and Additions to CppAD During 2004: 11.8.9: whats_new_04
Changes and Additions to CppAD During 2003: 11.8.10: whats_new_03
CppAD Deprecated API Features: 11.9: deprecated
Deprecated Include Files: 11.9.1: include_deprecated
ADFun Object Deprecated Member Functions: 11.9.2: FunDeprecated
OpenMP Parallel Setup: 11.9.3: omp_max_thread
Routines That Track Use of New and Delete: 11.9.4: TrackNewDel
Tracking Use of New and Delete: Example and Test: 11.9.4.1: TrackNewDel.cpp
A Quick OpenMP Memory Allocator Used by CppAD: 11.9.5: omp_alloc
Set and Get Maximum Number of Threads for omp_alloc Allocator: 11.9.5.1: omp_max_num_threads
Is The Current Execution in OpenMP Parallel Mode: 11.9.5.2: omp_in_parallel
Get the Current OpenMP Thread Number: 11.9.5.3: omp_get_thread_num
Get At Least A Specified Amount of Memory: 11.9.5.4: omp_get_memory
Return Memory to omp_alloc: 11.9.5.5: omp_return_memory
Free Memory Currently Available for Quick Use by a Thread: 11.9.5.6: omp_free_available
Amount of Memory a Thread is Currently Using: 11.9.5.7: omp_inuse
Amount of Memory Available for Quick Use by a Thread: 11.9.5.8: omp_available
Allocate Memory and Create A Raw Array: 11.9.5.9: omp_create_array
Return A Raw Array to The Available Memory for a Thread: 11.9.5.10: omp_delete_array
Check If A Memory Allocation is Efficient for Another Use: 11.9.5.11: omp_efficient
Set Maximum Number of Threads for omp_alloc Allocator: 11.9.5.12: old_max_num_threads
OpenMP Memory Allocator: Example and Test: 11.9.5.13: omp_alloc.cpp
Your License for the CppAD Software: 11.10: License
Alphabetic Listing of Cross Reference Tags: 12: _reference
Keyword Index: 13: _index
External Internet References: 14: _external
yum install cppad-devel
(In Fedora, devel is used for program development tools.)
You can download and install the corresponding version of the
documentation using the command
yum install cppad-doc
cppad.spec file
to build an RPM for some other operating system,
it can be found at
tar
and then compressed with gzip:
The ascii files for these downloads are in
Unix format; i.e., each line ends with just a line feed.
CPL License | cppad-20120203.cpl.tgz |
GPL License | cppad-20120203.gpl.tgz |
tar -xvzf cppad-20120203.license.tgz
license
is cpl or gpl)
to decompress and extract the unix format version
into the distribution directory
cppad-20120203
cppad-20120203/cppad/cppad.hpp
cppad-20120203/work,
which will be referred to as the work directory below.
./configure \
--prefix=PrefixDir \
--with-Documentation \
--with-stdvector \
--with-boostvector \
CXX_FLAGS=CompilerFlags \
OPENMP_FLAGS=OpenmpFlags \
POSTFIX_DIR=PostfixDir \
ADOLC_DIR=AdolcDir \
FADBAD_DIR=FadbadDir \
SADADO_DIR=SacadoDir \
BOOST_DIR=BoostDir \
IPOPT_DIR=IpoptDir \
TAPE_ADDR_TYPE=TapeAddrType
configure line need appear; i.e.,
the entries one each of the other lines are optional.
The text in italic is replaced values that you choose;
see discussion below.
make
make command,
you can run the correctness and speed tests.
make test
| 3.1.i: get_started | Getting Started Using CppAD to Compute Derivatives |
| 3.4.a: exp_apx_main | Correctness Tests For Exponential Approximation in Introduction |
| 9.2.1.a: example | CppAD Examples and Tests |
| 4.3.4.1.a: print_for_cout | Printing During Forward Mode: Example and Test |
| 9.2.2.a: speed_example | Run the Speed Examples |
| 11.2.3.b: speed_double | Speed Test of Functions in Double |
| 11.2.4.c: speed_adolc | Speed Test of Derivatives Using Adolc |
| 11.2.5.b: speed_cppad | Speed Test Derivatives Using CppAD |
| 11.2.6.c: speed_fadbad | Speed Test Derivatives Using Fadbad |
| 11.2.7.c: speed_sacado | Speed Test Derivatives Using Sacado |
cd test_more
make test
cd speed/profile
make test
make test, you can run a profile speed test
by executing the command ./profile;
see 11.2.1: speed_main
for the meaning of the command line
options to this program.
gprof -b profile
profile by profile.exe
in the gprof command above; i.e.,
gprof -b profile.exe
gprof output hard to read
(the routine names can be very long).
You can remove the template parameters and argument types from the
routine names by executing the following command
gprof -b profile | sed -f gprof.sed
gprof -b profile.exe | sed -f gprof.sed
$HOME
i.e., by default the CppAD include files
will 2.1.t: install
below $HOME.
If you want to install elsewhere, you will have to use this option.
As an example of using the
--prefix=PrefixDir
option,
if you specify
./configure --prefix=/usr/local
/usr/local/include/cppad
/usr/local/share/doc/cppad-20120203
--with-Documentation is specified,
the CppAD documentation HTML and XML files are copied to the directory
PrefixDir/share/doc/PostfixDir/cppad-20120203
PrefixDir/share/doc/PostfixDir/cppad-20120203/cppad.htm
PrefixDir/share/doc/PostfixDir/cppad-20120203/cppad.xml
--with-stdvector is specified,
the default definition this template class is replaced by
std::vector
--with-boostvector must not also be specified.
--with-boostvector is specified,
the default definition this template class is replaced by
boost::numeric::ublas::vector
--with-stdvector must not also be specified.
See also, 2.1.q: BoostDir
CompilerFlags
is present,
it specifies compiler flags.
For example,
CXX_FLAGS="-Wall -ansi"
-Wall
and -ansi should be included
in all the C++ compile commands.
The error and warning flags chosen must be valid options
for the C++ compiler.
The default value for
CompilerFlags
is the
empty string.
OpenmpFlags
is present,
it specifies the necessary flags so that the compiler will
properly interpret OpenMP directives.
For example, when using the GNU g++ compiler,
the following setting includes the OpenMP tests:
OPENMP_FLAGS=-fopenmp
POSTFIX_DIR=PostfixDir
option,
if you specify
./configure --prefix=/usr/local POSTFIX_DIR=coin
/usr/local/include/coin/cppad
/usr/local/share/doc/coin/cppad-20120203
AdolcDir
in the
2.1.d: configure
command line.
The value of
AdolcDir
must be such that
AdolcDir/include/adolc/adouble.h
adouble.h.
In this case, you can run the Adolc speed correctness tests
by executing the following commands starting in the work directory:
cd speed/adolc
make test
make test, you can run an Adolc speed tests
by executing the command ./adolc;
see 11.2.1: speed_main
for the meaning of the command line
options to this program.
.bash_profile in your home directory:
LD_LIBRARY_PATH=AdolcDir/lib:${LD_LIBRARY_PATH}
export LD_LIBRARY_PATH
.bash_profile in your home directory:
PATH=AdolcDir/bin:${PATH}
export PATH
AdolcDir
begins with a disk specification,
you must use the Cygwin format for the disk specification.
For example,
if d:/adolc_base is the proper directory,
/cygdrive/d/adolc_base should be used for
AdolcDir
.
FadbadDir
.
It must be such that
FadbadDir/FADBAD++/badiff.h
badiff.h.
In this case, you can run the Fadbad speed correctness tests
by executing the following commands starting in the work directory:
cd speed/fadbad
make test
make test, you can run a Fadbad speed tests
by executing the command ./fadbad;
see 11.2.1: speed_main
for the meaning of the command line
options to this program.
SacadoDir
.
It must be such that
SacadoDir/include/Sacado.hpp
Sacado.hpp.
In this case, you can run the Sacado speed correctness tests
by executing the following commands starting in the work directory:
cd speed/sacado
make test
make test, you can run a Sacado speed tests
by executing the command ./sacado;
see 11.2.1: speed_main
for the meaning of the command line
options to this program.
BOOST_DIR=BoostDir
BoostDir/boost/numeric/ublas/vector.hpp
BoostDir/boost/thread.hpp
IpoptDir
.
It must be such that
IpoptDir/include/coin/IpIpoptApplication.hpp
IpIpoptApplication.hpp.
In this case, the CppAD interface to Ipopt
8.u: examples
can be built and tested
by executing the following commands starting in the work directory:
make
#
cd cppad_ipopt/example
make test
#
cd ../test
make test
#
cd ../speed
make test
./speed in the work/cppad_ipopt/speed directory;
see 8.4: ipopt_ode_speed.cpp
.
TapeAddrType
is present,
it specifies the type used for address in the AD recordings (tapes).
The valid values for this argument are
unsigned short int,
unsigned int,
size_t.
The smaller the value of
sizeof(TapeAddrType)
,
the less memory is used.
On the other hand, the value
std::numeric_limits<TapeAddrType>::max()
make install
PrefixDir
directory to execute this command.
You may optionally specify a destination directory for the install; i.e.,
make install DESTDIR=DestinationDirectory
which svn
which omhelp
svn co https://projects.coin-or.org/svn/CppAD/dir dir
dir
is replaced by trunk.
To see if this has been done correctly, check for the following file:
dir/cppad/cppad.hpp
dir
values
corresponding to
stable versions
(https://projects.coin-or.org/CppAD/browser/stable) .
The following command will download a
stable version of the CppAD source code:
svn co https://projects.coin-or.org/svn/CppAD/stable/dir dir
dir/cppad/cppad.hpp
dir
values
corresponding to
release versions
(https://projects.coin-or.org/CppAD/browser/releases) .
The following command will download a
stable version of the CppAD source code:
svn co https://projects.coin-or.org/svn/CppAD/stable/dir dir
dir/cppad/cppad.hpp
mkdir dir/doc
cd dir/doc
omhelp ../doc.omh -noframe -debug -l http://www.coin-or.org/CppAD/ -xml
dir/doc/index.xml
pkg-config package helps with the use of installed libraries;
see its
guide
(http://people.freedesktop.org/~dbn/pkg-config-guide.html)
for more information.
Name
| A human-readable name for the CppAD package. |
Description
| A brief description of the CppAD package. |
URL
| A URL where people can get more information about the CppAD package. |
Version
| A string specifically defining the version of the CppAD package. |
Cflags
| The necessary flags for using any of the CppAD include files. |
builddir
is the build directory; i.e., the directory where
the CppAD
2.1.d: Configure
command is execute.
The directory
prefixdir
is the value of
2.1.g: PrefixDir
during configuration.
The following configuration files contain the information above
File
|
Description
|
prefixdir/share/pkgconfig/cppad.pc
| for use after 2.1.t: make install |
builddir/pkgconfig/cppad-uninstalled.pc
|
for testing before make install
|
tar
and then compressed with gzip.
The ascii files are in Unix format; i.e., each line ends with a
line feed (instead of a carriage return and line feed as is standard for
windows formatted files).
Visual Studio can handel this formatting just fine, but you may
want to convert the format to the windows standard if you are using
and editor that has trouble viewing the files in Unix format.
and then a line feed.
CPL License | cppad-20120203.cpl.tgz |
GPL License | cppad-20120203.gpl.tgz |
All archives) as the file type
in the Open browser.
Yes button.
Extract button from the main menu.
Extract to field and then select the Extract button
in the pop-up dialog.
Winzip will create a subdirectory called cppad-20120203
where the files are placed.
cppad-20120203\introduction\get_started\get_started.sln
Build | Build get_started.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following command
introduction\get_started\Debug\get_started
cppad-20120203\introduction\exp_apx\exp_apx.sln
Build | Build exp_apx.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following command
introduction\exp_apx\Debug\exp_apx
cppad-20120203\example\example.sln
Build | Build Example.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following command
example\Debug\example
cppad-20120203\test_more\test_more.sln
Build | Build test_more.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following command
test_more\Debug\test_more
cppad-20120203\print_for\print_for.sln
Build | Build print_for.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following command
print_for\Debug\print_for
cppad-20120203\speed\cppad\cppad.sln
Build | Build cppad.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following commands
speed\cppad\Debug\cppad correct 123
speed\cppad\Debug\cppad speed 123
cppad-20120203\speed\double\double.sln
Build | Build double.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following commands
speed\double\Debug\double correct 123
speed\double\Debug\double speed 123
cppad-20120203\speed\example\example.sln
in Visual Studio.
Then select Build | Build example.exe.
Then in a Dos box, and in the cppad-20120203 directory,
execute the following command
speed\example\Debug\example
while loop.
For each of these algorithms, do the following:
| get_started.cpp: 3.1 | Getting Started Using CppAD to Compute Derivatives |
| exp_2: 3.2 | Second Order Exponential Approximation |
| exp_eps: 3.3 | An Epsilon Accurate Exponential Approximation |
| exp_apx_main.cpp: 3.4 | Correctness Tests For Exponential Approximation in Introduction |
Poly is defined below for this particular application.
A general purpose polynomial evaluation routine is documented and
distributed with CppAD (see 7.12: Poly
).
#include <iostream> // standard input/output
#include <vector> // standard vector
#include <cppad/cppad.hpp> // the CppAD package http://www.coin-or.org/CppAD/
namespace {
// define y(x) = Poly(a, x) in the empty namespace
template <class Type>
Type Poly(const std::vector<double> &a, const Type &x)
{ size_t k = a.size();
Type y = 0.; // initialize summation
Type x_i = 1.; // initialize x^i
size_t i;
for(i = 0; i < k; i++)
{ y += a[i] * x_i; // y = y + a_i * x^i
x_i *= x; // x_i = x_i * x
}
return y;
}
}
// main program
int main(void)
{ using CppAD::AD; // use AD as abbreviation for CppAD::AD
using std::vector; // use vector as abbreviation for std::vector
size_t i; // a temporary index
// vector of polynomial coefficients
size_t k = 5; // number of polynomial coefficients
vector<double> a(k); // vector of polynomial coefficients
for(i = 0; i < k; i++)
a[i] = 1.; // value of polynomial coefficients
// domain space vector
size_t n = 1; // number of domain space variables
vector< AD<double> > X(n); // vector of domain space variables
X[0] = 3.; // value corresponding to operation sequence
// declare independent variables and start recording operation sequence
CppAD::Independent(X);
// range space vector
size_t m = 1; // number of ranges space variables
vector< AD<double> > Y(m); // vector of ranges space variables
Y[0] = Poly(a, X[0]); // value during recording of operations
// store operation sequence in f: X -> Y and stop recording
CppAD::ADFun<double> f(X, Y);
// compute derivative using operation sequence stored in f
vector<double> jac(m * n); // Jacobian of f (m by n matrix)
vector<double> x(n); // domain space vector
x[0] = 3.; // argument value for derivative
jac = f.Jacobian(x); // Jacobian for operation sequence
// print the results
std::cout << "f'(3) computed by CppAD = " << jac[0] << std::endl;
// check if the derivative is correct
int error_code;
if( jac[0] == 142. )
error_code = 0; // return code for correct case
else error_code = 1; // return code for incorrect case
return error_code;
}
f'(3) computed by CppAD = 142
cd introduction/get_started
make test
# include "exp_2.hpp"
y = exp_2(x)
cppad-yyyymmdd/introduction/exp_apx
cppad-yyyymmdd
is the distribution directory
created during the beginning steps of the
2: installation
of CppAD.
x
has prototype
const Type &x
Type
below).
It specifies the point at which to evaluate the
approximation for the second order exponential approximation.
y
has prototype
Type y
u
and v are Type objects and i
is an int:
| Operation | Result Type | Description |
Type(i)
|
Type
|
construct object with value equal to
i
|
Type u = v
|
Type
|
construct
u
with value equal to
v
|
u * v
|
Type
| result is value of |
u / v
|
Type
| result is value of |
u + v
|
Type
| result is value of |
| exp_2.hpp: 3.2.1 | exp_2: Implementation |
| exp_2.cpp: 3.2.2 | exp_2: Test |
| exp_2_for0: 3.2.3 | exp_2: Operation Sequence and Zero Order Forward Mode |
| exp_2_for1: 3.2.4 | exp_2: First Order Forward Mode |
| exp_2_rev1: 3.2.5 | exp_2: First Order Reverse Mode |
| exp_2_for2: 3.2.6 | exp_2: Second Order Forward Mode |
| exp_2_rev2: 3.2.7 | exp_2: Second Order Reverse Mode |
| exp_2_cppad: 3.2.8 | exp_2: CppAD Forward and Reverse Sweeps |
double x = .1;
double y = exp_2(x);
v1, v2, ... ,v5 in 3.2.1: exp_2.hpp
?
exp_2.hpp to
a routine exp_3.hpp that computes
Do this in a way that only assigns one value to each variable
(as exp_2 does).
double x = .5;
double y = exp_3(x);
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;
}
| Index |
| Code |
| Operation |
| Zero Order |
| 1 |
|
Type v1 = x;
| ||||
| 2 |
|
Type v2 = Type(1) + v1;
| ||||
| 3 |
|
Type v3 = v1 * v1;
| ||||
| 4 |
|
Type v4 = v3 / Type(2);
| ||||
| 5 |
|
Type v5 = v2 + v4;
|
# 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);
}
| Index |
| Operation |
| Zero Order |
| Derivative |
| First Order |
| 1 |
| 0.5 | ||||||
| 2 |
| 1.5 | ||||||
| 3 |
| 0.25 | ||||||
| 4 |
| 0.125 | ||||||
| 5 |
| 1.625 |
# 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);
}
# 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;
}
| Index |
| Zero |
| Operation |
| First |
| Derivative |
| Second |
| 1 | 0.5 |
| 1 | |||||||
| 2 | 1.5 |
| 1 | |||||||
| 3 | 0.25 |
| 1 | |||||||
| 4 | 0.125 |
| .5 | |||||||
| 5 | 1.625 |
| 1.5 |
# 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;
}
# include <cstddef> // define size_t
# 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_rev2(void)
{ bool ok = true;
// set the value of v0[j], v1[j] for j = 1 , ... , 5
double v0[6], v1[6];
ok &= exp_2_for0(v0);
ok &= exp_2_for1(v1);
// initial all partial derivatives as zero
double f_v0[6], f_v1[6];
size_t j;
for(j = 0; j < 6; j++)
{ f_v0[j] = 0.;
f_v1[j] = 0.;
}
// set partial derivative for f_5
f_v1[5] = 1.;
ok &= std::fabs( f_v1[5] - 1. ) <= 1e-10; // partial f_5 w.r.t v_5^1
// f_4 = f_5( v_1^0 , ... , v_4^1 , v_2^0 + v_4^0 , v_2^1 + v_4^1 )
f_v0[2] += f_v0[5] * 1.;
f_v0[4] += f_v0[5] * 1.;
f_v1[2] += f_v1[5] * 1.;
f_v1[4] += f_v1[5] * 1.;
ok &= std::fabs( f_v0[2] - 0. ) <= 1e-10; // partial f_4 w.r.t. v_2^0
ok &= std::fabs( f_v0[4] - 0. ) <= 1e-10; // partial f_4 w.r.t. v_4^0
ok &= std::fabs( f_v1[2] - 1. ) <= 1e-10; // partial f_4 w.r.t. v_2^1
ok &= std::fabs( f_v1[4] - 1. ) <= 1e-10; // partial f_4 w.r.t. v_4^1
// f_3 = f_4( v_1^0 , ... , v_3^1, v_3^0 / 2 , v_3^1 / 2 )
f_v0[3] += f_v0[4] / 2.;
f_v1[3] += f_v1[4] / 2.;
ok &= std::fabs( f_v0[3] - 0. ) <= 1e-10; // partial f_3 w.r.t. v_3^0
ok &= std::fabs( f_v1[3] - 0.5 ) <= 1e-10; // partial f_3 w.r.t. v_3^1
// f_2 = f_3( v_1^0 , ... , v_2^1, v_1^0 * v_1^0 , 2 * v_1^0 * v_1^1 )
f_v0[1] += f_v0[3] * 2. * v0[1];
f_v0[1] += f_v1[3] * 2. * v1[1];
f_v1[1] += f_v1[3] * 2. * v0[1];
ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_2 w.r.t. v_1^0
ok &= std::fabs( f_v1[1] - 0.5 ) <= 1e-10; // partial f_2 w.r.t. v_1^1
// f_1 = f_2( v_1^0 , v_1^1 , 1 + v_1^0 , v_1^1 )
f_v0[1] += f_v0[2] * 1.;
f_v1[1] += f_v1[2] * 1.;
ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_1 w.r.t. v_1^0
ok &= std::fabs( f_v1[1] - 1.5) <= 1e-10; // partial f_1 w.r.t. v_1^1
return ok;
}
exp_2()
as defined by the 3.2.1: exp_2.hpp
include file.
exp_2()
exp_3()
that evaluates the function
Test a modified version of the routine below that computes
the derivative of
at the point
.
# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
# include "exp_2.hpp" // second order exponential approximation
bool exp_2_cppad(void)
{ bool ok = true;
using CppAD::AD;
using CppAD::vector; // can use any simple vector template class
using CppAD::NearEqual; // checks if values are nearly equal
// domain space vector
size_t n = 1; // dimension of the domain space
vector< AD<double> > X(n);
X[0] = .5; // value of x for this operation sequence
// declare independent variables and start recording operation sequence
CppAD::Independent(X);
// evaluate our exponential approximation
AD<double> x = X[0];
AD<double> apx = exp_2(x);
// range space vector
size_t m = 1; // dimension of the range space
vector< AD<double> > Y(m);
Y[0] = apx; // variable that represents only range space component
// Create f: X -> Y corresponding to this operation sequence
// and stop recording. This also executes a zero order forward
// sweep using values in X for x.
CppAD::ADFun<double> f(X, Y);
// first order forward sweep that computes
// partial of exp_2(x) with respect to x
vector<double> dx(n); // differential in domain space
vector<double> dy(m); // differential in range space
dx[0] = 1.; // direction for partial derivative
dy = f.Forward(1, dx);
double check = 1.5;
ok &= NearEqual(dy[0], check, 1e-10, 1e-10);
// first order reverse sweep that computes the derivative
vector<double> w(m); // weights for components of the range
vector<double> dw(n); // derivative of the weighted function
w[0] = 1.; // there is only one weight
dw = f.Reverse(1, w); // derivative of w[0] * exp_2(x)
check = 1.5; // partial of exp_2(x) with respect to x
ok &= NearEqual(dw[0], check, 1e-10, 1e-10);
// second order forward sweep that computes
// second partial of exp_2(x) with respect to x
vector<double> x2(n); // second order Taylor coefficients
vector<double> y2(m);
x2[0] = 0.; // evaluate second partial .w.r.t. x
y2 = f.Forward(2, x2);
check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
ok &= NearEqual(y2[0], check, 1e-10, 1e-10);
// second order reverse sweep that computes
// derivative of partial of exp_2(x) w.r.t. x
dw.resize(2 * n); // space for first and second derivatives
dw = f.Reverse(2, w);
check = 1.; // result should be second derivative
ok &= NearEqual(dw[0*2+1], check, 1e-10, 1e-10);
return ok;
}
# include "exp_eps.hpp"
y = exp_eps(x, epsilon)
cppad-yyyymmdd/introduction/exp_apx
cppad-yyyymmdd
is the distribution directory
created during the beginning steps of the
2: installation
of CppAD.
x
has prototype
const Type &x
Type
below).
It specifies the point at which to evaluate the
approximation for the exponential function.
epsilon
has prototype
const Type &epsilon
y
has prototype
Type y
u
and v are Type objects and i
is an int:
| Operation | Result Type | Description |
Type(i)
|
Type
|
object with value equal to
i
|
Type u = v
|
Type
|
construct
u
with value equal to
v
|
u > v
|
bool
|
true,
if
u
greater than v, an false otherwise
|
u = v
|
Type
|
new
u
(and result) is value of v
|
u * v
|
Type
| result is value of |
u / v
|
Type
| result is value of |
u + v
|
Type
| result is value of |
-u
|
Type
| result is value of |
exp_eps:
double x = 1.;
double epsilon = .01;
double y = exp_eps(x, epsilon);
k, temp, term, and sum
the first time through the while loop in 3.3.1: exp_eps.hpp
?
k, temp, term, and sum
the second time through the while loop in 3.3.1: exp_eps.hpp
?
template <class Type>
Type exp_eps(const Type &x, const Type &epsilon)
{ // abs_x = |x|
Type abs_x = x;
if( Type(0) > x )
abs_x = - x;
// initialize
int k = 0; // initial order
Type term = 1.; // term = |x|^k / k !
Type sum = term; // initial sum
while(term > epsilon)
{ k = k + 1; // order for next term
Type temp = term * abs_x; // term = |x|^k / (k-1)!
term = temp / Type(k); // term = |x|^k / k !
sum = sum + term; // sum = 1 + ... + |x|^k / k !
}
// In the case where x is negative, use exp(x) = 1 / exp(-|x|)
if( Type(0) > x )
sum = Type(1) / sum;
return sum;
}
# include <cmath> // for fabs function
# include "exp_eps.hpp" // definition of exp_eps algorithm
bool exp_eps(void)
{ double x = .5;
double epsilon = .2;
double check = 1 + .5 + .125; // include 1 term less than epsilon
bool ok = std::fabs( exp_eps(x, epsilon) - check ) <= 1e-10;
return ok;
}
exp_eps(x, epsilon)
with x is equal to .5
and epsilon is equal to .2.
For this case,
the mathematical form for the operation sequence
corresponding to the exp_eps is
Note that, for these particular values of x and epsilon,
this is the same as the mathematical form for
3.2.3.a: exp_2
.
| Index |
| Code |
| Operation |
| Zero Order |
| 1 |
|
abs_x = x;
| ||||
| 2 |
|
temp = term * abs_x;
| ||||
| 3 |
|
term = temp / Type(k);
| ||||
| 4 |
|
sum = sum + term;
| ||||
| 5 |
|
temp = term * abs_x;
| ||||
| 6 |
|
term = temp / Type(k);
| ||||
| 7 |
|
sum = sum + term;
|
if( Type(0) > x )
while(term > epsilon)
# include <cmath> // for fabs function
bool exp_eps_for0(double *v0) // double v0[8]
{ bool ok = true;
double x = .5;
v0[1] = x; // abs_x = x;
ok &= std::fabs( v0[1] - 0.5) < 1e-10;
v0[2] = 1. * v0[1]; // temp = term * abs_x;
ok &= std::fabs( v0[2] - 0.5) < 1e-10;
v0[3] = v0[2] / 1.; // term = temp / Type(k);
ok &= std::fabs( v0[3] - 0.5) < 1e-10;
v0[4] = 1. + v0[3]; // sum = sum + term;
ok &= std::fabs( v0[4] - 1.5) < 1e-10;
v0[5] = v0[3] * v0[1]; // temp = term * abs_x;
ok &= std::fabs( v0[5] - 0.25) < 1e-10;
v0[6] = v0[5] / 2.; // term = temp / Type(k);
ok &= std::fabs( v0[6] - 0.125) < 1e-10;
v0[7] = v0[4] + v0[6]; // sum = sum + term;
ok &= std::fabs( v0[7] - 1.625) < 1e-10;
return ok;
}
bool exp_eps_for0(void)
{ double v0[8];
return exp_eps_for0(v0);
}
exp_eps(x, epsilon)
with x is equal to .5
and epsilon is equal to .2.
For this case, the mathematical function for the operation sequence
corresponding to exp_eps is
The corresponding partial derivative with respect to
,
and the value of the derivative, are
| Index |
| Operation |
| Zero Order |
| Derivative |
| First Order |
| 1 |
| 0.5 | ||||||
| 2 |
| 0.5 | ||||||
| 3 |
| 0.5 | ||||||
| 4 |
| 1.5 | ||||||
| 5 |
| 0.25 | ||||||
| 6 |
| 0.125 | ||||||
| 7 |
| 1.625 |
exp_eps(, epsilon)
# include <cmath> // for fabs function
extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
bool exp_eps_for1(double *v1) // double v[8]
{ bool ok = true;
double v0[8];
// set the value of v0[j] for j = 1 , ... , 7
ok &= exp_eps_for0(v0);
v1[1] = 1.; // v1 = x
ok &= std::fabs( v1[1] - 1. ) <= 1e-10;
v1[2] = 1. * v1[1]; // v2 = 1 * v1
ok &= std::fabs( v1[2] - 1. ) <= 1e-10;
v1[3] = v1[2] / 1.; // v3 = v2 / 1
ok &= std::fabs( v1[3] - 1. ) <= 1e-10;
v1[4] = v1[3]; // v4 = 1 + v3
ok &= std::fabs( v1[4] - 1. ) <= 1e-10;
v1[5] = v1[3] * v0[1] + v0[3] * v1[1]; // v5 = v3 * v1
ok &= std::fabs( v1[5] - 1. ) <= 1e-10;
v1[6] = v1[5] / 2.; // v6 = v5 / 2
ok &= std::fabs( v1[6] - 0.5 ) <= 1e-10;
v1[7] = v1[4] + v1[6]; // v7 = v4 + v6
ok &= std::fabs( v1[7] - 1.5 ) <= 1e-10;
return ok;
}
bool exp_eps_for1(void)
{ double v1[8];
return exp_eps_for1(v1);
}
exp_eps(x, epsilon)
with x is equal to .5
and epsilon is equal to .2.
For this case, the mathematical function for the operation sequence
corresponding to exp_eps is
The corresponding partial derivatives,
and the value of the derivatives, are
exp_eps(x, epsilon)
at x equal to .5 and epsilon equal .2 is
1.5 in the x direction and zero in the epsilon direction.
We also note that
3.3.4: forward
forward mode gave the
same result for the partial in the x direction.
# include <cstddef> // define size_t
# include <cmath> // for fabs function
extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
bool exp_eps_rev1(void)
{ bool ok = true;
// set the value of v0[j] for j = 1 , ... , 7
double v0[8];
ok &= exp_eps_for0(v0);
// initial all partial derivatives as zero
double f_v[8];
size_t j;
for(j = 0; j < 8; j++)
f_v[j] = 0.;
// set partial derivative for f7
f_v[7] = 1.;
ok &= std::fabs( f_v[7] - 1. ) <= 1e-10; // f7_v7
// f6( v1 , v2 , v3 , v4 , v5 , v6 )
f_v[4] += f_v[7] * 1.;
f_v[6] += f_v[7] * 1.;
ok &= std::fabs( f_v[4] - 1. ) <= 1e-10; // f6_v4
ok &= std::fabs( f_v[6] - 1. ) <= 1e-10; // f6_v6
// f5( v1 , v2 , v3 , v4 , v5 )
f_v[5] += f_v[6] / 2.;
ok &= std::fabs( f_v[5] - 0.5 ) <= 1e-10; // f5_v5
// f4( v1 , v2 , v3 , v4 )
f_v[1] += f_v[5] * v0[3];
f_v[3] += f_v[5] * v0[1];
ok &= std::fabs( f_v[1] - 0.25) <= 1e-10; // f4_v1
ok &= std::fabs( f_v[3] - 0.25) <= 1e-10; // f4_v3
// f3( v1 , v2 , v3 )
f_v[3] += f_v[4] * 1.;
ok &= std::fabs( f_v[3] - 1.25) <= 1e-10; // f3_v3
// f2( v1 , v2 )
f_v[2] += f_v[3] / 1.;
ok &= std::fabs( f_v[2] - 1.25) <= 1e-10; // f2_v2
// f1( v1 )
f_v[1] += f_v[2] * 1.;
ok &= std::fabs( f_v[1] - 1.5 ) <= 1e-10; // f1_v2
return ok;
}
exp_eps(x, epsilon)
with x is equal to .5
and epsilon is equal to .2.
For this case, the mathematical function for the operation sequence
corresponding to exp_eps is
The corresponding second partial derivative with respect to
,
and the value of the derivative, are
| Index |
| Zero |
| Operation |
| First |
| Derivative |
| Second |
| 1 | 0.5 | 1 | 0 | |||||||
| 2 | 0.5 | 1 | 0 | |||||||
| 3 | 0.5 | 1 | 0 | |||||||
| 4 | 1.5 | 1 | 0 | |||||||
| 5 | 0.25 | 1 | 2 | |||||||
| 6 | 0.125 | 0.5 | 1 | |||||||
| 7 | 1.625 | 1.5 | 1 |
# include <cmath> // for fabs function
extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
extern bool exp_eps_for1(double *v1); // computes first order forward sweep
bool exp_eps_for2(void)
{ bool ok = true;
double v0[8], v1[8], v2[8];
// set the value of v0[j], v1[j] for j = 1 , ... , 7
ok &= exp_eps_for0(v0);
ok &= exp_eps_for1(v1);
v2[1] = 0.; // v1 = x
ok &= std::fabs( v2[1] - 0. ) <= 1e-10;
v2[2] = 1. * v2[1]; // v2 = 1 * v1
ok &= std::fabs( v2[2] - 0. ) <= 1e-10;
v2[3] = v2[2] / 1.; // v3 = v2 / 1
ok &= std::fabs( v2[3] - 0. ) <= 1e-10;
v2[4] = v2[3]; // v4 = 1 + v3
ok &= std::fabs( v2[4] - 0. ) <= 1e-10;
v2[5] = v2[3] * v0[1] + 2. * v1[3] * v1[1] // v5 = v3 * v1
+ v0[3] * v2[1];
ok &= std::fabs( v2[5] - 2. ) <= 1e-10;
v2[6] = v2[5] / 2.; // v6 = v5 / 2
ok &= std::fabs( v2[6] - 1. ) <= 1e-10;
v2[7] = v2[4] + v2[6]; // v7 = v4 + v6
ok &= std::fabs( v2[7] - 1. ) <= 1e-10;
return ok;
}
exp_eps(x, epsilon)
with x is equal to .5
and epsilon is equal to .2.
For this case, the mathematical function for the operation sequence
corresponding to exp_eps is
The corresponding derivative of the
partial derivative with respect to
is
exp_eps(x, epsilon)
at x equal to .5 and epsilon equal .2 is
There is a theorem about algorithmic differentiation that explains why
the other partial of
is equal to the first partial of
exp_eps(x, epsilon)
with respect to
.
# include <cstddef> // define size_t
# include <cmath> // for fabs function
extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
extern bool exp_eps_for1(double *v1); // computes first order forward sweep
bool exp_eps_rev2(void)
{ bool ok = true;
// set the value of v0[j], v1[j] for j = 1 , ... , 7
double v0[8], v1[8];
ok &= exp_eps_for0(v0);
ok &= exp_eps_for1(v1);
// initial all partial derivatives as zero
double f_v0[8], f_v1[8];
size_t j;
for(j = 0; j < 8; j++)
{ f_v0[j] = 0.;
f_v1[j] = 0.;
}
// set partial derivative for f_7
f_v1[7] = 1.;
ok &= std::fabs( f_v1[7] - 1. ) <= 1e-10; // partial f_7 w.r.t. v_7^1
// f_6 = f_7( v_1^0 , ... , v_6^1 , v_4^0 + v_6^0, v_4^1 , v_6^1 )
f_v0[4] += f_v0[7];
f_v0[6] += f_v0[7];
f_v1[4] += f_v1[7];
f_v1[6] += f_v1[7];
ok &= std::fabs( f_v0[4] - 0. ) <= 1e-10; // partial f_6 w.r.t. v_4^0
ok &= std::fabs( f_v0[6] - 0. ) <= 1e-10; // partial f_6 w.r.t. v_6^0
ok &= std::fabs( f_v1[4] - 1. ) <= 1e-10; // partial f_6 w.r.t. v_4^1
ok &= std::fabs( f_v1[6] - 1. ) <= 1e-10; // partial f_6 w.r.t. v_6^1
// f_5 = f_6( v_1^0 , ... , v_5^1 , v_5^0 / 2 , v_5^1 / 2 )
f_v0[5] += f_v0[6] / 2.;
f_v1[5] += f_v1[6] / 2.;
ok &= std::fabs( f_v0[5] - 0. ) <= 1e-10; // partial f_5 w.r.t. v_5^0
ok &= std::fabs( f_v1[5] - 0.5 ) <= 1e-10; // partial f_5 w.r.t. v_5^1
// f_4 = f_5( v_1^0 , ... , v_4^1 , v_3^0 * v_1^0 ,
// v_3^1 * v_1^0 + v_3^0 * v_1^1 )
f_v0[1] += f_v0[5] * v0[3] + f_v1[5] * v1[3];
f_v0[3] += f_v0[5] * v0[1] + f_v1[5] * v1[1];
f_v1[1] += f_v1[5] * v0[3];
f_v1[3] += f_v1[5] * v0[1];
ok &= std::fabs( f_v0[1] - 0.5 ) <= 1e-10; // partial f_4 w.r.t. v_1^0
ok &= std::fabs( f_v0[3] - 0.5 ) <= 1e-10; // partial f_4 w.r.t. v_3^0
ok &= std::fabs( f_v1[1] - 0.25 ) <= 1e-10; // partial f_4 w.r.t. v_1^1
ok &= std::fabs( f_v1[3] - 0.25 ) <= 1e-10; // partial f_4 w.r.t. v_3^1
// f_3 = f_4( v_1^0 , ... , v_3^1 , 1 + v_3^0 , v_3^1 )
f_v0[3] += f_v0[4];
f_v1[3] += f_v1[4];
ok &= std::fabs( f_v0[3] - 0.5 ) <= 1e-10; // partial f_3 w.r.t. v_3^0
ok &= std::fabs( f_v1[3] - 1.25) <= 1e-10; // partial f_3 w.r.t. v_3^1
// f_2 = f_3( v_1^0 , ... , v_2^1 , v_2^0 , v_2^1 )
f_v0[2] += f_v0[3];
f_v1[2] += f_v1[3];
ok &= std::fabs( f_v0[2] - 0.5 ) <= 1e-10; // partial f_2 w.r.t. v_2^0
ok &= std::fabs( f_v1[2] - 1.25) <= 1e-10; // partial f_2 w.r.t. v_2^1
// f_1 = f_2 ( v_1^0 , v_2^0 , v_1^0 , v_2^0 )
f_v0[1] += f_v0[2];
f_v1[1] += f_v1[2];
ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_1 w.r.t. v_1^0
ok &= std::fabs( f_v1[1] - 1.5 ) <= 1e-10; // partial f_1 w.r.t. v_1^1
return ok;
}
exp_eps(, epsilon)
as defined by the 3.3.1: exp_eps.hpp
include file.
exp_eps(, epsilon)
.Forward(0, u)
to run zero order forward mode at a point different
form the point where the operation sequence corresponding to
f was recorded.
# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
# include "exp_eps.hpp" // our example exponential function approximation
bool exp_eps_cppad(void)
{ bool ok = true;
using CppAD::AD;
using CppAD::vector; // can use any simple vector template class
using CppAD::NearEqual; // checks if values are nearly equal
// domain space vector
size_t n = 2; // dimension of the domain space
vector< AD<double> > U(n);
U[0] = .5; // value of x for this operation sequence
U[1] = .2; // value of e for this operation sequence
// declare independent variables and start recording operation sequence
CppAD::Independent(U);
// evaluate our exponential approximation
AD<double> x = U[0];
AD<double> epsilon = U[1];
AD<double> apx = exp_eps(x, epsilon);
// range space vector
size_t m = 1; // dimension of the range space
vector< AD<double> > Y(m);
Y[0] = apx; // variable that represents only range space component
// Create f: U -> Y corresponding to this operation sequence
// and stop recording. This also executes a zero order forward
// mode sweep using values in U for x and e.
CppAD::ADFun<double> f(U, Y);
// first order forward mode sweep that computes partial w.r.t x
vector<double> du(n); // differential in domain space
vector<double> dy(m); // differential in range space
du[0] = 1.; // x direction in domain space
du[1] = 0.;
dy = f.Forward(1, du); // partial w.r.t. x
double check = 1.5;
ok &= NearEqual(dy[0], check, 1e-10, 1e-10);
// first order reverse mode sweep that computes the derivative
vector<double> w(m); // weights for components of the range
vector<double> dw(n); // derivative of the weighted function
w[0] = 1.; // there is only one weight
dw = f.Reverse(1, w); // derivative of w[0] * exp_eps(x, epsilon)
check = 1.5; // partial w.r.t. x
ok &= NearEqual(dw[0], check, 1e-10, 1e-10);
check = 0.; // partial w.r.t. epsilon
ok &= NearEqual(dw[1], check, 1e-10, 1e-10);
// second order forward sweep that computes
// second partial of exp_eps(x, epsilon) w.r.t. x
vector<double> x2(n); // second order Taylor coefficients
vector<double> y2(m);
x2[0] = 0.; // evaluate partial w.r.t x
x2[1] = 0.;
y2 = f.Forward(2, x2);
check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
ok &= NearEqual(y2[0], check, 1e-10, 1e-10);
// second order reverse sweep that computes
// derivative of partial of exp_eps(x, epsilon) w.r.t. x
dw.resize(2 * n); // space for first and second derivative
dw = f.Reverse(2, w);
check = 1.; // result should be second derivative
ok &= NearEqual(dw[0*2+1], check, 1e-10, 1e-10);
return ok;
}
cd introduction/exp_apx
make test
// system include files used for I/O
# include <iostream>
// external complied tests
extern bool exp_2(void);
extern bool exp_2_cppad(void);
extern bool exp_2_for1(void);
extern bool exp_2_for2(void);
extern bool exp_2_rev1(void);
extern bool exp_2_rev2(void);
extern bool exp_2_for0(void);
extern bool exp_eps(void);
extern bool exp_eps_cppad(void);
extern bool exp_eps_for1(void);
extern bool exp_eps_for2(void);
extern bool exp_eps_for0(void);
extern bool exp_eps_rev1(void);
extern bool exp_eps_rev2(void);
namespace {
static size_t Run_ok_count = 0;
static size_t Run_error_count = 0;
bool Run(bool TestOk(void), std::string name)
{ bool ok = true;
std::streamsize width = 20;
std::cout.width( width );
std::cout.setf( std::ios_base::left );
std::cout << name.c_str();
//
ok &= name.size() < size_t(width);
ok &= TestOk();
if( ok )
{ std::cout << "OK" << std::endl;
Run_ok_count++;
}
else
{ std::cout << "Error" << std::endl;
Run_error_count++;
}
return ok;
}
}
// main program that runs all the tests
int main(void)
{ bool ok = true;
using namespace std;
// This comment is used by OneTest
// external compiled tests
ok &= Run( exp_2, "exp_2" );
ok &= Run( exp_2_cppad, "exp_2_cppad" );
ok &= Run( exp_2_for0, "exp_2_for0" );
ok &= Run( exp_2_for1, "exp_2_for1" );
ok &= Run( exp_2_for2, "exp_2_for2" );
ok &= Run( exp_2_rev1, "exp_2_rev1" );
ok &= Run( exp_2_rev2, "exp_2_rev2" );
ok &= Run( exp_eps, "exp_eps" );
ok &= Run( exp_eps_cppad, "exp_eps_cppad" );
ok &= Run( exp_eps_for0, "exp_eps_for0" );
ok &= Run( exp_eps_for1, "exp_eps_for1" );
ok &= Run( exp_eps_for2, "exp_eps_for2" );
ok &= Run( exp_eps_rev1, "exp_eps_rev1" );
ok &= Run( exp_eps_rev2, "exp_eps_rev2" );
if( ok )
cout << "All " << int(Run_ok_count) << " tests passed." << endl;
else cout << int(Run_error_count) << " tests failed." << endl;
return static_cast<int>( ! ok );
}
float,
double,
std::complex<float>,
std::complex<double>.
Otherwise, see 4.7: base_require
.
| Default: 4.1 | AD Default Constructor |
| ad_copy: 4.2 | AD Copy Constructor and Assignment Operator |
| Convert: 4.3 | Conversion and Printing of AD Objects |
| ADValued: 4.4 | AD Valued Operations and Functions |
| BoolValued: 4.5 | Bool Valued Operations and Functions with AD Arguments |
| VecAD: 4.6 | AD Vectors that Record Index Operations |
| base_require: 4.7 | AD<Base> Requirements for Base Type |
AD<Base> x;
# include <cppad/cppad.hpp>
bool Default(void)
{ bool ok = true;
using CppAD::AD;
// default AD constructor
AD<double> x, y;
// check that they are parameters
ok &= Parameter(x);
ok &= Parameter(y);
// assign them values
x = 3.;
y = 4.;
// just check a simple operation
ok &= (x + y == 7.);
return ok;
}
AD<Base> y(x)
AD<Base> y = x
= x
AD<Base> object y
and the assignment operator uses an existing y.
In either case,
y has the same value as x,
and the same dependence on the
11.4.j.c: independent variables
(y is a
11.4.l: variable
if and only if x is a variable).
const &x
VecAD<Base>::reference,
AD<Base>,
Base, or
double.
AD<> &y
| 4.2.1: CopyAD.cpp | AD Copy Constructor: Example and Test |
| 4.2.2: CopyBase.cpp | AD Constructor From Base Type: Example and Test |
| 4.2.3: Eq.cpp | AD Assignment Operator: Example and Test |
# include <cppad/cppad.hpp>
bool CopyAD(void)
{ bool ok = true; // initialize test result flag
using CppAD::AD; // so can use AD in place of CppAD::AD
// domain space vector
size_t n = 1;
CPPAD_TEST_VECTOR< AD<double> > x(n);
x[0] = 2.;
// declare independent variables and start tape recording
CppAD::Independent(x);
// create an AD<double> that does not depend on x
AD<double> b = 3.;
// use copy constructor
AD<double> u(x[0]);
AD<double> v = b;
// check which are parameters
ok &= Variable(u);
ok &= Parameter(v);
// range space vector
size_t m = 2;
CPPAD_TEST_VECTOR< AD<double> > y(m);
y[0] = u;
y[1] = v;
// create f: x -> y and vectors used for derivative calculations
CppAD::ADFun<double> f(x, y);
CPPAD_TEST_VECTOR<double> dx(n);
CPPAD_TEST_VECTOR<double> dy(m);
// check parameters flags
ok &= ! f.Parameter(0);
ok &= f.Parameter(1);
// check function values
ok &= ( y[0] == 2. );
ok &= ( y[1] == 3. );
// forward computation of partials w.r.t. x[0]
dx[0] = 1.;
dy = f.Forward(1, dx);
ok &= ( dy[0] == 1. ); // du / dx
ok &= ( dy[1] == 0. ); // dv / dx
return ok;
}
# include <cppad/cppad.hpp>
bool CopyBase(void)
{ bool ok = true; // initialize test result flag
using CppAD::AD; // so can use AD in place of CppAD::AD
// construct directly from Base where Base is double
AD<double> x(1.);
// construct from a type that converts to Base where Base is double
AD<double> y = 2;
// construct from a type that converts to Base where Base = AD<double>
AD< AD<double> > z(3);
// check that resulting objects are parameters
ok &= Parameter(x);
ok &= Parameter(y);
ok &= Parameter(z);
// check values of objects (compare AD<double> with double)
ok &= ( x == 1.);
ok &= ( y == 2.);
ok &= ( Value(z) == 3.);
// user constructor through the static_cast template function
x = static_cast < AD<double> >( 4 );
z = static_cast < AD< AD<double> > >( 5 );
ok &= ( x == 4. );
ok &= ( Value(z) == 5. );
return ok;
}
# include <cppad/cppad.hpp>
bool Eq(void)
{ bool ok = true;
using CppAD::AD;
// domain space vector
size_t n = 3;
CPPAD_TEST_VECTOR< AD<double> > x(n);
x[0] = 2; // AD<double> = int
x[1] = 3.; // AD<double> = double
x[2] = x[1]; // AD<double> = AD<double>
// declare independent variables and start tape recording
CppAD::Independent(x);
// range space vector
size_t m = 3;
CPPAD_TEST_VECTOR< AD<double> > y(m);
// assign an AD<Base> object equal to an independent variable
// (choose the first independent variable to check a special case)
// use the value returned by the assignment (for another assignment)
y[0] = y[1] = x[0];
// assign an AD<Base> object equal to an expression
y[1] = x[1] + 1.;
y[2] = x[2] + 2.;
// check that all the resulting components of y depend on x
ok &= Variable(y[0]); // y[0] = x[0]
ok &= Variable(y[1]); // y[1] = x[1] + 1
ok &= Variable(y[2]); // y[2] = x[2] + 2
// construct f : x -> y and stop the tape recording
CppAD::ADFun<double> f(x, y);
// check variable values
ok &= ( y[0] == 2.);
ok &= ( y[1] == 4.);
ok &= ( y[2] == 5.);
// compute partials w.r.t x[1]
CPPAD_TEST_VECTOR<double> dx(n);
CPPAD_TEST_VECTOR<double> dy(m);
dx[0] = 0.;
dx[1] = 1.;
dx[2] = 0.;
dy = f.Forward(1, dx);
ok &= (dy[0] == 0.); // dy[0] / dx[1]
ok &= (dy[1] == 1.); // dy[1] / dx[1]
ok &= (dy[2] == 0.); // dy[2] / dx[1]
// compute the derivative y[2]
CPPAD_TEST_VECTOR<double> w(m);
CPPAD_TEST_VECTOR<double> dw(n);
w[0] = 0.;
w[1] = 0.;
w[2] = 1.;
dw = f.Reverse(1, w);
ok &= (dw[0] == 0.); // dy[2] / dx[0]
ok &= (dw[1] == 0.); // dy[2] / dx[1]
ok &= (dw[2] == 1.); // dy[2] / dx[2]
// assign a VecAD<Base>::reference
CppAD::VecAD<double> v(1);
AD<double> zero(0);
v[zero] = 5.;
ok &= (v[0] == 5.);
return ok;
}
| 4.3.1: Value | Convert From an AD Type to its Base Type |
| 4.3.2: Integer | Convert From AD to Integer |
| 4.3.3: Output | AD Output Stream Operator |
| 4.3.4: PrintFor | Printing AD Values During Forward Mode |
| 4.3.5: Var2Par | Convert an AD Variable to a Parameter |
= Value(x)
const AD<> &x
b
Value result (see above).
For this reason,
the argument x must be a 11.4.h: parameter
; i.e.,
it cannot depend on the current
11.4.j.c: independent variables
.
# include <cppad/cppad.hpp>
bool Value(void)
{ bool ok = true;
using CppAD::AD;
using CppAD::Value;
// domain space vector
size_t n = 2;
CPPAD_TEST_VECTOR< AD<double> > x(n);
x[0] = 3.;
x[1] = 4.;
// check value before recording
ok &= (Value(x[0]) == 3.);
ok &= (Value(x[1]) == 4.);
// declare independent variables and start tape recording
CppAD::Independent(x);
// range space vector
size_t m = 1;
CPPAD_TEST_VECTOR< AD<double> > y(m);
y[0] = - x[1];
// cannot call Value(x[j]) or Value(y[0]) here (currently variables)
AD<double> p = 5.; // p is a parameter (does not depend on x)
ok &= (Value(p) == 5.);
// create f: x -> y and stop tape recording
CppAD::ADFun<double> f(x, y);
// can call Value(x[j]) or Value(y[0]) here (currently parameters)
ok &= (Value(x[0]) == 3.);
ok &= (Value(x[1]) == 4.);
ok &= (Value(y[0]) == -4.);
return ok;
}
= Integer(x)
int
const float &x
const double &x