Changes and Additions to CppAD During 2004
Keywords: changes additions to cppad during 2004 introduction 12-11 12-09 12-03 11-17 11-16 11-15 11-14 11-13 11-12 11-10 11-04 11-02 11-01 10-29 10-28 10-27 10-21 10-19 10-16 10-06 09-29 09-26 09-23 09-21 09-13 09-10 09-09 09-07 09-04 09-02 08-27 08-25 08-24 08-12 07-31 07-08 07-07 07-03 07-02 06-29 06-25 06-12 06-04 06-03 06-01 05-30 05-29 05-26 05-25 05-14 05-12 05-09 05-07 05-04 05-03 04-29 04-28 04-25 04-24 04-22 04-21 04-20 04-19 04-09 04-08 04-07 04-03 04-02 04-01 03-30 03-28 03-25 03-18 03-17 03-15 03-12 03-11 03-09 03-07 03-06 03-05 03-04 03-03 03-01 02-29 02-28 02-21 02-20 02-17 02-16 02-15 02-12 02-01 01-29 01-28 01-22

| Prev | Next |  |  |  |  |  | whats_new_04 |

Changes and Additions to CppAD During 2004
Introduction
This section contains a list of the changes plus future plans for CppAD during 2004 (in reverse order by date). The purpose of this section is to assist you in learning about changes between various versions.
12-11
The documentation for the CppAD error macros was improved. The package title in cppad was changed. The documentation for CppAD::vector was improved and the corresponding source code `cppad/vector.hpp` was included.
12-09
The LuSolve and `OdeRunge` source code was modified to make the more in line with the introduction to C++ AD book (`OdeRunge` has been replaced by Runge45 ). In addition, the examples `OdeRunge.cpp` and lu_solve.cpp were modified to make the simpler. (The more complex version of `OdeRunge.cpp` was moved to the `TestMore` directory.)
12-03
The Poly documentation and source code were modified to make them more in line with the introduction to C++ AD book.
11-17
Changing to Autoconf and Automake on 08-24 mistakenly forgot the `-Wall` compiler switch (all warnings). This has been added and the corresponding warnings have been fixed.
11-16
The 11-15 Debug version would not compile under Visual C++ version 7.0 because a declaration of `LessThanOrZero` was missing. This has been fixed.
11-15
The ForOne and RevOne easy to use drivers were added.
11-14
The notation in the ADFun sections was changed to make the Forward and Reverse routines easier to use.
11-13
The Taylor coefficient vector and matrix notation was folded into just Taylor coefficients .
11-12
If `NDEBUG` is not defined during compile time, all `AD<Base>` comparison operations are checked during zero order forward mode calculations. The CompareChange function returns the number of comparison operations that have changed.
11-10
The get_started.cpp example was changed to use the Jacobian driver. In addition, more index entries, that point to the easy to use drivers , were added.
11-04
The Microsoft Visual Studio project file `example/Example.dsp/` was missing some new examples that needed to be linked in the install windows procedure. This has been fixed.
11-02
The unix installation required the user to touch the files to get the dates in proper order. This is no longer necessary.
11-01
Some of the dependency directories and files, for example `PrintFor/.deps` and `PrintFor/.deps/PrintFor.Po` had an extra `?` at the end of their names. This seems to have been fixed by using a newer version of the autoconf and automake tools.
10-29
Add the example and test simple_vector.cpp to the SimpleVector documentation. `
` The specifications for preprocessor symbols state that all the CppAD preprocessor symbols begin with `CppAD` (so they do not conflict with other packages). Some preprocessor symbols in the file `cppad/config.h` did began with `WITH_`. This has been fixed.
10-28
The examples hes_lu_det.cpp , hes_minor_det.cpp , jac_lu_det.cpp , and jac_minor_det.cpp used the negative of a `size_t` value. The value has been changed to an `int`. `
` The CppAD::vector template class was converted into a library routine so it can be used separately from the rest of CppAD.
10-27
The PrintFor example was moved to its own directory because the conversion from VC 6.0 to VC 7.0 projects did not work when there were multiple executables in one project file. The install instructions were modified to reflect this change.
10-21
One declaration (for the Value function) was missing from the file `cppad/local/Declare.h`. This has been added and CppAD should now compile and run under both Microsoft VC 6.0 and 7.0.
10-19
The current version of CppAD has a problem compiling under Microsoft Visual C++ version 7.0 (it compiles and works under version 6.0). The problem appears to be due to a closer agreement between VC 7.0 and the C++ standard for declaring templates functions as friends. Some friend declarations were removed and others were made more specific in order to migrate the a version that will compile and run using VC 7.0.
10-16
The example compare.cpp displayed the text from bool_fun.cpp by mistake. This has been fixed. `
` The Compare operators have been extended to work with `int` operands.
10-06
The test `TapeDetLu` was added to `speed_cppad/DetLuSpeed.cpp` and `TapeDetMinor` was added to `speed_cppad/DetMinorSpeed.cpp`. These tests just tape the calculations without computing any derivatives. Using this, and the other tests, one can to separate the taping time from the derivative calculation time. `
` The windows installation steps do not build a `config.h` file. Hence a default `config.h` file was added to the distribution for use with Microsoft Visual Studio. `
` The `Distribute` section of the developer documentation was brought up to date. `
` Links to the ADOLC and FADBAD download pages were added to the unix installation instructions.
09-29
The include files for the utilities are now included by the root file `cppad/cppad.hpp`. They can still be included individually with out the rest of the CppAD package.
09-26
The routine `OdeRunge` was modified so that it will now integrate functions of a complex arguments. This was done by removing all uses of greater than and less than comparisons were removed. (`OdeRunge` has been replaced by Runge45 ). `
` The changes on 09-21 did not fix all the file date and time problems; i.e., automake was still running in response to the unix installation `make` command.
09-23
There was a reference to `B` that should have been `X` in the description of the X argument of `LuSolve`. This has been fixed.
09-21
The CondExp function has been modified so that it works properly for `AD< AD<Base> >` types; i.e., it now works for multiple levels of taping. `
` The date of the files `aclocal.m4` and `config.h.in` were later than the date of top level `Makefile.am`. This caused the `make` command during the unix installation to try to run `autoconf` and this did not work on systems with very old versions of `autoconf`. This has been fixed.
09-13
The examples that are specific to an operation were moved to be below that operation in the documentation tree. For example add.cpp is below ad_binary in the documentation tree.
09-10
The version released on 04-09-09 did not have the new file `PrintFor.h` in `cppad/local`. This has been fixed. `
` The `Base` type requirements were simplified. `
` The Unix installation instructions were modified so just one make command was executed at the top level. This was necessary because the order of the makes is now important (as previously suggested, the makes did not work properly).
09-09
The PrintFor function was added so that users can debug the computation of function values at arguments that are different from those used when taping.
09-07
In the Unix installation instructions place `./` in front of current directory program names; for example, `./GetStarted` instead of `GetStarted` (because some unix systems do not have the current directory in the default executable path).
09-04
A library containing the SpeedTest and NearEqual object files was added to the distribution. `
` All of the include files of the form `<cppad/library/name.h>` were moved to `<cppad/name.h>` .
09-02
Some more messages were added to the output of `configure` during the Unix installation . `
` The suggested compression program during Windows installation was changed from 7-zip to WinZip .
08-27
The error messages printed by the default version of the CppAD error macros had `YY-MM-DD` in place of the date for the current version. This has been fixed. `
` All the correctness tests are now compiled with the `-g` command line option (the speed tests are still compiled with `-O2 -DNDEBUG`). `
` The installation instructions for Unix and Windows were split into separate pages.
08-25
The installation now automates the replacement of CppAD::vector by either the `std::vector` or `boost::numeric::ublas::vector`.
08-24
This date marks the first release that uses the Gnu tools Autoconf and Automake. This automates the building of the make files for the installation and is the standard way to distribute open source software. This caused some organizational changes, for example, the GetStarted example now has its own directory and the distribution directory is named `
cppad-yy-mm-dd
` where `yy-mm-dd` is the year, month and date of the distribution. (Note the distribution directory is different from the directory where CppAD is finally installed.)
08-12
Move `OdeExplicit` into the `cppad/library/` directory. In addition, change it so that the vector type was a template argument; i.e., works for any type of vector (not just `CppADvector`).
07-31
Move LuSolve into the `cppad/library/` directory. In addition, change it so that the vector type was a template argument; i.e., works for any type of vector (not just `CppADvector`).
07-08
The file `cppad/example/NearEqual.h` has been moved to `cppad/example/NearEqualExt.h` because it contains extensions of the NearEqual routine to `AD` types.
07-07
The `double` and `std::complex<double>` cases for the NearEqual routine arguments has been moved to the general purpose utilities .
07-03
The CppAD error macros names `CppADExternalAssert` and `CppADInternalAssert` were changed to `CppADUsageError` and `CppADUnknownError`. The SpeedTest routine was changed to use `CppADUsageError` instead of a C assert.
07-02
The SpeedTest output was improved so that the columns of values line up. Previously, this was not the case when the number of digits in the size changed.
06-29
Added code to trap and report memory allocation errors during `new` operations.
06-25
A discussion of the order dependence of the assignment operator and the independent function was added to the Faq . In addition, a similar discussion was added to the documentation for the Independent function. `
` The definition of a parameter and variable were changed to reflect that fact that these are time dependent (current) properties of an `AD<Base>` object.
06-12
All of the arithmetic operators (except for the unary operators) can now accept `int` arguments. The documentation for these arguments has been changed to reflect this. In addition, the corresponding test cases have been changed to test this and to test high order derivative cases. The old versions of these tests were moved into the `cppad/Test` directory.
06-04
The atan2 function was added.
06-03
The `asin` and `acos` unary_standard_math functions were added. `
` There was a bug the reverse mode theory and calculation of derivatives of sqrt for fourth and higher orders. This has been fixed. In addition, the following examples have been changed so that they test derivative up to fifth order: asin , atan , cos , exp , log , sin , sqrt .
06-01
There was a bug in the atan function forward mode calculations for Taylor coefficient orders greater than two. This has been fixed.
05-30
The sin and cos examples were changed so that they tested higher order derivatives.
05-29
The forward mode recursion formulas for each of the standard math functions has been split into separate sections. `
` A roman (instead of italic) font was used for the name of for the name of each of the standard math functions in the assumption statements below the section for the standard math functions. For example, sin ( x ) instead of sin ( x ) .
05-26
In the documentation for Poly , the reference to `example/Poly.h` was corrected to `cppad/library/Poly.h`. `
` In the documentation for SpeedTest , the reference to `Lib/SpeedTest.h` was corrected to `cppad/library/SpeedTest.h`. In addition, the example case was corrected. `
` In Reverse , the definition for U ( t , u ) had t p -1 where it should have had t p -1 . This has been fixed.
05-25
The special case where the second argument to the pow function is an `int` has been added.
05-14
Change all of the include syntax `
# include "filename"
` to the syntax `
# include <filename>
` so that examples and other use better reflect how one would use CppAD after it was installed in a standard include directory; for example `/usr/local/include/cppad`. `
` The user documentation was moved from the directory `cppad/User` to the directory `cppad/Doc`. `
` The directory `cppad/Lib` was moved to `cppad/library` to reflect that fact that it is not what one expects in a standard `lib` directory or a standard `include` directory.
05-12
The string `YY-MM-DD` in the preprocessor symbol `CppADVersion` was not being replaced by the current date during distribution. This resulted in the `CppADExternalAssert` macro printing `YY-MM-DD` where is should have printed the date of distribution. This has been fixed. `
` All of the include commands of the form `
# include "include/name.h"
# include "lib/name.h"
` have been changed to the form `
# include "cppad/include/name.h"
# include "cppad/lib/name.h"
` This will avoid mistakenly loading a file from another package that is in the set of directories being searched by the compiler. It is therefore necessary to specify that the directory above the `CppAD` directory be searched by the compiler. For example, if `CppAD` is in `/usr/local/cppad`, you must specify that `/usr/local` be searched by the compiler. Note that if `/usr/local/cppad/` is no longer searched, you will have to change `

         # include "cppad.hpp"

` to `

         # include "cppad/cppad.hpp"

` . `
` The window `nmake` file `Speed/Speed.mak` was out of date. This has been fixed.
05-09
Move Poly and SpeedTest into the `cppad/Lib` directory and the `CppAD` namespace.
05-07
The divide operator tests were extended to include a second order derivative calculation using reverse mode. `
` The Poly routine was modified to be more efficient in the derivative case. In addition, it was changed to use an arbitrary vector for the coefficients (not just a `CppADvector`).
05-04
A reloading of the data base caused the files `include/atan.h` and `include/cos.h` to be mistakenly started with lower case letters. These have been moved to `include/Atan.h` and `include/Cos.h` respectively.
05-03
The Reverse mode calculations for conditional expressions were mistakenly left out. This has been fixed.
04-29
The unary functions, such as sin and cos , were not defined for elements of an VecAD vector. This has been fixed.
04-28
The operator << was added to the default test_vector template class. `
` A FADBAD correctness and speed comparison with CppAD was added.
04-25
Factor out common sub-expressions in order to make lu_vec_ad.cpp faster. `
` Convert description from C++ Automatic Differentiation to C++ Algorithmic Differentiation.
04-24
The VecAD element class is no longer a derived class of the AD class. This enabled a decrease in tape memory and an increase in the speed for VecAD operations. `
` The log10 function was added.
04-22
Add CondExp and use it to speed up lu_vec_ad.cpp .
04-21
Use abs to speed up lu_vec_ad.cpp .
04-20
The absolute value function was added. `
` The value `n` for `OdeExplicit` and `OdeImplicit` is deduced from the argument `x0` and is not passed as a separate argument. This documentation has been fixed to this effect.
04-19
The += operator did not function correctly when the left hand operand was a parameter and the right hand operand was a variable (found by Mike Dodds ). This has been fixed.
04-09
Adding special operators for using parameters to index `VecAD` objects increased the speed and reduced the memory requirements (by about 20%) for the VecAD case in the `speed_cppad/LuSolveSpeed.cpp/` test. `
` The VecAD objects are not being handled correctly by the Reverse function. The `VecAD` test was extended to demonstrate the problem and the problem was fixed (it is now part of `TestMore/VecAD`).
04-08
The example lu_vec_ad_ok.cpp uses VecAD to executes different pivoting operations during the solution of linear equations with out having to retape. `
` The speed test `speed_cppad/LuSolveSpeed.cpp/` has been added. It shows that the initial implementation of VecAD is slow (and uses a lot of memory.) In fact, it is faster to use LuSolve and retape for each set of equations than it is to use lu_vec_ad.cpp and not have to retape. This test will help us improve the speed of lu_vec_ad.cpp .
04-07
There were bugs in the assignment to VecAD elements during taping that have been fixed. In addition, an example of tapping the pivoting operations in an Lu factorization has been added.
04-03
Added `size_t` indexing to the VecAD class. `
` Fixed a bug connected to the VecAD class and erasing the tape.
04-02
Some memory savings is done with regard to equal parameter values being stored in the tape. There was a bug in this logic when parameter in an `AD< AD<Base> >` class had values that were variables in the `AD<Base>` class. This has been fixed.
04-01
The name of the class that tapes indexing operations was changed from `ADVec` to VecAD . This class was extended so that the value of elements in these vectors can be variables (need not be parameters ).
03-30
Do some simple searching of the parameter table during taping avoid multiple copies of parameters on tape (use less tape memory).
03-28
The version ADVec , a vector class that tapes indexing operations, is now available. It is currently restricted by the fact that all the values in the vector must be parameters .
03-25
The internal taping structure has been changed to have variable length instructions. This is to save memory on the tape. In addition, it may help in the implementation of the vector class that tracks indexing. (A now functioning version of this class is described in VecAD .)
03-18
A change was made to the way parameter values are stored on the tape. This resulted in a significant savings in the amount of memory required.
03-17
Change the return type for SpeedTest from `const char *` to `std::string`. The memory required for the largest test cases was added to the speed_cppad tests output.
03-15
The comparison between ADOLC and CppAD for the `DetLuADOLC.cpp/` example was returning an error (because it was checking for exact equality of calculated derivatives instead of nearly equal). This has been fixed.
03-12
The user defined unary functions were removed and the user defined discrete functions were added. These discrete functions add the capability of conditional expressions (alternate calculations) being included in an ADFun object.
03-11
The classes det_by_minor and det_by_lu were added and used these to simplify the examples that compute determinants.
03-09
The routines `Grad` and `Hess` have been removed. You should use Jacobian and Hessian instead.
03-07
The driver routines Hessian and RevTwo has been added. These to compute specialized subsets of the second order partials. `
` Documentation errors in ForTwo and Reverse were fixed. The example documentation was reorganized.
03-06
The driver ForTwo has been added. It uses forward mode to compute a subset of the second order partials. `
` Split all of the "example" and "test" index entries that come from `cppad/example/*.cpp` into sorted subheadings.
03-05
The `Grad` routine, which only computed first derivatives of scalar valued functions, has been replaced by the Jacobian routine which computes the derivative of vector valued functions.
03-04
The bug reported on 02-17 was present in all the operators. These have all been fixed and tests for all the operators have been added to the `cppad/Test` directory. `
` The f.Parameter() function was added so that one can count how many components of the range space depend on the value of the domain space components. This helps when deciding whether to use forward or reverse mode.
03-03
Special operators were added to distinguish the cases where one of the operands is a parameter . This reduced the amount of branching that is necessary when executing Forward and Reverse calculations. `
` The Independent and Parameter functions were moved below ADFun in the documentation.
03-01
The DetLuADOLC.cpp, DetLu case was added to the ADOLC comparison tests.
02-29
Under certain optimization flag values, and on certain systems, an error was reported by the ADOLC correctness comparison. It turned out that CppAD was not initializing a particular index when debugging was turned off. This has been fixed.
02-28
A set of routines for comparing CppAD with ADOLC has been added to the distribution. In addition, documentation for compiling and linking the Examples and Speed Tests has been added.
02-21
If you use the user defined unary atomic functions there is a restriction on the order of the derivatives that can be calculated. This restriction was documented in the user defined unary function Forward and Reverse . (These unary functions were removed on 03-12 .)
02-20
A user interface to arbitrary order reverse mode calculations was implemented. In addition, the ADFun member functions `Rev` and `RevTwo` were removed because it is easier to use the uniform syntax below:

Old Syntax | Uniform Syntax
`r1 = f.Rev(v)` | `r1 = f.Reverse(1, v)`
`q1 = f.RevTwo(v)` | `r2 = f.Reverse(2, v)`
| `q1[i] == r2[2 * i + 1]`

`
` The Theory section has been completely changed so that it corresponds to the arbitrary order calculations. (Some of this change was made when the arbitrary forward mode interface was added on 04-02-15 . `
` The directory `cppad/Test` has been added. It contains tests cases that are not intended as examples.
02-17
There was a bug in the way CppAD handled the parameters zero and one when they were variables on a lower level tape; i.e. x might be a parameter on an `AD< AD<Base> >` tape and a its value might be a variable on the `AD<Base>` tape. This bug in the multiply and divide routines has been fixed. `
` There was a bug that is some cases reported a divide by zero error when the numerator was zero. This has been fixed.
02-16
A bug in Forward prevented the calculation of derivatives with higher order than two. In addition, this checking for user errors in the use of `Forward` was also faulty. This has been fixed. `
` The Microsoft project file `example\Example.dsp` was out of date. This has been fixed. `
` The example that tapes derivative calculations has been changed to an application of Taylor's method for solving ordinary differential equations.
02-15
A user interface to arbitrary order forward mode calculations was implemented. In addition, the ADFun member functions `Arg`, `For` and `ForTwo` were removed because it is easier to use the uniform syntax below:

Old Syntax | Uniform Syntax
`v0 = f.Arg(u0)` | `v0 = f.Forward(0, u0)`
`v1 = f.For(u1)` | `v1 = f.Forward(1, u1)`
`v2 = f.For(u2)` | `v2 = f.Forward(1, u2)`

02-12
All of the derivative calculations are now done using arbitrary order Taylor arithmetic routines. The Theory section was changed to document this method of calculation.
02-01
The definition of a Taylor coefficient was changed to include the factorial factor. This change was also made to the output specifications for the `FunForTwo` routine.
01-29
There were some bugs in the `FunArg` function that were fixed.

1. If one of the dependent variables was a parameter `FunArg` did not set it's value properly. (All its derivatives are zero and this was handled properly.)
2. The user defined unary functions were not computed correctly.

The specifications for the usage and unknown CppAD error macros were modified so that they could be used with out side effects.
01-28
Some corrections and improvements were made to the documentation including: `CppADvector` was placed before its use, a reference to `Ode_ind` and `Ode_dep` was fixed in `OdeImplicit`.
01-22
The specifications for the routine `FunForTwo` was changed to use Taylor coefficients . This makes the interface to CppAD closer to the interface for ADOLC .

Input File: omh/whats_new/whats_new_04.omh