Prev

Next

Index-> contents reference index search external

Up-> CppAD Appendix WishList

CppAD-> Install Introduction AD ADFun multi_thread library cppad_ipopt_nlp Example preprocessor Appendix

Appendix-> Faq speed Theory glossary Bib Bugs WishList whats_new deprecated License

WishList

Headings-> Atan2 BenderQuad CondExp Ipopt Library Memory Multiple Arguments Numeric Limits Operation Sequence Optimization ---..Expression Hashing ---..Microsoft Compiler Software Guidelines ---..Boost Sparsity Patterns ---..Faster Set Operations Speed Testing Tracing VecAD Vector Element Type

The CppAD Wish List
Atan2
The atan2 function could be made faster by adding a special operator for it.

BenderQuad
See the problem with the current BenderQuad specifications.

CondExp
Extend the conditional expressions CondExp so that they are valid for complex types by comparing real parts. In addition, use this change to extend LuRatio so that it works with complex AD types.

Ipopt

1. Create a separate documentation page for using cppad_ipopt_nlp with the simple representation .
2. The vector of sets sparsity pattern could be compared for speed with of vector of bools (and used instead if it is faster).
3. Perhaps it would help to cache the solution of the sparse Jacobian and spare Hessian graph coloring algorithm. Then, when the sparsity pattern does not depend on the argument value, these colorings would not have to be recomputed.
4. In the case where retape(k) is true for some k , one can still use the structure of the representation to compute a sparsity structure. Currently cppad_ipopt_nlp uses a dense sparsity structure for this case
5. The new_x flag could be used to avoid zero order forward mode computations. Because the same ADFun object is used at different argument values, this would require forward mode at multiple argument values (see multiple arguments ).

Library
One could build a CppAD library for use with the type AD<double>. This would speed up compilation for the most common usage where the Base type is double.

Memory
The thread_alloc memory manager might be able to improve performance of the multi_newton timing using the idea of allocating memory using a minimal chunk size. See end of page 118 and beginning of 119 in the article {Hoard: a scalable memory allocator for multi-threaded applications, by E.D. Berger et. al.

Multiple Arguments
It has been suggested that computing and storing forward mode results for multiple argument values (and for multiple orders) is faster for Adolc. Perhaps CppAD should allow for forward mode at multiple argument values (perhaps multiple orders).

Numeric Limits
Use a multiple of std::numeric_limits<double>::epsilon() instead 1e-10 for a small number in correctness checks; e.g., see tan.cpp .

Operation Sequence
It is possible to detect if the AD of Base operation sequence does not depend on any of the independent variable values. This could be returned as an extra seq_property .

Optimization

Expression Hashing
During expression sequence optimization , hash codes are used to detect expressions that have already been computed. Perhaps this should be done during the original forward mode recording.

Microsoft Compiler
The Microsoft's Visual C++ Version 9.0 generates a warning of the form warning C4396:%...% for every template function that is declared as a both a friend and inline (it thinks it is only doing this for specializations of template functions). The CPPAD_INLINE preprocessor symbol is used to convert these inline directives to empty code (if a Microsoft Visual C++ is used). If it is shown to be faster and does not slow down CppAD with other compilers, non-friend functions should be used to map these operations to member functions so that both can be compiled inline.

Software Guidelines

Boost
The following is a list of some software guidelines taken from boost . These guidelines are not followed by the current CppAD source code, but perhaps they should be:

1. Names (except as noted below) should be all lowercase, with words separated by underscores. For example, acronyms should be treated as ordinary names (xml_parser instead of XML_parser).
2. Template parameter names should begin with an uppercase letter.
3. Use spaces rather than tabs.

Sparsity Patterns

Faster Set Operations

1. The sparse set add_element operation could be made faster by cashing the iterator where the std::set inserts the previous element. See the add_element routine in the file sparse_set.hpp.
2. The memory allocation by standard set during sparsity calculations should be changed over to use omp_alloc (requires making a standard allocator interface to omp_alloc).
3. The user_atomic operations should allow the user to chose vectors of bits, instead of standard sets, for representing sets. This would be more efficient for most cases.

Speed Testing
Extend the speed tests for Adolc, Fadbad, and Sacado to run under MS Windows. Run the CppAD speed tests on a set of different machines and operating systems.

Tracing
Add operation sequence tracing to the user API and documentation.

VecAD
Make assignment operation in VecAD like assignment in ad_copy . This will fix slicing to int when assigning from double to VecAD< AD<double> >::reference object.

Vector Element Type
Change cross references from elements of a specified type to value_type .

---

Input File: omh/wish_list.omh