$Id: whats_new_04.omh 1598 2009-12-03 02:59:52Z bradbell $
/* --------------------------------------------------------------------------
CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell

CppAD is distributed under multiple licenses. This distribution is under
the terms of the 
                    Common Public License Version 1.0.

A copy of this license is included in the COPYING file of this distribution.
Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
-------------------------------------------------------------------------- */

$begin whats_new_04$$
$spell
	cppad.hpp
	deps
	executables
	Runge
	Rhs
	aclocal
	config
	Makefile
	ublas
	Autoconf
	Automake
	cppad
	yy
	mm
	dd
	Faq
	acos
	asin
	sqrt
	exp
	usr
	nmake
	mak
	namespace
	CppADvector
	atan
	cos
	retape
	Vec
	const
	std
	Hess
	depricated
	Det
	Lu
	dsp
	Arg
	Cpp
	Microsoft
	Taylor
	dep
	ind
$$

$section Changes and Additions to CppAD During 2004$$

$head 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.


$head 12-11$$
The documentation for the CppAD error macros was improved.
The package title in $xref/cppad/$$ was changed.
The documentation for $xref/CppAD_vector//CppAD::vector/$$ 
was improved and the corresponding source code 
$code cppad/vector.hpp$$ was included.

$head 12-09$$
The $xref/LuSolve/$$ and $code OdeRunge$$ source code
was modified to make the more in line with the introduction
to C++ AD book
($code OdeRunge$$ has been replaced by $xref/Runge45/$$).
In addition, the examples $code OdeRunge.cpp$$ and
$xref/LuSolve.cpp/$$ were modified to make the simpler.
(The more complex version of $code OdeRunge.cpp$$
was moved to the $code TestMore$$ directory.)

$head 12-03$$
The $xref/Poly/$$ documentation and source code were modified to
make them more in line with the introduction to C++ AD book.

$head 11-17$$
Changing to Autoconf and Automake on
$xref/whats_new_04/08-24/08-24/$$ mistakenly forgot 
the $code -Wall$$ compiler switch (all warnings).
This has been added and the corresponding warnings
have been fixed.

$head 11-16$$
The 11-15 Debug version would not compile under Visual C++ version 7.0 
because a declaration of $code LessThanOrZero$$ was missing.
This has been fixed.

$head 11-15$$
The $xref/ForOne/$$ and $xref/RevOne/$$
easy to use  $xref/Drivers//drivers/$$ were added.

$head 11-14$$
The notation in the $xref/ADFun/$$ sections was changed
to make the $xref/Forward/$$ and $xref/Reverse/$$ routines
easier to use.


$head 11-13$$
The Taylor coefficient vector and matrix notation was folded into
just $xref/glossary/Taylor Coefficient/Taylor coefficients/$$.

$head 11-12$$
If $code NDEBUG$$ is not defined during compile time,
all $syntax%AD<%Base%>%$$ 
$xref/Compare//comparison/$$ operations are checked during
$xref/ForwardZero//zero order/$$ forward mode calculations.
The 
$xref/CompareChange/$$ function
returns the number of comparison operations that have changed.

$head 11-10$$
The $xref/get_started.cpp/$$ example was changed to use the 
$xref/Jacobian/$$ driver.
In addition, more $xref/_index//index/$$ entries,
that point to the $xref/Drivers//easy to use drivers/$$, 
were added.

$head 11-04$$
The Microsoft Visual Studio
project file $code example/Example.dsp/$$ was missing some
new examples that needed to be linked in
(see $xref/InstallWindows/$$).
This has been fixed.

$head 11-02$$
The $xref/InstallUnix//unix installation/$$ required the user
to touch the files to get the dates in proper order.
This is no longer necessary.

$head 11-01$$
Some of the dependency directories and files, for example 
$code PrintFor/.deps$$ and
$code PrintFor/.deps/PrintFor.Po$$ had an extra $code ?$$
at the end of their names.
This seems to have been fixed by using a newer version of the autoconf
and automake tools.

$head 10-29$$
Add the example and test $xref/SimpleVector.cpp/$$ 
to the $xref/SimpleVector/$$ documentation.
$pre

$$
The specifications for 
$cref/preprocessor symbols/configure/Preprocessor Symbols/$$
state that all the CppAD preprocessor symbols
begin with $code CppAD$$ 
(so they do not conflict with other packages).
Some preprocessor symbols in the file $code cppad/config.h$$ did
began with $code WITH_$$.
This has been fixed.

$head 10-28$$
The examples 
$xref/HesLuDet.cpp/$$,
$xref/HesMinorDet.cpp/$$,
$xref/JacLuDet.cpp/$$,
and
$xref/JacMinorDet.cpp/$$ used the negative of a $code size_t$$ value.
The value has been changed to an $code int$$.
$pre

$$
The $xref/CppAD_vector//CppAD::vector/$$ template class
was converted into a library routine so it can be used
separately from the rest of CppAD.

$head 10-27$$
The $xref/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 $xref/install/$$ instructions were modified to reflect this change.

$head 10-21$$
One declaration (for the $xref/Value/$$ function) was missing
from the file $code cppad/local/Declare.h$$.
This has been added and CppAD should now compile and run
under both Microsoft VC 6.0 and 7.0. 

$head 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.

$head 10-16$$
The example $xref/Compare.cpp/$$ displayed the text from
$xref/BoolFun.cpp/$$ by mistake.
This has been fixed.
$pre

$$
The $xref/Compare/$$ operators have been extended to work with
$code int$$ operands.

$head 10-06$$
The test 
$code TapeDetLu$$ was added to $code speed_cppad/DetLuSpeed.cpp$$
and 
$code TapeDetMinor$$ was added to $code 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.
$pre

$$
The 
$xref/InstallWindows//windows installation/$$ steps
do not build a $code config.h$$ file.
Hence a default $code config.h$$ file was added to the 
distribution for use with Microsoft Visual Studio.
$pre

$$
The $code Distribute$$ section of the
developer documentation was brought up to date.
$pre

$$
Links to the ADOLC and FADBAD download pages were added
to the $xref/InstallUnix//unix installation/$$ instructions.

$head 09-29$$
The include files for the $xref/library/$$ are now included
by the root file $code cppad/cppad.hpp$$. 
They can still be included individually with out the rest of
the CppAD package.

$head 09-26$$
The routine $code 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.
($code OdeRunge$$ has been replaced by $xref/Runge45/$$).
$pre

$$
The changes on $xref/whats_new_04/09-21/09-21/$$ did not fix all
the file date and time problems; i.e., automake was still running
in response to the $xref/InstallUnix//unix installation/$$ 
$code make$$ command.


$head 09-23$$
There was a reference to $italic B$$ that should have been $italic X$$
in the description of the 
$xref/LuSolve/X/X/$$ argument of $code LuSolve$$.
This has been fixed.

$head 09-21$$
The $xref/CondExp/$$ function has been modified so that it works properly
for $syntax%AD< AD<%Base%> >%$$ types; i.e.,
it now works for multiple levels of taping.
$pre

$$
The date of the files $code aclocal.m4$$ and $code config.h.in$$
were later than the date of top level $code Makefile.am$$.
This caused the $code make$$ command during the 
$xref/InstallUnix//unix installation/$$
to try to run $code autoconf$$
and this did not work on systems with very old versions of $code autoconf$$.
This has been fixed.


$head 09-13$$
The examples that are specific to an operation were moved
to be below that operation in the documentation tree.
For example
$xref/Add.cpp/$$ is below $cref/ad_binary/$$ 
in the documentation tree.

$head 09-10$$
The version released on 04-09-09 did not have the 
new file $code PrintFor.h$$ in $code cppad/local$$.
This has been fixed.
$pre

$$
The $italic Base$$ type requirements were simplified.
$pre

$$
The $xref/InstallUnix//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).

$head 09-09$$
The $xref/PrintFor/$$ function was added so that
users can debug the computation of function values
at arguments that are different from those used when taping.

$head 09-07$$
In the $xref/InstallUnix//Unix installation/$$ instructions
place $code ./$$ in front of current directory program names; for example,
$code ./GetStarted$$ instead of $code GetStarted$$
(because some unix systems do not have the current directory
in the default executable path).


$head 09-04$$
A library containing the 
$xref/SpeedTest/$$ and $xref/NearEqual/$$ object files
was added to the distribution.
$pre

$$
All of the include files of the form 
$syntax%<cppad/library/%name%.h>%$$ were moved to
$syntax%<cppad/%name%.h>%$$. 

$head 09-02$$
Some more messages were added to the output of $code configure$$
during the $xref/InstallUnix//Unix installation/$$.
$pre

$$
The suggested compression program during 
$xref/InstallWindows//Windows installation/$$
was changed from
$href%
	http://www.7-zip.org%
	7-zip
%$$
to
$href%
	http://www.winzip.com%
	WinZip
%$$.


$head 08-27$$
The error messages printed by the default version of 
the CppAD error macros had $code YY-MM-DD$$ in place of the 
date for the current version.
This has been fixed.
$pre

$$
All the correctness tests are now compiled with the $code -g$$
command line option
(the speed tests are still compiled with $code -O2 -DNDEBUG$$).
$pre

$$
The $xref/Install//installation instructions/$$ for 
Unix and Windows were split into separate pages.

$head 08-25$$
The $xref/Install//installation/$$ now automates the replacement
of $xref/CppAD_vector//CppAD::vector/$$ by 
either the $code std::vector$$
or $code boost::numeric::ublas::vector$$.

$head 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
$xref/Install//installation/$$ and is the standard
way to distribute open source software.
This caused some organizational changes,
for example, the $xref/get_started.cpp//GetStarted/$$ example now 
has its own directory and
the distribution directory is named
$syntax%
	cppad-%yy%-%mm%-%dd%
%$$
where $syntax%%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.)


$head 08-12$$
Move $code OdeExplicit$$ into the $code 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 $code CppADvector$$).

$head 07-31$$
Move $xref/LuSolve/$$ into the $code 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 $code CppADvector$$).


$head 07-08$$
The file $code cppad/example/NearEqual.h$$ has been moved
to $code cppad/example/NearEqualExt.h$$ because it contains
extensions of the $xref/NearEqual/$$ routine to $code AD$$ types. 

$head 07-07$$
The $code double$$ and $code std::complex<double>$$
cases for the $xref/NearEqual/$$ routine arguments
has been moved to the general purpose $xref/library/$$.

$head 07-03$$
The CppAD error macros names
$code CppADExternalAssert$$ and $code CppADInternalAssert$$
were changed to
$code CppADUsageError$$ and $code CppADUnknownError$$.
The $xref/SpeedTest/$$ routine was changed to use $code CppADUsageError$$
instead of a C assert.

$head 07-02$$
The $xref/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.

$head 06-29$$
Added code to trap and report memory allocation errors during 
$code new$$ operations.

$head 06-25$$
A discussion of the order dependence of the
$cref/assignment/ad_copy/Syntax/Assignment/$$ operator
and the 
$xref/Independent//independent function/$$
was added to the
$xref/Faq/Assignment and Independent/Faq/$$. 
In addition,
a similar discussion
was added to the documentation for the
$xref/Independent/$$ function.
$pre

$$
The definition of a 
$xref/glossary/Parameter/parameter/$$
and 
$xref/glossary/Variable/variable/$$
were changed to reflect that fact that 
these are time dependent (current) properties
of an $syntax%AD<%Base%>%$$ object.


$head 06-12$$
All of the 
$xref/Arithmetic//arithmetic operators/$$ 
(except for the unary operators)
can now accept $code 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
$code cppad/Test$$ directory.


$head 06-04$$
The $xref/atan2//atan2/$$ function was added.

$head 06-03$$
The $code asin$$ and $code acos$$ 
$xref/std_math_ad//AD standard math unary functions/$$ were added.
$pre

$$
There was a bug the reverse mode theory and calculation of 
derivatives of $xref/std_math_ad//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:
$xref/Asin.cpp//asin/$$,
$xref/Atan.cpp//atan/$$,
$xref/Cos.cpp//cos/$$,
$xref/Exp.cpp//exp/$$,
$xref/Log.cpp//log/$$,
$xref/Sin.cpp//sin/$$,
$xref/Sqrt.cpp//sqrt/$$.


$head 06-01$$
There was a bug in the $xref/std_math_ad//atan/$$ function 
$xref/Forward//forward mode/$$ calculations for Taylor coefficient
orders greater than two.
This has been fixed.

$head 05-30$$
The $xref/Sin.cpp//sin/$$ and $xref/Cos.cpp//cos/$$ examples were
changed so that they tested higher order derivatives.


$head 05-29$$
The forward mode recursion formulas for each of the 
$xref/
	ForwardTheory/
	Standard Math Functions/
	Recursion Formula for Specific Cases/
	standard math functions/
	1
/$$
has been split into separate sections.
$pre

$$
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, $latex \sin(x)$$ instead of $latex sin(x)$$.


$head 05-26$$
In the documentation for $xref/Poly/$$,
the reference to $code example/Poly.h$$ 
was corrected to $code cppad/library/Poly.h$$.
$pre

$$
In the documentation for $xref/SpeedTest/$$,
the reference to $code Lib/SpeedTest.h$$ 
was corrected to $code cppad/library/SpeedTest.h$$.
In addition, the example case was corrected.
$pre

$$
In $xref/Reverse/$$, the definition for $latex U(t, u)$$ had
$latex t^p-1$$ where it should have had $latex t^{p-1}$$.
This has been fixed.


$head 05-25$$
The special case where the second argument to the $xref/pow/$$ function is an
$code int$$ has been added.

$head 05-14$$
Change all of the include syntax
$syntax%
	# include "%filename%"
%$$
to the syntax
$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
$code /usr/local/include/cppad$$.
$pre

$$
The user documentation was moved from the directory 
$code cppad/User$$ to the directory $code cppad/Doc$$.
$pre

$$
The directory $code cppad/Lib$$ was moved to $code cppad/library$$
to reflect that fact that it is not what one expects in a standard 
$code lib$$ directory or a standard $code include$$ directory.


$head 05-12$$
The string $code YY-MM-DD$$ in the preprocessor symbol $code CppADVersion$$ 
was not being replaced by the current date during distribution.
This resulted in the $code CppADExternalAssert$$ macro printing 
$code YY-MM-DD$$ where is should have printed the date of distribution.  
This has been fixed.
$pre

$$
All of the include commands of the form
$syntax%
	# include "include/%name%.h"
	# include "lib/%name%.h"
%$$
have been changed to the form
$syntax%
	# 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 
$code CppAD$$ directory be searched by the compiler.
For example,
if $code CppAD$$ is in $code /usr/local/cppad$$,
you must specify that $code /usr/local$$ be searched by the compiler.
Note that if $code /usr/local/cppad/$$ is no longer searched,
you will have to change 
$codep
	# include "cppad.hpp"
$$
to 
$codep
	# include "cppad/cppad.hpp"
$$.
$pre

$$
The window $code nmake$$ file $code Speed/Speed.mak$$ was out of date.
This has been fixed.

$head 05-09$$
Move $xref/Poly/$$ and $xref/SpeedTest/$$ into the
$code cppad/Lib$$ directory and the $code CppAD$$ namespace.


$head 05-07$$
The $xref/Div.cpp//divide operator tests/$$ were extended to
include a second order derivative calculation using reverse mode.
$pre

$$
The $xref/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 $code CppADvector$$).


$head 05-04$$
A reloading of the data base
caused the files $code include/atan.h$$ and $code include/cos.h$$ to be
mistakenly started with lower case letters.
These have been moved to $code include/Atan.h$$ and $code include/Cos.h$$
respectively.

$head 05-03$$
The $xref/Reverse/$$ mode calculations for 
$xref/CondExp//conditional expressions/$$ were mistakenly left out.
This has been fixed.

$head 04-29$$
The unary functions, such as $xref/std_math_ad//sin/$$ and $xref/std_math_ad//cos/$$,
were not defined for elements of an $xref/VecAD/$$ vector.
This has been fixed.


$head 04-28$$
The operator $xref/CppAD_vector/Output/<</$$ was added to the
default $cref/test_vector/$$ template class.
$pre

$$
A FADBAD correctness and speed comparison with CppAD
was added.

$head 04-25$$
Factor out common sub-expressions in order to make
$xref/LuVecAD/$$ faster.
$pre

$$
Convert description
from C++ Automatic Differentiation to C++ Algorithmic Differentiation.

$head 04-24$$
The $xref/VecAD/$$ element class is no longer
a derived class of the $xref/AD/$$ class.
This enabled a decrease in tape memory
and an increase in the speed for $xref/VecAD/$$ operations.
$pre

$$
The $xref/std_math_ad//log10/$$ function was added.


$head 04-22$$
Add $xref/CondExp/$$ and use it to speed up $xref/LuVecAD/$$.

$head 04-21$$
Use $xref/abs//abs/$$ to speed up $xref/LuVecAD/$$.

$head 04-20$$
The $xref/abs//absolute value/$$ function was added.
$pre

$$
The value $italic n$$ for 
$code OdeExplicit$$ and $code OdeImplicit$$ 
is deduced from the argument $italic x0$$ and is not passed
as a separate argument.
This documentation has been fixed to this effect.



$head 04-19$$
The $cref/+=/compute_assign/$$ operator did not function correctly
when the left hand operand was a 
$xref/glossary/Parameter/parameter/$$
and the right hand operand was a variable
(found by $href%mailto:magister@u.washington.edu%Mike Dodds%$$).
This has been fixed.


$head 04-09$$
Adding special operators for using parameters to index $code VecAD$$ objects
increased the speed and reduced the memory requirements (by about 20%) for 
the $xref/VecAD/$$ case in the $code speed_cppad/LuSolveSpeed.cpp/$$ test.
$pre

$$
The $xref/VecAD/$$ objects are not being handled correctly by the 
$xref/Reverse/$$ function.
The $code VecAD$$ test was extended to demonstrate the problem
and the problem was fixed
(it is now part of $code TestMore/VecAD$$).

$head 04-08$$
The example $xref/LuVecADOk.cpp/$$ 
uses $xref/VecAD/$$ to executes different pivoting operations 
during the solution of linear equations with out having to retape.
$pre

$$
The speed test $code speed_cppad/LuSolveSpeed.cpp/$$ has been added.
It shows that the initial implementation of $xref/VecAD/$$ is slow
(and uses a lot of memory.) 
In fact, 
it is faster to use $xref/LuSolve/$$ and retape for each set of equations
than it is to use $xref/LuVecAD/$$ and not have to retape.
This test will help us improve the speed of $xref/LuVecAD/$$.


$head 04-07$$
There were bugs in the assignment to $xref/VecAD/$$ elements
during taping that have been fixed.
In addition, an example of tapping the pivoting operations in
an $xref/LuVecAD//Lu factorization/$$ has been added.

$head 04-03$$
Added $code size_t$$ indexing to the $xref/VecAD/$$ class.
$pre

$$
Fixed a bug connected to the $xref/VecAD/$$ class and erasing the tape.

$head 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 $syntax%AD< AD<%Base%> >%$$ class had values that were variables in the 
$syntax%AD<%Base%>%$$ class.
This has been fixed.

$head 04-01$$
The name of the class that tapes indexing operations 
was changed from $code ADVec$$ to $xref/VecAD/$$.
This class was extended so that
the value of elements in these vectors can be variables
(need not be $xref/glossary/Parameter/parameters/$$).

$head 03-30$$
Do some simple searching of the parameter table during taping
avoid multiple copies of parameters on tape (use less tape memory).


$head 03-28$$
The version $xref/VecAD//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 
$xref/Glossary/Parameter/parameters/$$.



$head 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
$xref/VecAD/$$.)


$head 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.


$head 03-17$$
Change the return type for $xref/SpeedTest/$$ from $code const char *$$
to $code std::string$$.
The memory required for the largest test cases was added to the
$xref/speed_cppad/$$ tests output.

$head 03-15$$
The comparison between ADOLC and CppAD for
the $code 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.

$head 03-12$$
The user defined unary functions were removed and 
the user defined $xref/Discrete//discrete functions/$$ were
added. 
These discrete functions add the capability of conditional expressions 
(alternate calculations)
being included in an $xref/ADFun/$$ object.

$head 03-11$$
The classes $xref/det_by_minor/$$ and $xref/det_by_lu/$$ were added
and used these to simplify the 
examples that compute determinants.

$head 03-09$$
The routines $code Grad$$ and $code Hess$$ have been removed.
You should use $xref/Jacobian/$$ and $xref/Hessian/$$ instead.


$head 03-07$$
The driver routines $xref/Hessian/$$ and $xref/RevTwo/$$ has been added.
These to compute specialized subsets of the second order partials.
$pre

$$
Documentation errors in $xref/ForTwo/$$ and $xref/Reverse/$$ were fixed.
The $xref/example/$$ documentation was reorganized.


$head 03-06$$
The driver $xref/ForTwo/$$ has been added.
It uses forward mode to compute a subset of the second order partials.
$pre

$$
Split all of the "example" and "test" index entries that come from
$syntax%cppad/example/%*%.cpp%$$
into sorted subheadings.

$head 03-05$$
The $code Grad$$ routine,
which only computed first derivatives of scalar valued functions,
has been replaced by the $xref/Jacobian/$$ routine which 
computes the derivative of vector valued functions.

$head 03-04$$
The bug reported on $xref/whats_new_04/02-17/02-17/$$ was present in all
the operators. These have all been fixed and tests for all the operators
have been added to the $code cppad/Test$$ directory.
$pre

$$
The $xref/seq_property/Parameter/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.

$head 03-03$$
Special operators were added to distinguish the cases where 
one of the operands is a
$xref/glossary/Parameter/parameter/$$.
This reduced the amount of branching that is necessary
when executing $xref/Forward/$$ and $xref/Reverse/$$ calculations.
$pre

$$
The $xref/Independent/$$ and $xref/seq_property/Parameter/Parameter/$$ functions
were moved below $xref/ADFun/$$ in the documentation.


$head 03-01$$
The DetLuADOLC.cpp, DetLu case was added to the ADOLC
comparison tests.

$head 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.


$head 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
$xref/example//Examples/$$ and $xref/speed_cppad//Speed Tests/$$
has been added.

$head 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
$xref/Forward/$$
and $xref/Reverse/$$.
(These unary functions were removed on $xref/whats_new_04/03-12/03-12/$$.)

$head 02-20$$
A user interface to arbitrary order 
$xref/Reverse//reverse mode/$$ calculations was implemented.
In addition, the $xref/ADFun/$$ member functions
$code Rev$$ and $code RevTwo$$ were removed
because it is easier to use the uniform syntax below:
$table
$bold Old Syntax$$ $cnext $bold Uniform Syntax$$ 
$rnext
$syntax%%r1% = %f%.Rev(%v%)%$$ $cnext $syntax%%r1% = %f%.Reverse(1, %v%)%$$
$rnext
$syntax%%q1% = %f%.RevTwo(%v%)%$$ $cnext $syntax%%r2% = %f%.Reverse(2, %v%)%$$
$rnext
	$cnext $syntax%%q1%[%i%] == %r2%[2 * %i% + 1]%$$
$tend
$pre

$$
The $xref/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 
$xref/whats_new_04/02-15/04-02-15/$$.
$pre

$$
The directory $code cppad/Test$$ has been added. 
It contains tests cases that are not intended as examples.

$head 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 $syntax%AD< AD<%Base%> >%$$ tape and a its value
might be a variable on the
$syntax%AD<%Base%>%$$ tape.
This bug in the multiply and divide routines has been fixed.
$pre

$$
There was a bug that is some cases reported a divide by zero error
when the numerator was zero. This has been fixed.


$head 02-16$$
A bug in $xref/Forward/$$ prevented the calculation of derivatives
with higher order than two.
In addition, this checking for user errors in the use of $code Forward$$
was also faulty. 
This has been fixed.
$pre

$$
The Microsoft project file $code example\Example.dsp$$
was out of date. This has been fixed.
$pre

$$
The example that $xref/mul_level//tapes derivative calculations/$$
has been changed to an application of 
$xref/ode_taylor.cpp//Taylor's method/$$ for solving ordinary differential
equations.

$head 02-15$$
A user interface to arbitrary order 
$xref/Forward// forward mode/$$ calculations was implemented.
In addition, the $xref/ADFun/$$ member functions
$code Arg$$, $code For$$ and $code ForTwo$$ were removed
because it is easier to use the uniform syntax below:
$table
$bold Old Syntax$$ $cnext $bold Uniform Syntax$$ 
$rnext
$syntax%%v0% = %f%.Arg(%u0%)%$$ $cnext $syntax%%v0% = %f%.Forward(0, %u0%)%$$
$rnext
$syntax%%v1% = %f%.For(%u1%)%$$ $cnext $syntax%%v1% = %f%.Forward(1, %u1%)%$$
$rnext
$syntax%%v2% = %f%.For(%u2%)%$$ $cnext $syntax%%v2% = %f%.Forward(1, %u2%)%$$
$tend


$head 02-12$$
All of the derivative calculations are now done using arbitrary
order Taylor arithmetic routines.
The $xref/Theory/$$ section was changed to document this method
of calculation.


$head 02-01$$
The definition of a 
$xref/glossary/Taylor Coefficient/Taylor coefficient/$$
was changed to include the factorial factor.
This change was also made to the output specifications for the 
$code FunForTwo$$ routine.

$head 01-29$$
There were some bugs in the $code FunArg$$ function
that were fixed.
$list number$$
If one of the dependent variables was a
$xref/glossary/Parameter/parameter/$$ 
$code FunArg$$ did not set it's value properly.
(All its derivatives are zero and this was handled properly.)
$lnext
The user defined unary functions were not
computed correctly.
$lend

The specifications for the usage and unknown CppAD error macros
were modified so that they could be used with out side effects.

$head 01-28$$
Some corrections and improvements were made to the documentation including:
$code CppADvector$$ was placed before its use,
a reference to $code Ode_ind$$ and $code Ode_dep$$ was fixed in 
$code OdeImplicit$$.

$head 01-22$$
The specifications for the routine $code FunForTwo$$ 
was changed to use 
$xref/glossary/Taylor Coefficient/Taylor coefficients/$$.
This makes the interface to CppAD closer to the interface for
$href%http://www.math.tu-dresden.de/~adol-c/%ADOLC%$$.




$end
