# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-23 Bradley M. Bell
# ----------------------------------------------------------------------------

{xrst_begin whats_new_09 app}
{xrst_spell
   apx
   autoconf
   automake
   commutative
   doxygen
   isnan
   mhelp
   of of
   prev
   pycppad
   svn
   tarball
   valgrind
}

Changes and Additions to CppAD During 2009
##########################################

mm-dd
*****

12-23
=====
The
``ADFun`` :ref:`fun_construct@Assignment Operator`
was changed so that it now copies forward mode
Taylor coefficients and sparsity pattern information.
(This assignment operator was added on :ref:`whats_new_09@mm-dd@10-24` .)
You can use :ref:`capacity_order-name` to delete the Taylor coefficients
before copying them.
Two new functions were added so that you can query and delete the
forward mode sparsity information;
see
:ref:`ForSparseJac@f@size_forward_bool` and
:ref:`ForSparseJac@f@size_forward_set` .

12-22
=====
Convert the optimization of a sequence of additions from multiple operators
to one operator with a varying number of arguments. This improved the speed
for forward and reverse mode computations of an optimized tape.

12-18
=====
It turns out that detection of a sequence of additions makes the optimization
longer. This was simplified and makes slightly faster by converting two
jointly recursive routines to one non-recursive routine that uses a
stack for the necessary information.
More work is planned to make this optimization faster.

12-12
=====
Detection of a sequence of additions that can be converted to one variable
during the :ref:`optimize-name` process.
This leads to a significant improvement in the tape size and speed.

12-04
=====
Change hash coding of parameter values as part of operators
during the :ref:`optimize-name` process.
This should leads to more detection and removal of duplicate operations.

12-02
=====
Fix minor grammatical error in the Purpose heading
for :ref:`conditional expressions<CondExp@Purpose>` .

Add the following functions:
:ref:`fun_property@size_op` ,
:ref:`fun_property@size_op_arg` ,
and
:ref:`fun_property@size_op_seq` .
In addition, improve and extend the
:ref:`fun_property.cpp-name` example.

11-28
=====
Fix bug in tape optimization with :ref:`VecAD-name` objects.

11-27
=====
Remove duplicate expressions for the commutative binary operators; i.e.,
addition and multiplication.

11-26
=====
Improve :ref:`optimize-name` command so that it removes some duplicate
expressions from the tape (more of this is planned).

10-30
=====
Make program that check Ipopt ODE example correctness
a separate file ``ipopt_nlp_ode_check.cpp``
Split out Ipopt driver for ODE example ``ipopt_nlp_ode_run.hpp`` .
Add the speed testing problem ``ipopt_cppad/ipopt_ode_speed.cpp`` .

10-29
=====
Split out the
ode inverse problem,
its simple representation,
and
its fast representation,
as a separate files; to be specific,
``ipopt_nlp_ode_problem.hpp`` ,
``ipopt_nlp_ode_simple.hpp`` ,
``ipopt_nlp_ode_fast.hpp`` ,
and
``ipopt_nlp_ode_check.cpp`` .

10-28
=====
Improve the documentation for ``ipopt_nlp_ode_simple`` and
``ipopt_nlp_ode_fast`` .

10-27
=====
Moved old ``ipopt_cppad_simple.cpp`` to ``ipopt_nlp_get_started.cpp`` ,
created the example ``ipopt_nlp_ode_simple.hpp`` ,
and split and ``ipopt_cppad_ode.cpp``
into ``ipopt_nlp_ode_fast.hpp`` and ``ipopt_nlp_ode_check.cpp`` .

10-24
=====
Added the :ref:`fun_construct@Assignment Operator`
to the ``ADFun`` object class.
This makes a copy of the entire operation sequence in another
function object.
The intention is that the two functions objects can do calculations in
parallel.
In addition,
CppAD now check for the ``ADFun``
:ref:`fun_construct@Copy Constructor`
and generates an error message if it is used.

10-23
=====
The :ref:`sparse_hessian-name` routine was extended so the user can now choose
between vectors of sets and boolean vectors for representing
:ref:`sparsity patterns<glossary@Sparsity Pattern>` .

10-21
=====
The :ref:`CheckSimpleVector-name` function was extended so that
it can check simple vectors where the elements of the vector
can not be assigned to integer values.
This was done by adding the :ref:`CheckSimpleVector@x, y`
arguments to ``CheckSimpleVector`` .

10-16
=====
The :ref:`sparse_jacobian-name` routine was extended so the user can now choose
between vectors of sets and boolean vectors for representing
:ref:`sparsity patterns<glossary@Sparsity Pattern>` .

10-14
=====
The *packed* parameter for the sparsity routines
:ref:`ForSparseJac-name` , :ref:`RevSparseJac-name` , and :ref:`RevSparseHes-name`
(introduced on :ref:`whats_new_09@mm-dd@09-26` ) has been removed.
It has been replaced by changing the argument and return values
to be more versatile.
To be specific, they can now represent sparsity
using vectors of ``std::set<size_t>``
instead of just as vectors of ``bool``
(see :ref:`sparsity patterns<glossary@Sparsity Pattern>` ).

10-03
=====
The Microsoft Visual Studio project files for
examples and testing
and for
more correctness testing
were not including some new tests in their builds.
This has been fixed.

09-30
=====
Added the :ref:`cppad_sparse_jacobian.cpp-name` speed test
and increased the sizes used by :ref:`link_sparse_hessian-name` .
Some mistakes were fixed in the documentation for speed tests
:ref:`link_sparse_hessian-name` and :ref:`sparse_hes_fun-name` .

09-29
=====
The documentation definition of the function :math:`H(x)` in
:ref:`RevSparseHes-name` was missing a factor of :math:`R`.
This has been fixed.

09-28
=====
Changed :ref:`RevSparseHes-name` so that it uses a sparse
representation when the corresponding call to
:ref:`ForSparseJac-name` used a sparse representation.
This should have been included with the change on 09-26
because Hessian sparsity patters after ``ForSparseJac``
with *packed* did not work.
Thus, this could be considered a bug fix.

09-26
=====
Added the ``packed`` parameter to
:ref:`ForSparseJac-name` and :ref:`RevSparseJac-name` .
If *packed* is false,
a sparse instead of packed representation is used
during the calculations of sparsity patterns.
The sparse representation
should be faster, and use less memory, for very large sparse Jacobians.
The functions ``ForSparseJac`` and ``RevSparseJac``
return packed representations.
The plan is to eventually provide new member functions that return
sparse representations.

09-20
=====
Fixed a bug in the :ref:`Hessian Sparsity<RevSparseHes-name>` calculations
that included use of :ref:`VecAD-name` objects.

09-19
=====
Some more memory allocation improvements (related to those
on 09-18) were made.

09-18
=====
A bug was found in all the :ref:`sparsity_pattern-name` calculations.
The result was that eight times the necessary memory was being used
during these calculations.  This has been fixed.

08-25
=====
Add :ref:`ad_fun.cpp-name`
an example of how to create your own interface to an :ref:`ADFun-name` object.

08-14
=====
Add :ref:`ad_in_c.cpp-name`
an example of how to link CppAD to other languages.

08_13
=====
Add an option to :ref:`optimize-name` an operation sequence.
These changes come from the directory ``branches/optimize``
in the CppAD subversion repository.
The dates below represent when the correspond change was made.

#. 08-13:
   An automatic check of the :ref:`forward_zero-name` results was added
   after each call to :ref:`f.optimize()<optimize-name>`
   (this :ref:`check<optimize@Checking Optimization>`
   is skipped when ``NDEBUG`` is defined).
   In addition, all of the ``speed/cppad/`` * . ``cpp`` tests
   now check and use the speed test
   :ref:`speed_main@Global Options@optimize` flag.

#. 08-11:
   Change the speed test :ref:`main program<speed_main-name>` so
   that it uses a list of options instead of a boolean flag for each option.
   This will make it possible to add options in the future with out
   having to change all the existing tests because the options are now
   global variables instead of arguments to the speed test routines; for example,
   see ``retape`` speed test option.

#. 08-10:
   The routine for :ref:`optimizing<optimize-name>` the operation sequence
   has been added has been further tested using ``test_more/optimize.cpp`` .
   Some bugs have been fix and the routine can
   now be trusted to work correctly.

   The function
   :ref:`fun_property@size_VecAD` function was added
   so that the user could see the ``VecAD`` vectors
   and elements corresponding to an operation sequence.

#. 08-09:
   A routine for :ref:`optimizing<optimize-name>` the operation sequence
   has been added.
   This is a preliminary version and needs more testing before it can
   be trusted to work correctly.

08-06
=====
Add hash table coding to reduce the number of copies of the same
parameter value necessary in a tape recording.
In addition, add the function
:ref:`fun_property@size_par` was added
so that the user could see the number of parameters
corresponding to an operation sequence.

08-02
=====
Fix bug in new version of how :ref:`ForSparseJac-name` handles
:ref:`VecAD-name` objects.

Fix bug in overnight build where HTML version and entire documentation
as one page versions of documentation were not being built.

Fix missing new line under
:ref:`SimpleVector@Element Access@Using Value`
heading for simple vector documentation.

08-01
=====
Fix bug in reverse mode Jacobian :ref:`sparsity<RevSparseJac-name>`
for :ref:`VecAD-name` objects.

07-31
=====
The :ref:`forward<ForSparseJac-name>` and :ref:`reverse<RevSparseJac-name>`
sparse Jacobian routines have been improved so the resulting sparsity
patterns are valid for all values of the independent variables
(even if you use :ref:`CondExp-name` or :ref:`VecAD-name` ).

07-26
=====
Convert developer documentation from
forward and reverse mode sweep routines from OMhelp to doxygen.

07-25
=====
Add developer documentation for :ref:`PrintFor-name` operations.

07-24
=====
Add developer documentation for :ref:`Discrete-name` operations.

07-23
=====
Add developer documentation for tape evaluation of :ref:`VecAD-name` store
operations. (a store operation changes the value of a VecAD element).

Improve the :ref:`vec_ad.cpp-name` user example.

07-06
=====
Fixed a bug in second or higher order reverse mode calculations
that used :ref:`VecAD-name` .
This bug was demonstrated by the test case ``SecondOrderReverse``
in the file ``test_more/vec_ad.cpp`` .

Add developer documentation for tape evaluation of the
VecAD load operations
(a load operation accesses an element of the vector but
does not change it.)

Fix ``isnan`` undefined in ``example/cond_exp.cpp`` error
introduced on 07-04 change.

07-04
=====
Add developer documentation for the
:ref:`CompareChange-name` operations during tape evaluation.
These changes come from the directory ``branches/sweep``
in the CppAD subversion repository.
The dates below represent when the correspond change was made.

#. 07-04:
   Fixed a bug in second or higher order reverse mode calculations
   that included :ref:`conditional expressions<CondExp-name>` .
   This bug was demonstrated by the test case ``SecondOrderReverse``
   in the file ``test_more/cond_exp.cpp`` .

   A simpler and useful example was provided for
   :ref:`conditional expressions<CondExp-name>` ;
   see :ref:`cond_exp.cpp-name` .

#. 07-03:
   Some minor improvements were made to the documentation for
   :ref:`CondExp-name` .
   To be specific, a newer OMhelp option was used to change the formatting
   of the syntax, some of the argument names were changed to be more descriptive.

#. 07-02:
   Add developer doxygen documentation of
   tape evaluation for power (exponentiation) operators.

#. 07-01:
   Fix an example indexing error in
   ``introduction/exp_apx/exp_eps_for2.cpp`` (found by valgrind).

   Add developer doxygen documentation of
   tape evaluation for multiplication and division operators.

#. 06-30:
   Add developer doxygen documentation of
   tape evaluation for addition and subtraction operators.

#. 06-29:
   Add developer doxygen documentation of
   tape evaluation for sin, sinh, cos, and cosh.

#. 06-28:
   Add developer doxygen documentation of
   tape evaluation for atan, asin, acos, sqrt, log.

06-25
=====
The tarball for most recent release (of the subversion trunk for CppAD)
was not being placed in the
`download <http://www.coin-or.org/download/source/CppAD/>`_
directory.
This has been fixed.

06-22
=====
Fix compiler warnings during the ``openmp/run.sh`` test.

Changed :ref:`speed_example.cpp-name` to omit the ``speed_test`` from
the correctness result.
In stead, a message is printed explaining that timing tests need
to be run without a lot of other demands on the system.

06-21
=====
The configure instructions for :ref:`configure@ipopt_dir`
had the wrong path for ``IpIpoptApplication.hpp`` .
This has been fixed.

06-20
=====
Upgrade to from autoconf 2.61 to 2.63,
and from automake 1.10.1 to 1.11.

Fix conflict between CppAD's use of config.h preprocessor symbols
and other packages use of the same symbol names.

06-06
=====

#. Using complex of an AD type (instead of AD of complex) was not working
   correctly in ``not_complex_ad.cpp`` because the
   :ref:`default constructor<ad_ctor-name>` for an AD object has an unspecified value.
   This has been fixed for the complex type by changing the default constructor
   to use value zero.
   (The ``not_complex_ad.cpp`` example has been removed;
   see :ref:`complex FAQ<Faq@Complex Types>` .)
#. Fixing the ``not_complex_ad.cpp`` problem above also fixed a warning
   generated by `valgrind <http://valgrind.org/>`_.
   Now ``valgrind`` runs the CppAD ``example/example`` program
   with out any warning or error messages.
   In addition, a minor initialization error was fixed in the
   ``test_more/jacobian.cpp`` routine so now
   ``valgrind`` also runs the CppAD ``test_more/test_more`` program
   with out any warnings or error messages.

05-20
=====
A change was make to the trunk on 05-19 (svn revision 1361) that broke the
:ref:`Unix install<configure-name>` procedure.
This was has been fixed (revision 1362).

03-24
=====
Added cross references in
the :ref:`examples<list_all_examples-name>` to occurrence of the following tokens:
:ref:`AD-name` ,
:ref:`ADFun<fun_construct-name>` ,
``CPPAD_TEST_VECTOR`` ,
:ref:`Forward-name` ,
:ref:`Independent-name` ,
:ref:`Jacobian-name`
:ref:`NearEqual-name` ,
:ref:`Reverse-name` .

02-20
=====
Demonstrate using AD to compute the derivative
of the solution of an ODE with respect to a parameter
(in the :ref:`runge_45.cpp-name` example).

02-15
=====
Change the distribution
compressed tar file
to only contain one copy of the documentation.
Link to the current Internet documentation for the other three copies.

02-01
=====
Move the ``Prev`` and ``Next`` buttons at the top of the documentation
to the beginning so that their position does not change between sections.
This makes it easier to repeatedly select this links.

01-31
=====
Modify ``cppad/local/op_code.hpp`` to avoid incorrect warning by
g++ version 4.3.2 when building ``pycppad`` (a python interface to CppAD).

01-18
=====
Sometimes an error occurs while taping AD operations.
The :ref:`abort_recording-name` function has been added
to make it easier to recover in such cases.

Previously, CppAD speed and comparison tests used Adolc-1.10.2.
The version used in the tests has been upgraded to
`Adolc-2.0.0. <https://projects.coin-or.org/ADOL-C>`_

A discussion has been added to the documentation for :ref:`Jacobian-name`
about its use of
:ref:`Jacobian@Forward or Reverse`
mode depending on which it estimates is more efficient.

A minor typo has been fixed in the description of
``W(t, u)`` in :ref:`reverse_any-name` .
To be specific,
:math:`o ( t^{p-1} ) * t^{1-p} \rightarrow 0`
has been replaced by
:math:`o ( t^{p-1} ) / t^{1-p} \rightarrow 0`.

01-06
=====
Made some minor improvements to the documentation in
:ref:`fun_construct-name` .

{xrst_end whats_new_09}
