source: branches/cache/cppad/local/ad_fun.hpp @ 3335

Last change on this file since 3335 was 3335, checked in by bradbell, 6 years ago
  1. cache.sh should not revert sweep files that have changed.
  2. Fix calls that were erased by mistake fixed in 1.
  3. Use cache2var (better description than cache).
  4. Put cache2var in ADFun function object.
  • Property svn:keywords set to Id
File size: 16.8 KB
Line 
1/* $Id: ad_fun.hpp 3335 2014-09-15 22:32:35Z bradbell $ */
2# ifndef CPPAD_AD_FUN_INCLUDED
3# define CPPAD_AD_FUN_INCLUDED
4
5/* --------------------------------------------------------------------------
6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
7
8CppAD is distributed under multiple licenses. This distribution is under
9the terms of the
10                    Eclipse Public License Version 1.0.
11
12A copy of this license is included in the COPYING file of this distribution.
13Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
14-------------------------------------------------------------------------- */
15/*
16$begin ADFun$$
17$spell
18        xk
19        Ind
20        bool
21        taylor_
22        sizeof
23        const
24        std
25        ind_taddr_
26        dep_taddr_
27$$
28
29$spell
30$$
31
32$section ADFun Objects$$
33
34$index ADFun, object$$
35$index object, ADFun$$
36
37$head Purpose$$
38An AD of $icode Base$$
39$cref/operation sequence/glossary/Operation/Sequence/$$
40is stored in an $code ADFun$$ object by its $cref FunConstruct$$.
41The $code ADFun$$ object can then be used to calculate function values,
42derivative values, and other values related to the corresponding function.
43
44$childtable%
45        cppad/local/independent.hpp%
46        cppad/local/fun_construct.hpp%
47        cppad/local/dependent.hpp%
48        cppad/local/abort_recording.hpp%
49        omh/seq_property.omh%
50        cppad/local/fun_eval.hpp%
51        cppad/local/drivers.hpp%
52        cppad/local/fun_check.hpp%
53        cppad/local/optimize.hpp%
54        cppad/local/cache.hpp%
55        omh/check_for_nan.omh
56%$$
57
58$end
59*/
60
61namespace CppAD { // BEGIN_CPPAD_NAMESPACE
62/*!
63\file ad_fun.hpp
64File used to define the ADFun<Base> class.
65*/
66
67/*!
68Class used to hold function objects
69
70\tparam Base
71A function object has a recording of <tt>AD<Base></tt> operations.
72It does it calculations using \c Base operations.
73*/
74
75template <class Base>
76class ADFun {
77// ------------------------------------------------------------
78// Private member variables
79private:
80        /// Check for nan's and report message to user (default value is true).
81        bool check_for_nan_;
82
83        /// debug checking number of comparision operations that changed
84        size_t compare_change_;
85
86        /// number of orders stored in taylor_
87        size_t num_order_taylor_;
88
89        /// maximum number of orders that will fit in taylor_
90        size_t cap_order_taylor_;
91
92        /// number of directions stored in taylor_
93        size_t num_direction_taylor_;
94
95        /// number of variables in the recording (play_)
96        size_t num_var_tape_;
97
98        /// tape address for the independent variables
99        CppAD::vector<size_t> ind_taddr_;
100
101        /// tape address and parameter flag for the dependent variables
102        CppAD::vector<size_t> dep_taddr_;
103
104        /// which dependent variables are actually parameters
105        CppAD::vector<bool>   dep_parameter_;
106
107        /// results of the forward mode calculations
108        pod_vector<Base> taylor_;
109
110        /// which operations can be conditionally skipped
111        /// Set during forward pass of order zero
112        pod_vector<bool> cskip_op_;
113
114        /// Variable on the tape corresponding to each vecad load operation
115        /// (if zero, the operation corresponds to a parameter).
116        pod_vector<addr_t> load_op_;
117
118        /// the operation sequence corresponding to this object
119        player<Base> play_;
120
121        /// mapping from variable index to cache index
122        CppAD::vector<addr_t> var2cache_;
123
124        /// Packed results of the forward mode Jacobian sparsity calculations.
125        /// for_jac_sparse_pack_.n_set() != 0  implies other sparsity results
126        /// are empty
127        sparse_pack      for_jac_sparse_pack_;
128
129        /// Set results of the forward mode Jacobian sparsity calculations
130        /// for_jac_sparse_set_.n_set() != 0  implies for_sparse_pack_ is empty.
131        CPPAD_INTERNAL_SPARSE_SET  for_jac_sparse_set_;
132
133// ------------------------------------------------------------
134// Private member functions
135
136        /// change the operation sequence corresponding to this object
137        template <typename ADvector>
138        void Dependent(ADTape<Base> *tape, const ADvector &y);
139
140        // ------------------------------------------------------------
141        // vector of bool version of ForSparseJac
142        // (see doxygen in for_sparse_jac.hpp)
143        template <class VectorSet>
144        void ForSparseJacCase(
145                bool               set_type  ,
146                bool               transpose ,
147                size_t             q         ,
148                const VectorSet&   r         , 
149                VectorSet&         s
150        );
151        // vector of std::set<size_t> version of ForSparseJac
152        // (see doxygen in for_sparse_jac.hpp)
153        template <class VectorSet>
154        void ForSparseJacCase(
155                const std::set<size_t>&  set_type  ,
156                bool                     transpose ,
157                size_t                   q         ,
158                const VectorSet&         r         , 
159                VectorSet&               s
160        );
161        // ------------------------------------------------------------
162        // vector of bool version of RevSparseJac
163        // (see doxygen in rev_sparse_jac.hpp)
164        template <class VectorSet>
165        void RevSparseJacCase(
166                bool               set_type  ,
167                bool               transpose ,
168                bool               nz_compare,
169                size_t             p         ,
170                const VectorSet&   s         , 
171                VectorSet&         r
172        );
173        // vector of std::set<size_t> version of RevSparseJac
174        // (see doxygen in rev_sparse_jac.hpp)
175        template <class VectorSet>
176        void RevSparseJacCase(
177                const std::set<size_t>&  set_type  ,
178                bool                     transpose ,
179                bool                     nz_compare,
180                size_t                   p         ,
181                const VectorSet&         s         , 
182                VectorSet&               r
183        );
184        // ------------------------------------------------------------
185        // vector of bool version of RevSparseHes
186        // (see doxygen in rev_sparse_hes.hpp)
187        template <class VectorSet>
188        void RevSparseHesCase(
189                bool               set_type  ,
190                bool               transpose ,
191                size_t             q         ,
192                const VectorSet&   s         , 
193                VectorSet&         h
194        );
195        // vector of std::set<size_t> version of RevSparseHes
196        // (see doxygen in rev_sparse_hes.hpp)
197        template <class VectorSet>
198        void RevSparseHesCase(
199                const std::set<size_t>&  set_type  ,
200                bool                     transpose ,
201                size_t                   q         ,
202                const VectorSet&         s         , 
203                VectorSet&               h
204        );
205        // ------------------------------------------------------------
206        // Forward mode version of SparseJacobian
207        // (see doxygen in sparse_jacobian.hpp)
208        template <class VectorBase, class VectorSet, class VectorSize>
209        size_t SparseJacobianFor(
210                const VectorBase&           x               ,
211                      VectorSet&            p_transpose     ,
212                const VectorSize&           row             ,
213                const VectorSize&           col             ,
214                      VectorBase&           jac             ,
215                      sparse_jacobian_work& work
216        );
217        // Reverse mode version of SparseJacobian
218        // (see doxygen in sparse_jacobian.hpp)
219        template <class VectorBase, class VectorSet, class VectorSize>
220        size_t SparseJacobianRev(
221                const VectorBase&           x               ,
222                      VectorSet&            p               ,
223                const VectorSize&           row             ,
224                const VectorSize&           col             ,
225                      VectorBase&           jac             ,
226                      sparse_jacobian_work& work
227        );
228        // ------------------------------------------------------------
229        // combined sparse_set, sparse_list and sparse_pack version of
230        // SparseHessian (see doxygen in sparse_hessian.hpp)
231        template <class VectorBase, class VectorSet, class VectorSize>
232        size_t SparseHessianCompute(
233                const VectorBase&              x           ,
234                const VectorBase&              w           ,
235                      VectorSet&               sparsity    ,
236                const VectorSize&              row         ,
237                const VectorSize&              col         ,
238                      VectorBase&              hes         ,
239                      sparse_hessian_work&     work
240        );
241// ------------------------------------------------------------
242public:
243        /// copy constructor
244        ADFun(const ADFun& g) 
245        : num_var_tape_(0)
246        {       CppAD::ErrorHandler::Call(
247                true,
248                __LINE__,
249                __FILE__,
250                "ADFun(const ADFun& g)",
251                "Attempting to use the ADFun<Base> copy constructor.\n"
252                "Perhaps you are passing an ADFun<Base> object "
253                "by value instead of by reference."
254                );
255         }
256
257        /// default constructor
258        ADFun(void); 
259
260        // assignment operator
261        // (see doxygen in fun_construct.hpp)
262        void operator=(const ADFun& f);
263
264        /// sequence constructor
265        template <typename ADvector>
266        ADFun(const ADvector &x, const ADvector &y);
267
268        /// destructor
269        ~ADFun(void)
270        { }
271
272        /// set value of check_for_nan_
273        void check_for_nan(bool value)
274        {       check_for_nan_ = value; }
275        bool check_for_nan(void) const
276        {       return check_for_nan_; }
277
278        /// assign a new operation sequence
279        template <typename ADvector>
280        void Dependent(const ADvector &x, const ADvector &y);
281
282        /// forward mode user API, one order multiple directions.
283        template <typename VectorBase>
284        VectorBase Forward(size_t q, size_t r, const VectorBase& x);
285
286        /// forward mode user API, multiple directions one order.
287        template <typename VectorBase>
288        VectorBase Forward(size_t q, 
289                const VectorBase& x, std::ostream& s = std::cout
290        );
291
292        /// reverse mode sweep
293        template <typename VectorBase>
294        VectorBase Reverse(size_t p, const VectorBase &v);
295
296        // forward mode Jacobian sparsity
297        // (see doxygen documentation in for_sparse_jac.hpp)
298        template <typename VectorSet>
299        VectorSet ForSparseJac(
300                size_t q, const VectorSet &r, bool transpose = false
301        );
302        // reverse mode Jacobian sparsity
303        // (see doxygen documentation in rev_sparse_jac.hpp)
304        template <typename VectorSet>
305        VectorSet RevSparseJac(
306                size_t q, const VectorSet &s, bool transpose = false,
307                bool nz_compare = false
308        );
309        // reverse mode Hessian sparsity
310        // (see doxygen documentation in rev_sparse_hes.hpp)
311        template <typename VectorSet>
312        VectorSet RevSparseHes(
313                size_t q, const VectorSet &s, bool transpose = false
314        );
315
316        /// amount of memeory used for Jacobain sparsity pattern
317        size_t size_forward_bool(void) const
318        {       return for_jac_sparse_pack_.memory(); }
319
320        /// free memeory used for Jacobain sparsity pattern
321        void size_forward_bool(size_t zero) 
322        {       CPPAD_ASSERT_KNOWN(
323                        zero == 0,
324                        "size_forward_bool: argument not equal to zero"
325                );
326                for_jac_sparse_pack_.resize(0, 0); 
327        }
328
329        /// total number of elements used for Jacobian sparsity pattern
330        size_t size_forward_set(void) const
331        {       return for_jac_sparse_set_.number_elements(); }
332
333        /// free memeory used for Jacobain sparsity pattern
334        void size_forward_set(size_t zero)
335        {       CPPAD_ASSERT_KNOWN(
336                        zero == 0,
337                        "size_forward_bool: argument not equal to zero"
338                );
339                for_jac_sparse_set_.resize(0, 0); 
340        }
341
342        /// number of operators in the operation sequence
343        size_t size_op(void) const
344        {       return play_.num_op_rec(); }
345
346        /// number of operator arguments in the operation sequence
347        size_t size_op_arg(void) const
348        {       return play_.num_op_arg_rec(); }
349
350        /// amount of memory required for the operation sequence
351        size_t size_op_seq(void) const
352        {       return play_.Memory(); }
353
354        /// number of parameters in the operation sequence
355        size_t size_par(void) const
356        {       return play_.num_par_rec(); }
357
358        /// number taylor coefficient orders calculated
359        size_t size_order(void) const
360        {       return num_order_taylor_; } 
361
362        /// number taylor coefficient directions calculated
363        size_t size_direction(void) const
364        {       return num_direction_taylor_; } 
365
366        /// number of characters in the operation sequence
367        size_t size_text(void) const
368        {       return play_.num_text_rec(); }
369
370        /// number of variables in opertion sequence
371        size_t size_var(void) const
372        {       return num_var_tape_; }
373
374        /// number of VecAD indices in the operation sequence
375        size_t size_VecAD(void) const
376        {       return play_.num_vec_ind_rec(); }
377
378        /// set number of orders currently allocated (user API)
379        void capacity_order(size_t c);
380
381        /// set number of orders and directions currently allocated
382        void capacity_order(size_t c, size_t r);   
383
384        /// number of variables in conditional expressions that can be skipped
385        size_t number_skip(void);   
386
387        /// number of independent variables
388        size_t Domain(void) const
389        {       return ind_taddr_.size(); }
390
391        /// number of dependent variables
392        size_t Range(void) const
393        {       return dep_taddr_.size(); }
394
395        /// is variable a parameter
396        bool Parameter(size_t i)
397        {       CPPAD_ASSERT_KNOWN(
398                        i < dep_taddr_.size(),
399                        "Argument to Parameter is >= dimension of range space"
400                );
401                return dep_parameter_[i]; 
402        }
403
404# ifndef NDEBUG
405        /// in not NDEBUG case, number of comparison operations that change
406        size_t CompareChange(void) const
407        {       return compare_change_; }
408# endif
409
410        /// calculate entire Jacobian
411        template <typename VectorBase>
412        VectorBase Jacobian(const VectorBase &x); 
413
414        /// calculate Hessian for one component of f
415        template <typename VectorBase>
416        VectorBase Hessian(const VectorBase &x, const VectorBase &w); 
417        template <typename VectorBase>
418        VectorBase Hessian(const VectorBase &x, size_t i); 
419
420        /// forward mode calculation of partial w.r.t one domain component
421        template <typename VectorBase>
422        VectorBase ForOne(
423                const VectorBase   &x ,
424                size_t              j );
425
426        /// reverse mode calculation of derivative of one range component
427        template <typename VectorBase>
428        VectorBase RevOne(
429                const VectorBase   &x ,
430                size_t              i );
431
432        /// forward mode calculation of a subset of second order partials
433        template <typename VectorBase, typename VectorSize_t>
434        VectorBase ForTwo(
435                const VectorBase   &x ,
436                const VectorSize_t &J ,
437                const VectorSize_t &K );
438
439        /// reverse mode calculation of a subset of second order partials
440        template <typename VectorBase, typename VectorSize_t>
441        VectorBase RevTwo(
442                const VectorBase   &x ,
443                const VectorSize_t &I ,
444                const VectorSize_t &J );
445
446        /// calculate sparse Jacobians
447        template <typename VectorBase>
448        VectorBase SparseJacobian(
449                const VectorBase &x
450        ); 
451        template <typename VectorBase, typename VectorSet>
452        VectorBase SparseJacobian(
453                const VectorBase &x , 
454                const VectorSet  &p
455        ); 
456        template <class VectorBase, class VectorSet, class VectorSize>
457        size_t SparseJacobianForward(
458                const VectorBase&     x     ,
459                const VectorSet&      p     ,
460                const VectorSize&     r     ,
461                const VectorSize&     c     ,
462                VectorBase&           jac   ,
463                sparse_jacobian_work& work
464        );
465        template <class VectorBase, class VectorSet, class VectorSize>
466        size_t SparseJacobianReverse(
467                const VectorBase&     x    ,
468                const VectorSet&      p    ,
469                const VectorSize&     r    ,
470                const VectorSize&     c    ,
471                VectorBase&           jac  ,
472                sparse_jacobian_work& work
473        );
474
475        /// calculate sparse Hessians
476        template <typename VectorBase>
477        VectorBase SparseHessian(
478                const VectorBase&    x  , 
479                const VectorBase&    w
480        ); 
481        template <typename VectorBase, typename VectorBool>
482        VectorBase SparseHessian(
483                const VectorBase&    x  ,
484                const VectorBase&    w  ,
485                const VectorBool&    p
486        ); 
487        template <class VectorBase, class VectorSet, class VectorSize>
488        size_t SparseHessian(
489                const VectorBase&    x   ,
490                const VectorBase&    w   ,
491                const VectorSet&     p   ,
492                const VectorSize&    r   ,
493                const VectorSize&    c   ,
494                VectorBase&          hes ,
495                sparse_hessian_work& work
496        ); 
497
498        // Optimize the tape
499        // (see doxygen documentation in optimize.hpp)
500        void optimize(void);
501
502        // Create a cache for tape values
503        void cache(void);
504        // ------------------- Deprecated -----------------------------
505
506        /// deprecated: assign a new operation sequence
507        template <typename ADvector>
508        void Dependent(const ADvector &y);
509
510        /// Deprecated: number of variables in opertion sequence
511        size_t Size(void) const
512        {       return num_var_tape_; }
513
514        /// Deprecated: # taylor_ coefficients currently stored
515        /// (per variable,direction)
516        size_t Order(void) const
517        {       return num_order_taylor_ - 1; }
518
519        /// Deprecated: amount of memory for this object
520        /// Note that an approximation is used for the std::set<size_t> memory
521        size_t Memory(void) const
522        {       size_t pervar  = cap_order_taylor_ * sizeof(Base)
523                + for_jac_sparse_pack_.memory()
524                + 3 * sizeof(size_t) * for_jac_sparse_set_.number_elements();
525                size_t total   = num_var_tape_  * pervar + play_.Memory();
526                return total;
527        }
528
529        /// Deprecated: # taylor_ coefficient orderss stored
530        /// (per variable,direction)
531        size_t taylor_size(void) const
532        {       return num_order_taylor_; } 
533
534        /// Deprecated: Does this AD operation sequence use
535        /// VecAD<Base>::reference operands
536        bool use_VecAD(void) const
537        {       return play_.num_vec_ind_rec() > 0; }
538
539        /// Deprecated: # taylor_ coefficient orders calculated
540        /// (per variable,direction)
541        size_t size_taylor(void) const
542        {       return num_order_taylor_; } 
543
544        /// Deprecated: set number of orders currently allocated
545        /// (per variable,direction)
546        void capacity_taylor(size_t per_var);   
547};
548// ---------------------------------------------------------------------------
549
550} // END_CPPAD_NAMESPACE
551
552// non-user interfaces
553# include <cppad/local/forward0sweep.hpp>
554# include <cppad/local/forward1sweep.hpp>
555# include <cppad/local/forward2sweep.hpp>
556# include <cppad/local/reverse_sweep.hpp>
557# include <cppad/local/for_jac_sweep.hpp>
558# include <cppad/local/rev_jac_sweep.hpp>
559# include <cppad/local/rev_hes_sweep.hpp>
560
561// user interfaces
562# include <cppad/local/parallel_ad.hpp>
563# include <cppad/local/independent.hpp>
564# include <cppad/local/dependent.hpp>
565# include <cppad/local/fun_construct.hpp>
566# include <cppad/local/abort_recording.hpp>
567# include <cppad/local/fun_eval.hpp>
568# include <cppad/local/drivers.hpp>
569# include <cppad/local/fun_check.hpp>
570# include <cppad/local/omp_max_thread.hpp>
571# include <cppad/local/optimize.hpp>
572# include <cppad/local/cache.hpp>
573
574# endif
Note: See TracBrowser for help on using the repository browser.