Changeset 3715


Ignore:
Timestamp:
Aug 30, 2015 8:20:43 AM (5 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 1d82806185c40ae85242338c2c1cdba2fd4f5985
end hash code: 668f6e23b6765e289257953ca0c9b64a75be3a6d

commit 668f6e23b6765e289257953ca0c9b64a75be3a6d
Author: Brad Bell <bradbell@…>
Date: Sun Aug 30 05:18:29 2015 -0700

Fix doxygen documentation of sparsity in atomic_base and checkpoint ctor.

commit 103015cd89c83e5a57d7c71128d47b92063ddd1b
Author: Brad Bell <bradbell@…>
Date: Sat Aug 29 20:45:55 2015 -0700

Add sparsity argument to checkpoint constructor.

commit 25bd23f48772614452881b9690422dd155b29523
Author: Brad Bell <bradbell@…>
Date: Sat Aug 29 20:04:45 2015 -0700

Remove invisible white space.

commit d231b61428fb2984e348354bbb30e7c8cb32d110
Author: Brad Bell <bradbell@…>
Date: Sat Aug 29 20:03:54 2015 -0700

Remove some now redundant index commands.


atomic_base.hpp: updo deprecation of atomic::option.
reciprocal.cpp: remove bool version of sparsity patterns.

commit d74750e010af2a2f4a1c0d45a56ad00d14f6530c
Author: Brad Bell <bradbell@…>
Date: Sat Aug 29 18:30:40 2015 -0700

Remove invisible white space.

commit 0122d57ee909a15698cb9316a85ec56a24ae797a
Author: Brad Bell <bradbell@…>
Date: Sat Aug 29 18:30:12 2015 -0700

Put type of atomic sparsity in constructor and deprecate use of atomic option.


norm_sq.cpp: example that make use of change by not specifying set version of sparsity.

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad/local/atomic_base.hpp

    r3714 r3715  
    8181$begin atomic_ctor$$
    8282$spell
     83        enum
    8384        sq
    8485        std
     
    9394
    9495$section Atomic Function Constructor$$
    95 $index constructor, atomic function$$
    96 $index atomic, function constructor$$
    97 $index function, atomic constructor$$
    9896
    9997$head Syntax$$
    10098$icode%atomic_user afun%(%ctor_arg_list%)
    10199%$$
    102 $codei%atomic_base<%Base%>(%name%)
     100$codei%atomic_base<%Base%>(%name%, %sparsity%)
    103101%$$
    104102
     
    122120        class %atomic_user% : public CppAD::atomic_base<%Base%> {
    123121        public:
    124                 %atomic_user%(%ctor_arg_list%) : atomic_base<%Base%>(%name%)
     122                %atomic_user%(%ctor_arg_list%) : atomic_base<%Base%>(%name%, %sparsity%)
    125123        %...%
    126124        };
     
    144142
    145143$subhead name$$
    146 This $icode atomic_base$$ constructor argument has either of the
    147 following prototypes
    148 $codei%
    149         const char*        %name%
     144This $code atomic_base$$ constructor argument has the following prototype
     145$codei%
    150146        const std::string& %name%
    151147%$$
     
    153149The suggested value for $icode name$$ is $icode afun$$ or $icode atomic_user$$,
    154150i.e., the name of the corresponding atomic object or class.
     151
     152$subhead sparsity$$
     153This $code atomic_base$$ constructor argument has prototype
     154$codei%
     155        atomic_base<%Base%>::option_enum %sparsity%
     156%$$
     157and its value is either
     158$code atomic_base<%Base%>::bool_sparsity_enum$$ or
     159$code atomic_base<%Base%>::set_sparsity_enum$$.
     160There is a unspecified default value for $icode sparsity$$ if it is not
     161included in the constructor.
     162If the sparsity for this object is always bool (set),
     163only the bool (set) versions of
     164$cref atomic_for_sparse_jac$$,
     165$cref atomic_rev_sparse_jac$$, and
     166$cref atomic_rev_sparse_hes$$ need to be implemented.
    155167
    156168$head Examples$$
     
    192204\param name
    193205name used for error reporting
    194 */
    195 atomic_base( const std::string&  name) :
     206
     207\param sparsity [in]
     208what type of sparsity patterns are computed by this function,
     209bool_sparsity_enum or set_sparsity_enum. Default value is unspecified.
     210*/
     211atomic_base(
     212                const std::string&     name,
     213                option_enum            sparsity = bool_sparsity_enum
     214) :
    196215index_( class_object().size() )     ,
    197 sparsity_( bool_sparsity_enum )
     216sparsity_( sparsity )
    198217{       CPPAD_ASSERT_KNOWN(
    199218                ! thread_alloc::in_parallel() ,
     
    234253
    235254$section Set Atomic Function Options$$
    236 $index atomic, options$$
    237 $index options, atomic$$
    238255
    239256$head Syntax$$
    240257$icode%afun%.option(%option_value%)%$$
     258These settings do not apply to individual $icode afun$$ calls,
     259but rather all subsequent uses of the corresponding atomic operation
     260in an $cref ADFun$$ object.
    241261
    242262$head atomic_sparsity$$
    243 $index atomic_sparsity$$
    244 $index sparsity, atomic$$
    245 You can used this option to set the type used for
    246 $icode afun$$ sparsity patterns.
    247 This does not apply individual calls to $icode afun$$,
    248 but rather all its uses between when the sparsity pattern is set and when
    249 it is changed.
    250 If neither the $code set_sparsity_enum$$ or
    251 $code bool_sparsity_enum$$ option is set,
    252 the type for $icode atomic_sparsity$$ is one of the two choices below
    253 (and otherwise unspecified).
    254263
    255264$subhead bool_sparsity_enum$$
    256 $index bool_sparsity_enum$$
    257265If $icode option_value$$ is $codei%atomic_base<%Base%>::bool_sparsity_enum%$$,
    258266then the type used by $icode afun$$ for
     
    267275
    268276$subhead set_sparsity_enum$$
    269 $index set_sparsity_enum$$
    270277If $icode option_value$$ is $icode%atomic_base<%Base%>::set_sparsity_enum%$$,
    271278then the type used by $icode afun$$ for
     
    483490                tape->Rec_.PutOp(UserOp);
    484491
    485                 // Now put n operators, one for each element of arugment vector
     492                // Now put n operators, one for each element of argument vector
    486493                CPPAD_ASSERT_UNKNOWN( NumRes(UsravOp) == 0 );
    487494                CPPAD_ASSERT_UNKNOWN( NumRes(UsrapOp) == 0 );
     
    495502                        }
    496503                        else
    497                         {       // information for an arugment that is parameter
     504                        {       // information for an argument that is parameter
    498505                                addr_t par = tape->Rec_.PutPar(ax[j].value_);
    499506                                tape->Rec_.PutArg(par);
  • trunk/cppad/local/checkpoint.hpp

    r3714 r3715  
    3535        atom_fun
    3636        const
     37        enum
     38        bool
    3739$$
    3840
     
    4244
    4345$head Syntax$$
    44 $codei%checkpoint<%Base%> %atom_fun%(%name%, %algo%, %ax%, %ay%)
     46$codei%checkpoint<%Base%> %atom_fun%(%name%, %algo%, %ax%, %ay%, %sparsity%)
    4547%sv% = %atom_fun%.size_var()
    4648%atom_fun%.option(%option_value%)
     
    120122$latex y = f(x)$$.
    121123
     124$head sparsity$$
     125This argument has prototype
     126$codei%
     127        atomic_base<%Base%>::option_enum %sparsity%
     128%$$
     129It specifies $cref/sparsity/atomic_ctor/atomic_base/sparsity/$$
     130in the $code atomic_base$$ constructor and must be either
     131$codei%atomic_base<%Base%>::bool_sparsity_enum%$$, or
     132$codei%atomic_base<%Base%>::set_sparsity_enum%$$.
     133This argument is optional and its default value is unspecified.
     134
     135
    122136$head size_var$$
    123137This $code size_var$$ member function return value has prototype
     
    183197// ---------------------------------------------------------------------------
    184198private:
     199        /// same as option_enum in base class
     200        typedef typename atomic_base<Base>::option_enum option_enum;
     201        //
     202        /// AD function corresponding to this checkpoint object
    185203        ADFun<Base> f_;
    186204        //
     
    193211        vectorBool                 hes_sparse_bool_;
    194212        // ------------------------------------------------------------------------
    195         typename atomic_base<Base>::option_enum sparsity(void)
     213        option_enum sparsity(void)
    196214        {       return static_cast< atomic_base<Base>* >(this)->sparsity(); }
    197215        // ------------------------------------------------------------------------
     
    340358        \param ay [out]
    341359        function value at specified argument value.
     360
     361        \param sparsity [in]
     362        what type of sparsity patterns are computed by this function,
     363        bool_sparsity_enum or set_sparsity_enum. Default value is unspecified.
    342364        */
    343365        template <class Algo, class ADVector>
    344         checkpoint(const char* name,
    345                 Algo& algo, const ADVector& ax, ADVector& ay)
    346         : atomic_base<Base>(name)
     366        checkpoint(
     367                const char*                    name     ,
     368                Algo&                          algo     ,
     369                const ADVector&                ax       ,
     370                ADVector&                      ay       ,
     371                option_enum                    sparsity =
     372                                atomic_base<Base>::bool_sparsity_enum
     373        ) : atomic_base<Base>(name, sparsity)
    347374        {       CheckSimpleVector< CppAD::AD<Base> , ADVector>();
    348375
  • trunk/cppad/local/epsilon.hpp

    r3607 r3715  
    66
    77CppAD is distributed under multiple licenses. This distribution is under
    8 the terms of the 
     8the terms of the
    99                    Eclipse Public License Version 1.0.
    1010
     
    2929
    3030$head Deprecated 2012-06-17$$
    31 $index deprecated, epsilon$$
    32 This routine has bee deprecated.
     31This routine has been deprecated.
    3332You should use the $cref/numeric_limits/limits/$$ $code epsilon$$ instead.
    3433
     
    5049%$$
    5150
    52 $end 
     51$end
    5352------------------------------------------------------------------------------
    5453*/
     
    5958        inline ADtype epsilon(void)
    6059        {       typedef typename ADtype::value_type value_type;
    61                 return ADtype ( epsilon<value_type>() ); 
     60                return ADtype ( epsilon<value_type>() );
    6261        }
    6362
  • trunk/example/atomic/checkpoint.cpp

    r3706 r3715  
    9191        for(j = 0; j < n; j++)
    9292                ax[j] = double(j);
    93         checkpoint<double> atom_f("atom_f", f_algo, ax, ay);
    94         checkpoint<double> atom_g("atom_g", g_algo, ay, az);
     93        CppAD::atomic_base<double>::option_enum sparsity =
     94                CppAD::atomic_base<double>::bool_sparsity_enum;
     95        checkpoint<double> atom_f("atom_f", f_algo, ax, ay, sparsity);
     96        checkpoint<double> atom_g("atom_g", g_algo, ay, az, sparsity);
    9597
    9698        // Record a version of z = g[f(x)] without checkpointing
  • trunk/example/atomic/get_started.cpp

    r3160 r3715  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1515
    1616$section Getting Started with Atomic Operations: Example and Test$$
    17 $index get_started, atomic operation$$
    18 $index atomic, get_started $$
    19 $index operation, atomic get_started$$
    2017
    2118$head Purpose$$
     
    3734        public:
    3835        // constructor (could use const char* for name)
    39         atomic_get_started(const std::string& name) :
     36        atomic_get_started(const std::string& name) :
     37        // this example does not use any sparsity patterns
    4038        CppAD::atomic_base<double>(name)
    4139        { }
     
    109107        CppAD::Independent(ax);
    110108
    111         // range space vector 
     109        // range space vector
    112110        size_t m = 1;
    113111        vector< AD<double> > ay(m);
    114112
    115         // call user function and store get_started(x) in au[0] 
     113        // call user function and store get_started(x) in au[0]
    116114        vector< AD<double> > au(m);
    117115        afun(ax, au);        // u = 1 / x
     
    126124$subhead forward$$
    127125$codep */
    128         // check function value 
     126        // check function value
    129127        double check = x0;
    130128        ok &= NearEqual( Value(ay[0]) , check,  eps, eps);
  • trunk/example/atomic/norm_sq.cpp

    r3160 r3715  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1818
    1919$section Euclidean Norm Squared: Example and Test$$
    20 $index norm_sq, atomic operation$$
    21 $index atomic, norm_sq$$
    22 $index Euclidean, norm example$$
    23 $index operation, norm_sq$$
    2420
    2521$head Theory$$
     
    4036using CppAD::vector;  // abbreviate as vector
    4137//
    42 // a utility to compute the union of two sets.
    43 void my_union(
    44         std::set<size_t>&         result  ,
    45         const std::set<size_t>&   left    ,
    46         const std::set<size_t>&   right   )
    47 {       std::set<size_t> temp;
    48         std::set_union(
    49                 left.begin()              ,
    50                 left.end()                ,
    51                 right.begin()             ,
    52                 right.end()               ,
    53                 std::inserter(temp, temp.begin())
    54         );
    55         result.swap(temp);
    56 }
    57 //
    5838class atomic_norm_sq : public CppAD::atomic_base<double> {
    5939/* $$
     
    6242        public:
    6343        // constructor (could use const char* for name)
    64         atomic_norm_sq(const std::string& name) :
    65         CppAD::atomic_base<double>(name)
     44        atomic_norm_sq(const std::string& name) :
     45        // this example uses boolean sparsity patterns
     46        CppAD::atomic_base<double>(name, atomic_base<double>::bool_sparsity_enum)
    6647        { }
    6748        private:
     
    9374
    9475                // Order zero forward mode must always be implemented.
    95                 // y^0 = f( x^0 ) 
     76                // y^0 = f( x^0 )
    9677                double x_00 = tx[ 0*(q+1) + 0];        // x_0^0
    9778                double x_10 = tx[ 1*(q+1) + 0];        // x_10
     
    131112        )
    132113        {       size_t n = tx.size() / (q+1);
    133                 size_t m = ty.size() / (q+1);   
     114                size_t m = ty.size() / (q+1);
    134115                assert( px.size() == n * (q+1) );
    135116                assert( py.size() == m * (q+1) );
    136117                assert( n == 2 );
    137118                assert( m == 1 );
    138                 bool ok = q <= 1;       
     119                bool ok = q <= 1;
    139120
    140121                double fp_0, fp_1;
     
    164145                const vector<bool>&                   r ,
    165146                      vector<bool>&                   s )
    166         {       // This function needed if using f.ForSparseJac
    167                 // with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
     147        {       // This function needed if using f.ForSparseJac
    168148                size_t n = r.size() / p;
    169149                size_t m = s.size() / p;
     
    171151                assert( m == 1 );
    172152
    173                 // sparsity for S(x) = f'(x) * R 
     153                // sparsity for S(x) = f'(x) * R
    174154                // where f'(x) = 2 * [ x_0, x_1 ]
    175155                for(size_t j = 0; j < p; j++)
     
    178158                                s[j] |= r[i * p + j];
    179159                }
    180                 return true;
    181         }
    182         // forward Jacobian set sparsity routine called by CppAD
    183         virtual bool for_sparse_jac(
    184                 size_t                                p ,
    185                 const vector< std::set<size_t> >&     r ,
    186                       vector< std::set<size_t> >&     s )
    187         {       // This function needed if using f.ForSparseJac
    188                 // with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
    189                 size_t n = r.size();
    190                 size_t m = s.size();
    191                 assert( n == 2 );
    192                 assert( m == 1 );
    193 
    194                 // sparsity for S(x) = f'(x) * R
    195                 // where f'(x) = 2 * [ x_0, x_1 ]
    196                 my_union(s[0], r[0], r[1]);
    197 
    198                 return true;
     160                return true;
    199161        }
    200162/* $$
     
    207169                      vector<bool>&                   st )
    208170        {       // This function needed if using RevSparseJac or optimize
    209                 // with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
    210171                size_t n = st.size() / p;
    211172                size_t m = rt.size() / p;
     
    213174                assert( m == 1 );
    214175
    215                 // sparsity for S(x)^T = f'(x)^T * R^T 
     176                // sparsity for S(x)^T = f'(x)^T * R^T
    216177                // where f'(x)^T = 2 * [ x_0, x_1]^T
    217178                for(size_t j = 0; j < p; j++)
     
    219180                                st[i * p + j] = rt[j];
    220181
    221                 return true;
    222         }
    223         // reverse Jacobian set sparsity routine called by CppAD
    224         virtual bool rev_sparse_jac(
    225                 size_t                                p  ,
    226                 const vector< std::set<size_t> >&     rt ,
    227                       vector< std::set<size_t> >&     st )
    228         {       // This function needed if using RevSparseJac or optimize
    229                 // with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
    230                 size_t n = st.size();
    231                 size_t m = rt.size();
    232                 assert( n == 2 );
    233                 assert( m == 1 );
    234 
    235                 // sparsity for S(x)^T = f'(x)^T * R^T
    236                 // where f'(x)^T = 2 * [ x_0, x_1]^T
    237                 st[0] = rt[0];
    238                 st[1] = rt[0];
    239 
    240                 return true;
     182                return true;
    241183        }
    242184/* $$
     
    253195                      vector<bool>&                   v )
    254196        {       // This function needed if using RevSparseHes
    255                 // with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
    256197                size_t m = s.size();
    257198                size_t n = t.size();
     
    265206                // so it is not necessary to use vx.
    266207
    267                 // sparsity for T(x) = S(x) * f'(x) 
     208                // sparsity for T(x) = S(x) * f'(x)
    268209                t[0] = s[0];
    269210                t[1] = s[0];
    270211
    271                 // V(x) = f'(x)^T * g''(y) * f'(x) * R  +  g'(y) * f''(x) * R 
     212                // V(x) = f'(x)^T * g''(y) * f'(x) * R  +  g'(y) * f''(x) * R
    272213                // U(x) = g''(y) * f'(x) * R
    273214                // S(x) = g'(y)
    274                
     215
    275216                // back propagate the sparsity for U
    276217                size_t j;
     
    290231                return true;
    291232        }
    292         // reverse Hessian set sparsity routine called by CppAD
    293         virtual bool rev_sparse_hes(
    294                 const vector<bool>&                   vx,
    295                 const vector<bool>&                   s ,
    296                       vector<bool>&                   t ,
    297                 size_t                                p ,
    298                 const vector< std::set<size_t> >&     r ,
    299                 const vector< std::set<size_t> >&     u ,
    300                       vector< std::set<size_t> >&     v )
    301         {       // This function needed if using RevSparseHes
    302                 // with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
    303                 size_t n = vx.size();
    304                 size_t m = s.size();
    305                 assert( t.size() == n );
    306                 assert( r.size() == n );
    307                 assert( u.size() == m );
    308                 assert( v.size() == n );
    309                 assert( n == 2 );
    310                 assert( m == 1 );
    311 
    312                 // There are no cross term second derivatives for this case,
    313                 // so it is not necessary to vx.
    314 
    315                 // sparsity for T(x) = S(x) * f'(x)
    316                 // where f'(x) = 2 * [ x_0, x_1 ]
    317                 t[0] = s[0];
    318                 t[1] = s[0];
    319        
    320                 // V(x) = f'(x)^T * g''(y) * f'(x) * R  +  g'(y) * f''(x) * R
    321                 // U(x) = g''(y) * f'(x) * R
    322                 // S(x) = g'(y)
    323                
    324                 // Compute sparsity for f'(x)^T * U(x)
    325                 // where f'(x)^T = 2 * [ x_0, x_1 ]^T
    326                 v[0] = u[0];
    327                 v[1] = u[0];
    328 
    329                 // include sparsity for g'(y) * f''(x) * R
    330                 // where f''(x) = [ 2 , 0 ]
    331                 //                [ 0 , 2 ]
    332                 // note there are no cross terms
    333                 if( s[0] )
    334                 {       for(size_t i = 0; i < n; i++)
    335                                 my_union(v[i], v[i], r[i] );
    336                 }
    337 
    338                 return true;
    339         }
    340233/* $$
    341234$head End Class Definition$$
     
    374267        CppAD::Independent(ax);
    375268
    376         // range space vector 
     269        // range space vector
    377270        size_t m = 1;
    378271        vector< AD<double> > ay(m);
    379272
    380         // call user function and store norm_sq(x) in au[0] 
     273        // call user function and store norm_sq(x) in au[0]
    381274        afun(ax, ay);        // y_0 = x_0 * x_0 + x_1 * x_1
    382275
    383276        // create f: x -> y and stop tape recording
    384277        CppAD::ADFun<double> f;
    385         f.Dependent (ax, ay); 
     278        f.Dependent (ax, ay);
    386279/* $$
    387280$subhead forward$$
    388281$codep */
    389         // check function value 
     282        // check function value
    390283        double check = x0 * x0 + x1 * x1;
    391284        ok &= NearEqual( Value(ay[0]) , check,  eps, eps);
     
    411304$subhead reverse$$
    412305$codep */
    413         // first order reverse mode 
     306        // first order reverse mode
    414307        q     = 1;
    415308        vector<double> w(m), dw(n * q);
     
    429322        r1[2] = false; r1[3] = true;
    430323        //
    431         afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    432324        s1    = f.ForSparseJac(p, r1);
    433         ok  &= s1[0] == true;  // f[0] depends on x[0] 
    434         ok  &= s1[1] == true;  // f[0] depends on x[1] 
    435         //
    436         afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
    437         s1    = f.ForSparseJac(p, r1);
    438         ok  &= s1[0] == true;  // f[0] depends on x[0] 
    439         ok  &= s1[1] == true;  // f[0] depends on x[1] 
     325        ok  &= s1[0] == true;  // f[0] depends on x[0]
     326        ok  &= s1[1] == true;  // f[0] depends on x[1]
    440327/* $$
    441328$subhead rev_sparse_jac$$
     
    446333        s2[0] = true;          // compute sparsity pattern for f[0]
    447334        //
    448         afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    449335        r2    = f.RevSparseJac(q, s2);
    450         ok  &= r2[0] == true;  // f[0] depends on x[0] 
    451         ok  &= r2[1] == true;  // f[0] depends on x[1] 
    452         //
    453         afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
    454         r2    = f.RevSparseJac(q, s2);
    455         ok  &= r2[0] == true;  // f[0] depends on x[0] 
    456         ok  &= r2[1] == true;  // f[0] depends on x[1] 
     336        ok  &= r2[0] == true;  // f[0] depends on x[0]
     337        ok  &= r2[1] == true;  // f[0] depends on x[1]
    457338/* $$
    458339$subhead rev_sparse_hes$$
    459340$codep */
    460         // Hessian sparsity (using previous ForSparseJac call) 
     341        // Hessian sparsity (using previous ForSparseJac call)
    461342        CppAD::vectorBool s3(m), h(p * n);
    462343        s3[0] = true;        // compute sparsity pattern for f[0]
    463344        //
    464         afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    465345        h     = f.RevSparseHes(p, s3);
    466346        ok  &= h[0] == true;  // partial of f[0] w.r.t. x[0],x[0] is non-zero
     
    469349        ok  &= h[3] == true;  // partial of f[0] w.r.t. x[1],x[1] is non-zero
    470350        //
    471         afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
    472         h     = f.RevSparseHes(p, s3);
    473         ok  &= h[0] == true;  // partial of f[0] w.r.t. x[0],x[0] is non-zero
    474         ok  &= h[1] == false; // partial of f[0] w.r.t. x[0],x[1] is zero
    475         ok  &= h[2] == false; // partial of f[0] w.r.t. x[1],x[0] is zero
    476         ok  &= h[3] == true;  // partial of f[0] w.r.t. x[1],x[1] is non-zero
    477 
    478351        return ok;
    479352}
  • trunk/example/atomic/old_mat_mul.cpp

    r2857 r3715  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1717$$
    1818
    19 $section Matrix Multiply as a User Atomic Operation: Example and Test$$
    20 
    21 $index old_atomic, example$$
    22 $index old_atomic, test$$
    23 $index matrix, atomic example$$
    24 $index old_mat_mul, example$$
    25 $index old_mat_mul, test$$
     19$section Old Matrix Multiply as a User Atomic Operation: Example and Test$$
    2620
    2721$head Deprecated$$
    28 This example has been deprecated; 
     22This example has been deprecated;
    2923see $cref atomic_mat_mul.cpp$$.
    3024
     
    5347        size_t n_middle  = 2;
    5448        size_t nc_result = 2;
    55        
    56         // declare the AD<double> vectors ax and ay and X 
     49
     50        // declare the AD<double> vectors ax and ay and X
    5751        size_t n = nr_result * n_middle + n_middle * nc_result;
    5852        size_t m = nr_result * nc_result;
     
    7266        ax[4]  = X[2];  // right[0,0]  = x[2] = 3
    7367        ax[5]  = 7.;    // right[0,1]  = 7
    74         ax[6]  = X[3];  // right[1,0]  = x[3] = 4 
     68        ax[6]  = X[3];  // right[1,0]  = x[3] = 4
    7569        ax[7]  = 8.;    // right[1,1]  = 8
    7670        /*
     
    8680        info.nc_result = nc_result;
    8781        // info.vx gets set by forward during call to mat_mul below
    88         assert( info.vx.size() == 0 ); 
     82        assert( info.vx.size() == 0 );
    8983        size_t id      = info_.size();
    9084        info_.push_back(info);
     
    115109
    116110        //----------------------------------------------------------------------
    117         // Test first order forward mode evaluation of g'(x) * [1, 2, 3, 4]^T 
     111        // Test first order forward mode evaluation of g'(x) * [1, 2, 3, 4]^T
    118112        // g'(x) = [ x2, x3, x0, x1 ]
    119113        //         [ 7 ,  8,  0, 0  ]
    120114        //         [ 0 ,  0,  5, 6  ]
    121         //         [ 0 ,  0,  0, 0  ] 
     115        //         [ 0 ,  0,  0, 0  ]
    122116        CppAD::vector<double> dx( X.size() ), dy(m);
    123117        for(j = 0; j <  X.size() ; j++)
     
    130124
    131125        //----------------------------------------------------------------------
    132         // Test second order forward mode 
     126        // Test second order forward mode
    133127        // g_0^2 (x) = [ 0, 0, 1, 0 ], g_0^2 (x) * [1] = [3]
    134128        //             [ 0, 0, 0, 1 ]              [2]   [4]
     
    140134        ddy = G.Forward(2, ddx);
    141135        // [1, 2, 3, 4] * g_0^2 (x) * [1, 2, 3, 4]^T = 1*3 + 2*4 + 3*1 + 4*2
    142         ok &= 2. * ddy[0] == 1. * 3. + 2. * 4. + 3. * 1. + 4. * 2.; 
     136        ok &= 2. * ddy[0] == 1. * 3. + 2. * 4. + 3. * 1. + 4. * 2.;
    143137        // for i > 0, [1, 2, 3, 4] * g_i^2 (x) * [1, 2, 3, 4]^T = 0
    144138        ok &= ddy[1] == 0.;
     
    147141
    148142        //----------------------------------------------------------------------
    149         // Test second order reverse mode 
     143        // Test second order reverse mode
    150144        CppAD::vector<double> w(m), dw(2 *  X.size() );
    151145        for(i = 0; i < m; i++)
     
    196190        // s[3] == {}
    197191        ok &= s[3].empty();
    198        
     192
    199193        //----------------------------------------------------------------------
    200194        // Test reverse Jacobian sparsity pattern
     
    247241        for(j = 0; j <  X.size() ; j++)
    248242        {       // h[j] = { check[j] }
    249                 for(i = 0; i < n; i++) 
     243                for(i = 0; i < n; i++)
    250244                {       if( i == check[j] )
    251245                                ok &= h[j].find(i) != h[j].end();
     
    259253        for(j = 0; j <  X.size() ; j++)
    260254        {       // h[j] = { }
    261                 for(i = 0; i < X.size(); i++) 
     255                for(i = 0; i < X.size(); i++)
    262256                        ok &= h[j].find(i) == h[j].end();
    263257        }
    264258
    265259        // --------------------------------------------------------------------
    266         // Free temporary work space. (If there are future calls to 
     260        // Free temporary work space. (If there are future calls to
    267261        // old_mat_mul they would create new temporary work space.)
    268262        CppAD::user_atomic<double>::clear();
  • trunk/example/atomic/old_reciprocal.cpp

    r3160 r3715  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1414$begin old_reciprocal.cpp$$
    1515$section Old Atomic Operation Reciprocal: Example and Test$$
    16 $index user, old atomic reciprocal$$
    17 $index atomic, old atomic reciprocal$$
    18 $index reciprocal, old atomic$$
    1916
    2017$head Deprecated$$
     
    2320
    2421$head Theory$$
    25 The example below defines the user atomic function 
     22The example below defines the user atomic function
    2623$latex f : \B{R}^n \rightarrow \B{R}^m$$ where
    2724$latex n = 1$$, $latex m = 1$$, and $latex f(x) = 1 / x$$.
     
    3633# include <cppad/cppad.hpp>
    3734
    38 namespace { // Begin empty namespace 
     35namespace { // Begin empty namespace
    3936        using CppAD::vector;
    4037        // ----------------------------------------------------------------------
     
    7168                assert( m == 1 );
    7269                assert( k == 0 || vx.size() == 0 );
    73                 bool ok = false;       
     70                bool ok = false;
    7471                double f, fp, fpp;
    7572
     
    9289                        f     = ty[0];
    9390                        fp    = - f / tx[0];
    94                         ty[1] = fp * tx[1]; 
     91                        ty[1] = fp * tx[1];
    9592                        ok    = true;
    9693                        break;
     
    126123                assert( n == 1 );
    127124                assert( m == 1 );
    128                 bool ok = false;       
     125                bool ok = false;
    129126
    130127                double f, fp, fpp, fppp;
     
    163160                        px[2]  = py[2] * fp;
    164161                        px[1]  = py[2] * fpp * tx[1];
    165                         px[0]  = py[2] * tx[1] * fppp * tx[1] / 2.0 + fpp * tx[2]; 
     162                        px[0]  = py[2] * tx[1] * fppp * tx[1] / 2.0 + fpp * tx[2];
    166163                        // reverse: F^1 ( tx ) = y^1 = f'( x^0 ) x^1
    167164                        px[1] += py[1] * fp;
     
    178175        // forward Jacobian sparsity routine called by CppAD
    179176        bool reciprocal_for_jac_sparse(
    180                 size_t                               id ,             
     177                size_t                               id ,
    181178                size_t                                n ,
    182179                size_t                                m ,
     
    192189                s[0] = r[0];
    193190
    194                 return true; 
     191                return true;
    195192        }
    196193        // ----------------------------------------------------------------------
    197194        // reverse Jacobian sparsity routine called by CppAD
    198195        bool reciprocal_rev_jac_sparse(
    199                 size_t                               id ,             
     196                size_t                               id ,
    200197                size_t                                n ,
    201198                size_t                                m ,
     
    212209                        r[q] = s[q];
    213210
    214                 return true; 
     211                return true;
    215212        }
    216213        // ----------------------------------------------------------------------
    217214        // reverse Hessian sparsity routine called by CppAD
    218215        bool reciprocal_rev_hes_sparse(
    219                 size_t                               id ,             
     216                size_t                               id ,
    220217                size_t                                n ,
    221218                size_t                                m ,
     
    233230                // sparsity for T(x) = S(x) * f'(x) is same as sparsity for S
    234231                t[0] = s[0];
    235        
    236                 // V(x) = [ f'(x)^T * g''(y) * f'(x) + g'(y) * f''(x) ] * R 
     232
     233                // V(x) = [ f'(x)^T * g''(y) * f'(x) + g'(y) * f''(x) ] * R
    237234                // U(x) = g''(y) * f'(x) * R
    238235                // S(x) = g'(y)
    239                
     236
    240237                // back propagate the sparsity for U because derivative of
    241238                // reciprocal may be non-zero
    242                 v[0] = u[0]; 
     239                v[0] = u[0];
    243240
    244241                // convert forward Jacobian sparsity to Hessian sparsity
     
    253250        // Declare the AD<double> routine reciprocal(id, ax, ay)
    254251        CPPAD_USER_ATOMIC(
    255                 reciprocal                 , 
     252                reciprocal                 ,
    256253                CppAD::vector              ,
    257                 double                     , 
    258                 reciprocal_forward         , 
     254                double                     ,
     255                reciprocal_forward         ,
    259256                reciprocal_reverse         ,
    260257                reciprocal_for_jac_sparse  ,
    261258                reciprocal_rev_jac_sparse  ,
    262                 reciprocal_rev_hes_sparse 
     259                reciprocal_rev_hes_sparse
    263260        )
    264261} // End empty namespace
     
    282279        CppAD::Independent(ax);
    283280
    284         // range space vector 
     281        // range space vector
    285282        size_t m = 1;
    286283        vector< AD<double> > ay(m);
    287284
    288         // call user function and store reciprocal(x) in au[0] 
     285        // call user function and store reciprocal(x) in au[0]
    289286        vector< AD<double> > au(m);
    290287        size_t id = 0;           // not used
    291288        reciprocal(id, ax, au); // u = 1 / x
    292289
    293         // call user function and store reciprocal(u) in ay[0] 
     290        // call user function and store reciprocal(u) in ay[0]
    294291        reciprocal(id, au, ay); // y = 1 / u = x
    295292
     
    301298        // Check forward mode results
    302299        //
    303         // check function value 
     300        // check function value
    304301        double check = x0;
    305302        ok &= NearEqual( Value(ay[0]) , check,  eps, eps);
     
    330327        // Check reverse mode results
    331328        //
    332         // third order reverse mode 
     329        // third order reverse mode
    333330        q     = 3;
    334331        vector<double> w(m), dw(n * q);
     
    347344        r1[0] = true;          // compute sparsity pattern for x[0]
    348345        s1    = f.ForSparseJac(p, r1);
    349         ok  &= s1[0] == true;  // f[0] depends on x[0] 
     346        ok  &= s1[0] == true;  // f[0] depends on x[0]
    350347
    351348        // --------------------------------------------------------------------
     
    355352        s2[0] = true;          // compute sparsity pattern for f[0]
    356353        r2    = f.RevSparseJac(q, s2);
    357         ok  &= r2[0] == true;  // f[0] depends on x[0] 
    358 
    359         // --------------------------------------------------------------------
    360         // Hessian sparsity (using previous ForSparseJac call) 
     354        ok  &= r2[0] == true;  // f[0] depends on x[0]
     355
     356        // --------------------------------------------------------------------
     357        // Hessian sparsity (using previous ForSparseJac call)
    361358        CppAD::vectorBool s3(m), h(p * n);
    362359        s3[0] = true;        // compute sparsity pattern for f[0]
     
    365362
    366363        // -----------------------------------------------------------------
    367         // Free all temporary work space associated with old_atomic objects. 
    368         // (If there are future calls to user atomic functions, they will 
     364        // Free all temporary work space associated with old_atomic objects.
     365        // (If there are future calls to user atomic functions, they will
    369366        // create new temporary work space.)
    370367        CppAD::user_atomic<double>::clear();
  • trunk/example/atomic/old_tan.cpp

    r3160 r3715  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1717$$
    1818
    19 $section Tan and Tanh as User Atomic Operations: Example and Test$$
    20 
    21 $index tan, old_atomic$$
    22 $index user, atomic tan$$
    23 $index atomic, tan$$
    24 $index test, old_atomic$$
    25 $index old_atomic, example$$
    26 $index example, old_atomic$$
     19$section Old Tan and Tanh as User Atomic Operations: Example and Test$$
    2720
    2821$head Deprecated$$
     
    4437# include <cppad/cppad.hpp>
    4538
    46 namespace { // Begin empty namespace 
     39namespace { // Begin empty namespace
    4740        using CppAD::vector;
    4841
     
    9083                {       assert( vx.size() >= n );
    9184                        assert( vzy.size() >= m );
    92                        
     85
    9386                        // now setvzy
    9487                        vzy[0] = vx[0];
     
    111104
    112105                        // z^{(j)} = x^{(j)} +- sum_{k=1}^j k x^{(k)} y^{(j-k)} / j
    113                         tzy[j] = tx[j]; 
     106                        tzy[j] = tx[j];
    114107                        for(k = 1; k <= j; k++)
    115108                                tzy[j] += tx[k] * tzy[n_order + j-k] * k * j_inv;
     
    120113                                tzy[n_order + j] += tzy[k] * tzy[j-k];
    121114                }
    122                        
     115
    123116                // All orders are implemented and there are no possible errors
    124117                return true;
     
    164157                        px[j] += qzy[j];
    165158                        for(k = 1; k <= j; k++)
    166                                 px[k] += qzy[j] * tzy[n_order + j-k] * k * j_inv; 
     159                                px[k] += qzy[j] * tzy[n_order + j-k] * k * j_inv;
    167160
    168161                        // H_{y^{j-k)} += +- H_{z^{(j)} x^{(k)} * k / j
    169162                        for(k = 1; k <= j; k++)
    170                                 qzy[n_order + j-k] += qzy[j] * tx[k] * k * j_inv; 
    171 
    172                         // H_{z^{(k)}} += H_{y^{(j-1)}} * z^{(j-k-1)} * 2. 
     163                                qzy[n_order + j-k] += qzy[j] * tx[k] * k * j_inv;
     164
     165                        // H_{z^{(k)}} += H_{y^{(j-1)}} * z^{(j-k-1)} * 2.
    173166                        for(k = 0; k < j; k++)
    174                                 qzy[k] += qzy[n_order + j-1] * tzy[j-k-1] * 2.f; 
     167                                qzy[k] += qzy[n_order + j-1] * tzy[j-k-1] * 2.f;
    175168                }
    176169
     
    181174                        px[0] += qzy[0] * (1.f - tzy[n_order + 0]);
    182175
    183                 return true; 
     176                return true;
    184177        }
    185178        // ----------------------------------------------------------------------
    186179        // forward Jacobian sparsity routine called by CppAD
    187180        bool old_tan_for_jac_sparse(
    188                 size_t                               id ,             
     181                size_t                               id ,
    189182                size_t                                n ,
    190183                size_t                                m ,
     
    208201        // reverse Jacobian sparsity routine called by CppAD
    209202        bool old_tan_rev_jac_sparse(
    210                 size_t                               id ,             
     203                size_t                               id ,
    211204                size_t                                n ,
    212205                size_t                                m ,
     
    222215
    223216                // note that, if the users code only uses z, and not y,
    224                 // we could just set r[0] = s[0]       
     217                // we could just set r[0] = s[0]
    225218                my_union(r[0], s[0], s[1]);
    226                 return true; 
     219                return true;
    227220        }
    228221        // ----------------------------------------------------------------------
    229222        // reverse Hessian sparsity routine called by CppAD
    230223        bool old_tan_rev_hes_sparse(
    231                 size_t                               id ,             
     224                size_t                               id ,
    232225                size_t                                n ,
    233226                size_t                                m ,
     
    265258        // Declare the AD<float> routine old_tan(id, ax, ay)
    266259        CPPAD_USER_ATOMIC(
    267                 old_tan                 , 
     260                old_tan                 ,
    268261                CppAD::vector           ,
    269                 float                   , 
    270                 old_tan_forward         , 
     262                float                   ,
     263                old_tan_forward         ,
    271264                old_tan_reverse         ,
    272265                old_tan_for_jac_sparse  ,
    273266                old_tan_rev_jac_sparse  ,
    274                 old_tan_rev_hes_sparse 
     267                old_tan_rev_hes_sparse
    275268        )
    276269} // End empty namespace
     
    291284        CppAD::Independent(ax);
    292285
    293         // range space vector 
     286        // range space vector
    294287        size_t m = 3;
    295288        CppAD::vector< AD<float> > af(m);
     
    313306        one[0] = 1.;
    314307        old_tan(id, one, az);
    315         af[2] = az[0]; 
     308        af[2] = az[0];
    316309
    317310        // create f: x -> f and stop tape recording
    318311        CppAD::ADFun<float> F;
    319         F.Dependent(ax, af); 
    320 
    321         // check function value 
     312        F.Dependent(ax, af);
     313
     314        // check function value
    322315        float tan = std::tan(x0);
    323316        ok &= NearEqual(af[0] , tan,  eps, eps);
     
    344337        dw    = F.Reverse(1, w);
    345338
    346         // tan'(x)   = 1 + tan(x)  * tan(x) 
    347         // tanh'(x)  = 1 - tanh(x) * tanh(x) 
    348         float tanp  = 1.f + tan * tan; 
    349         float tanhp = 1.f - tanh * tanh; 
     339        // tan'(x)   = 1 + tan(x)  * tan(x)
     340        // tanh'(x)  = 1 - tanh(x) * tanh(x)
     341        float tanp  = 1.f + tan * tan;
     342        float tanhp = 1.f - tanh * tanh;
    350343        ok   &= NearEqual(df[0], tanp, eps, eps);
    351344        ok   &= NearEqual(df[1], tanhp, eps, eps);
     
    361354        ddw   = F.Reverse(2, w);
    362355
    363         // tan''(x)   = 2 *  tan(x) * tan'(x) 
    364         // tanh''(x)  = - 2 * tanh(x) * tanh'(x) 
     356        // tan''(x)   = 2 *  tan(x) * tan'(x)
     357        // tanh''(x)  = - 2 * tanh(x) * tanh'(x)
    365358        // Note that second order Taylor coefficient for u half the
    366359        // corresponding second derivative.
     
    419412        tanhp = 0.;
    420413        ok   &= NearEqual(df[1], tanhp, eps, eps);
    421  
     414
    422415        // --------------------------------------------------------------------
    423         // Free all temporary work space associated with old_atomic objects. 
    424         // (If there are future calls to user atomic functions, they will 
     416        // Free all temporary work space associated with old_atomic objects.
     417        // (If there are future calls to user atomic functions, they will
    425418        // create new temporary work space.)
    426419        CppAD::user_atomic<float>::clear();
  • trunk/example/atomic/reciprocal.cpp

    r3160 r3715  
    11// $Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1515
    1616$section Reciprocal as an Atomic Operation: Example and Test$$
    17 $index reciprocal, atomic operation$$
    18 $index simple, atomic operation$$
    19 $index atomic, simple operation$$
    20 $index operation, simple atomic$$
    2117
    2218$head Theory$$
     
    5652        public:
    5753        // constructor (could use const char* for name)
    58         atomic_reciprocal(const std::string& name) :
    59         CppAD::atomic_base<double>(name)
     54        atomic_reciprocal(const std::string& name) :
     55        // this exmaple uses set sparsity patterns
     56        CppAD::atomic_base<double>(name, atomic_base<double>::set_sparsity_enum)
    6057        { }
    6158        private:
     
    10198                double fp = - f / tx[0];
    10299                if( p <= 1 )
    103                         ty[1] = fp * tx[1]; 
     100                        ty[1] = fp * tx[1];
    104101                if( q <= 1 )
    105102                        return ok;
     
    130127        )
    131128        {       size_t n = tx.size() / (q + 1);
    132                 size_t m = ty.size() / (q + 1); 
     129                size_t m = ty.size() / (q + 1);
    133130                assert( px.size() == n * (q + 1) );
    134131                assert( py.size() == m * (q + 1) );
    135132                assert( n == 1 );
    136133                assert( m == 1 );
    137                 bool ok = q <= 2;       
     134                bool ok = q <= 2;
    138135
    139136                double f, fp, fpp, fppp;
     
    171168                        px[2]  = py[2] * fp;
    172169                        px[1]  = py[2] * fpp * tx[1];
    173                         px[0]  = py[2] * tx[1] * fppp * tx[1] / 2.0 + fpp * tx[2]; 
     170                        px[0]  = py[2] * tx[1] * fppp * tx[1] / 2.0 + fpp * tx[2];
    174171                        // reverse: F^1 ( tx ) = y^1 = f'( x^0 ) x^1
    175172                        px[1] += py[1] * fp;
     
    188185$head for_sparse_jac$$
    189186$codep */
    190         // forward Jacobian bool sparsity routine called by CppAD
    191         virtual bool for_sparse_jac(
    192                 size_t                                p ,
    193                 const vector<bool>&                   r ,
    194                       vector<bool>&                   s )
    195         {       // This function needed if using f.ForSparseJac
    196                 // with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
    197                 size_t n = r.size() / p;
    198                 size_t m = s.size() / p;
    199                 assert( n == 1 );
    200                 assert( m == 1 );
    201 
    202                 // sparsity for S(x) = f'(x) * R is same as sparsity for R
    203                 for(size_t j = 0; j < p; j++)
    204                         s[j] = r[j];
    205 
    206                 return true;
    207         }
    208187        // forward Jacobian set sparsity routine called by CppAD
    209188        virtual bool for_sparse_jac(
     
    211190                const vector< std::set<size_t> >&     r ,
    212191                      vector< std::set<size_t> >&     s )
    213         {       // This function needed if using f.ForSparseJac
    214                 // with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
     192        {       // This function needed if using f.ForSparseJac
    215193                size_t n = r.size();
    216194                size_t m = s.size();
     
    221199                s[0] = r[0];
    222200
    223                 return true; 
     201                return true;
    224202        }
    225203/* $$
    226204$head rev_sparse_jac$$
    227205$codep */
    228         // reverse Jacobian bool sparsity routine called by CppAD
    229         virtual bool rev_sparse_jac(
    230                 size_t                                p  ,
    231                 const vector<bool>&                   rt ,
    232                       vector<bool>&                   st )
    233         {       // This function needed if using RevSparseJac or optimize
    234                 // with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
    235                 size_t n = st.size() / p;
    236                 size_t m = rt.size() / p;
    237                 assert( n == 1 );
    238                 assert( m == 1 );
    239 
    240                 // sparsity for S(x)^T = f'(x)^T * R^T is same as sparsity for R^T
    241                 for(size_t i = 0; i < p; i++)
    242                         st[i] = rt[i];
    243 
    244                 return true;
    245         }
    246206        // reverse Jacobian set sparsity routine called by CppAD
    247207        virtual bool rev_sparse_jac(
     
    250210                      vector< std::set<size_t> >&     st )
    251211        {       // This function needed if using RevSparseJac or optimize
    252                 // with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
    253212                size_t n = st.size();
    254213                size_t m = rt.size();
     
    259218                st[0] = rt[0];
    260219
    261                 return true; 
     220                return true;
    262221        }
    263222/* $$
    264223$head rev_sparse_hes$$
    265224$codep */
    266         // reverse Hessian bool sparsity routine called by CppAD
    267         virtual bool rev_sparse_hes(
    268                 const vector<bool>&                   vx,
    269                 const vector<bool>&                   s ,
    270                       vector<bool>&                   t ,
    271                 size_t                                p ,
    272                 const vector<bool>&                   r ,
    273                 const vector<bool>&                   u ,
    274                       vector<bool>&                   v )
    275         {       // This function needed if using RevSparseHes
    276                 // with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
    277                 size_t m = s.size();
    278                 size_t n = t.size();
    279                 assert( r.size() == n * p );
    280                 assert( u.size() == m * p );
    281                 assert( v.size() == n * p );
    282                 assert( n == 1 );
    283                 assert( m == 1 );
    284 
    285                 // There are no cross term second derivatives for this case,
    286                 // so it is not necessary to vx.
    287 
    288                 // sparsity for T(x) = S(x) * f'(x) is same as sparsity for S
    289                 t[0] = s[0];
    290 
    291                 // V(x) = f'(x)^T * g''(y) * f'(x) * R  +  g'(y) * f''(x) * R
    292                 // U(x) = g''(y) * f'(x) * R
    293                 // S(x) = g'(y)
    294                
    295                 // back propagate the sparsity for U, note f'(x) may be non-zero;
    296                 size_t j;
    297                 for(j = 0; j < p; j++)
    298                         v[j] = u[j];
    299 
    300                 // include forward Jacobian sparsity in Hessian sparsity
    301                 // (note sparsty for f''(x) * R same as for R)
    302                 if( s[0] )
    303                 {       for(j = 0; j < p; j++)
    304                                 v[j] |= r[j];
    305                 }
    306 
    307                 return true;
    308         }
    309225        // reverse Hessian set sparsity routine called by CppAD
    310226        virtual bool rev_sparse_hes(
     
    317233                      vector< std::set<size_t> >&     v )
    318234        {       // This function needed if using RevSparseHes
    319                 // with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
    320235                size_t n = vx.size();
    321236                size_t m = s.size();
     
    332247                // sparsity for T(x) = S(x) * f'(x) is same as sparsity for S
    333248                t[0] = s[0];
    334        
    335                 // V(x) = f'(x)^T * g''(y) * f'(x) * R  +  g'(y) * f''(x) * R 
     249
     250                // V(x) = f'(x)^T * g''(y) * f'(x) * R  +  g'(y) * f''(x) * R
    336251                // U(x) = g''(y) * f'(x) * R
    337252                // S(x) = g'(y)
    338                
     253
    339254                // back propagate the sparsity for U, note f'(x) may be non-zero;
    340255                v[0] = u[0];
     
    381296        CppAD::Independent(ax);
    382297
    383         // range space vector 
     298        // range space vector
    384299        size_t m = 1;
    385300        vector< AD<double> > ay(m);
    386301
    387         // call user function and store reciprocal(x) in au[0] 
     302        // call user function and store reciprocal(x) in au[0]
    388303        vector< AD<double> > au(m);
    389304        afun(ax, au);        // u = 1 / x
     
    398313$subhead forward$$
    399314$codep */
    400         // check function value 
     315        // check function value
    401316        double check = x0;
    402317        ok &= NearEqual( Value(ay[0]) , check,  eps, eps);
     
    426341$subhead reverse$$
    427342$codep */
    428         // third order reverse mode 
     343        // third order reverse mode
    429344        q     = 3;
    430345        vector<double> w(m), dw(n * q);
     
    444359        r1[0] = true;          // compute sparsity pattern for x[0]
    445360        //
    446         afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    447361        s1    = f.ForSparseJac(p, r1);
    448         ok  &= s1[0] == true;  // f[0] depends on x[0] 
    449         //
    450         afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
    451         s1    = f.ForSparseJac(p, r1);
    452         ok  &= s1[0] == true;  // f[0] depends on x[0] 
     362        ok  &= s1[0] == true;  // f[0] depends on x[0]
    453363/* $$
    454364$subhead rev_sparse_jac$$
     
    459369        s2[0] = true;          // compute sparsity pattern for f[0]
    460370        //
    461         afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    462371        r2    = f.RevSparseJac(q, s2);
    463         ok  &= r2[0] == true;  // f[0] depends on x[0] 
    464         //
    465         afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
    466         r2    = f.RevSparseJac(q, s2);
    467         ok  &= r2[0] == true;  // f[0] depends on x[0] 
     372        ok  &= r2[0] == true;  // f[0] depends on x[0]
    468373/* $$
    469374$subhead rev_sparse_hes$$
    470375$codep */
    471         // Hessian sparsity (using previous ForSparseJac call) 
     376        // Hessian sparsity (using previous ForSparseJac call)
    472377        CppAD::vectorBool s3(m), h(p * n);
    473378        s3[0] = true;        // compute sparsity pattern for f[0]
    474379        //
    475         afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
    476380        h     = f.RevSparseHes(p, s3);
    477381        ok  &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
    478382        //
    479         afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
    480         h     = f.RevSparseHes(p, s3);
    481         ok  &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
    482 
    483383        return ok;
    484384}
  • trunk/omh/atomic_base.omh

    r3505 r3715  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    1212$begin atomic_base$$
    1313$spell
     14        ctor
    1415        cppad
    1516        hpp
     
    3940
    4041$codei%
    41 %atomic_user% %afun%(%n%, %m%, %use_set%, %user_arg_list%)
     42%atomic_user% %afun%(%ctor_arg_list%)
    4243%afun%(%ax%, %ay%)
    4344%ok% = %afun%.forward(%p%, %q%, %vx%, %vy%, %tx%, %ty%)
     
    4950
    5051$head Purpose$$
    51 In some cases, the user knows how to compute derivatives of a function 
     52In some cases, the user knows how to compute derivatives of a function
    5253$latex \[
    53         y = f(x) \; {\rm where} \; f : B^n \rightarrow B^m 
     54        y = f(x) \; {\rm where} \; f : B^n \rightarrow B^m
    5455\] $$
    55 more efficiently than by coding it using $codei%AD<%Base%>%$$ 
     56more efficiently than by coding it using $codei%AD<%Base%>%$$
    5657$cref/atomic/glossary/Operation/Atomic/$$ operations
    5758and letting CppAD do the rest.
    5859In this case $codei%atomic_base%<%Base%>%$$ can use
    5960the user code for $latex f(x)$$, and its derivatives,
    60 as $codei%AD<%Base%>%$$ atomic operations. 
     61as $codei%AD<%Base%>%$$ atomic operations.
    6162
    6263$head Virtual Functions$$
     
    7071These virtual functions have a default implementation
    7172that returns $icode%ok% == false%$$.
    72 The $code forward$$ function, 
     73The $code forward$$ function,
    7374for the case $icode%q% == 0%$$, must be implemented.
    7475Otherwise, only those functions
    75 required by the your calculations need to be implemented. 
    76 For example, 
     76required by the your calculations need to be implemented.
     77For example,
    7778$icode forward$$ for the case $icode%q% == 2%$$ can just return
    7879$icode%ok% == false%$$ unless you require
  • trunk/omh/whats_new/whats_new_15.omh

    r3714 r3715  
    1414$dollar @$$
    1515$spell
     16        ctor
    1617        dimensioned
    1718        cskip_op
     
    5152        Adolc
    5253        resize
     54        bool
    5355$$
    5456
     
    6062The purpose of this section is to
    6163assist you in learning about changes between various versions of CppAD.
     64
     65$head 08-30$$
     66$list number$$
     67The $cref/sparsity/atomic_ctor/atomic_base/sparsity/$$
     68argument was added to the $code atomic_base$$ constructor and the
     69$cref/checkpoint/checkpoint/sparsity/$$ constructor.
     70$lnext
     71Make $cref atomic_norm_sq.cpp$$ an example with no set sparsity
     72and $cref atomic_reciprocal.cpp$$ an example with no bool sparsity.
     73$lend
    6274
    6375$head 08-29$$
Note: See TracChangeset for help on using the changeset viewer.