Changeset 3682 for trunk/test_more


Ignore:
Timestamp:
May 8, 2015 5:59:05 PM (5 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: c85ed888ce93510f0df134d9fec6b7e185552f41
end hash code: febe930d34888cf37df862a1bf118229b9bf37a5

commit febe930d34888cf37df862a1bf118229b9bf37a5
Author: Brad Bell <bradbell@…>
Date: Fri May 8 14:21:47 2015 -0700

  1. Automatically generated changes for deprecated auto-tools install.
  2. Fix bug in acosh_op multiple direction forward mode.


configure.ac: Add new symbols for acosh and atanh detection (this install never detects them).
acosh_op.hpp: fix bug in multiple direction forward mode.
whats_new_15.omh: mention bug fix.
forward_dir.cpp: test asinh, acosh, and atanh.

commit 5d007c969a1e8bb0f983629f8134022a47ff2d75
Author: Brad Bell <bradbell@…>
Date: Fri May 8 12:27:18 2015 -0700

Remove trialing white space.

commit d88357106a95ee156ecf2101334dc51b22162950
Author: Brad Bell <bradbell@…>
Date: Fri May 8 12:26:58 2015 -0700

Add atanh operator.

commit 03890672ea394862373e4b1aa19a79cf04a71e73
Author: Brad Bell <bradbell@…>
Date: Fri May 8 11:57:45 2015 -0700

Change order to erf asinh acosh.

commit 9657e6dae7b5ef30ea1ea79d344f655e4db4498e
Author: Brad Bell <bradbell@…>
Date: Fri May 8 05:56:33 2015 -0700

Remove trialing white space.

commit cca1d8b8f344582f4c27c3c9c16745625e7e395e
Author: Brad Bell <bradbell@…>
Date: Fri May 8 05:56:06 2015 -0700

Change Atan -> atan.

commit ffa1894b1f97ca342aa84b65b171baad03568f58
Author: Brad Bell <bradbell@…>
Date: Fri May 8 05:37:49 2015 -0700

  1. Extend atan to include atanh.
  2. Remove index commands for words in headings.
  3. Change AtanForward? -> atan_forward.
  4. Remove trailing white space.


acos_forward.omh: add heading as in tan_forward.
asin_forward.omh: add heading as in tan_forward.
atan_forward.omh: change AtanForward? -> atan_forward.

Location:
trunk/test_more
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/CMakeLists.txt

    r3680 r3682  
    7676        add_zero.cpp
    7777        atan.cpp
     78        atanh.cpp
    7879        atan2.cpp
    7980        base_alloc.cpp
  • trunk/test_more/atan.cpp

    r2506 r3682  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 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
     
    3434        // some temporary values
    3535        AD<double> x = cos(U[s]);
    36         AD<double> y = sin(U[s]); 
     36        AD<double> y = sin(U[s]);
    3737        AD<double> z = y / x;       // tan(s)
    3838
     
    4545
    4646        // create f: U -> Z and vectors used for dierivative calculations
    47         ADFun<double> f(U, Z); 
     47        ADFun<double> f(U, Z);
    4848        CPPAD_TESTVECTOR(double) v( f.Domain() );
    4949        CPPAD_TESTVECTOR(double) w( f.Range() );
    5050
    51         // check value 
     51        // check value
    5252        ok &= NearEqual(U[s] , Z[a],  1e-10 , 1e-10);
    5353
     
    6767        v[s] = 0.;
    6868        w    = f.Forward(2, v);
    69         ok &= NearEqual(2. * w[a], 0e0, 1e-10 , 1e-10);     // d^2 a / (ds ds) 
     69        ok &= NearEqual(2. * w[a], 0e0, 1e-10 , 1e-10);     // d^2 a / (ds ds)
    7070
    7171        // reverse computation of second partials of a
     
    9292
    9393        // a temporary values
    94         AD<double> x = sin(U[0]) / cos(U[0]); 
     94        AD<double> x = sin(U[0]) / cos(U[0]);
    9595
    96         // dependent variable vector 
     96        // dependent variable vector
    9797        CPPAD_TESTVECTOR(AD<double>) Z(1);
    9898        Z[0] = atan(x); // atan( tan(u) )
    9999
    100100        // create f: U -> Z and vectors used for derivative calculations
    101         ADFun<double> f(U, Z); 
     101        ADFun<double> f(U, Z);
    102102        CPPAD_TESTVECTOR(double) v(1);
    103103        CPPAD_TESTVECTOR(double) w(1);
    104104
    105         // check value 
     105        // check value
    106106        ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
    107107
     
    114114        for(j = 1; j < p; j++)
    115115        {       jfac *= j;
    116                 w     = f.Forward(j, v);       
     116                w     = f.Forward(j, v);
    117117                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
    118118                v[0]  = 0.;
     
    121121
    122122        // reverse computation of partials of Taylor coefficients
    123         CPPAD_TESTVECTOR(double) r(p); 
     123        CPPAD_TESTVECTOR(double) r(p);
    124124        w[0]  = 1.;
    125125        r     = f.Reverse(p, w);
     
    137137} // END empty namespace
    138138
    139 bool Atan(void)
     139bool atan(void)
    140140{       bool ok = true;
    141141        ok &= AtanTestOne();
    142         ok &= AtanTestTwo(); 
     142        ok &= AtanTestTwo();
    143143        return ok;
    144144}
  • trunk/test_more/forward_dir.cpp

    r3583 r3682  
    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
     
    2121        using CppAD::NearEqual;
    2222        // ---------------------------------------------------------------------
    23         // Used the check that fun is an idenity funciton 
    24         typedef AD<double> (*adfun)(const AD<double>&); 
     23        // Used the check that fun is an idenity funciton
     24        typedef AD<double> (*adfun)(const AD<double>&);
    2525        bool check_identity(adfun identity, double argument)
    2626        {
     
    2929                size_t j;
    3030
    31        
     31
    3232                // domain space vector
    3333                size_t n = 1;
    3434                CPPAD_TESTVECTOR(AD<double>) ax(n);
    3535                ax[0] = argument;
    36        
    37                 // declare independent variables and starting recording
    38                 CppAD::Independent(ax);
    39        
     36
     37                // declare independent variables and starting recording
     38                CppAD::Independent(ax);
     39
    4040                // range space vector
    4141                size_t m = 1;
    4242                CPPAD_TESTVECTOR(AD<double>) ay(m);
    4343                ay[0] = identity(ax[0]);
    44        
    45                 // create f: x -> y and stop tape recording
    46                 CppAD::ADFun<double> f(ax, ay);
    47        
    48                 // first order Taylor coefficients
    49                 size_t r = 2, ell;
    50                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    51                 for(ell = 0; ell < r; ell++)
    52                 {       for(j = 0; j < n; j++)
    53                                 x1[ r * j + ell ] = double(j + ell + 1);
    54                 }
    55                 y1  = f.Forward(1, r, x1);
    56                 ok &= y1.size() == r*m;
    57                
    58                 // secondorder Taylor coefficients
    59                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    60                 for(ell = 0; ell < r; ell++)
    61                 {       for(j = 0; j < n; j++)
    62                                 x2[ r * j + ell ] = double(j + ell + 2);
    63                 }
    64                 y2  = f.Forward(2, r, x2);
    65                 ok &= y2.size() == r*m;
    66                 // 
     44
     45                // create f: x -> y and stop tape recording
     46                CppAD::ADFun<double> f(ax, ay);
     47
     48                // first order Taylor coefficients
     49                size_t r = 2, ell;
     50                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     51                for(ell = 0; ell < r; ell++)
     52                {       for(j = 0; j < n; j++)
     53                                x1[ r * j + ell ] = double(j + ell + 1);
     54                }
     55                y1  = f.Forward(1, r, x1);
     56                ok &= y1.size() == r*m;
     57
     58                // secondorder Taylor coefficients
     59                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     60                for(ell = 0; ell < r; ell++)
     61                {       for(j = 0; j < n; j++)
     62                                x2[ r * j + ell ] = double(j + ell + 2);
     63                }
     64                y2  = f.Forward(2, r, x2);
     65                ok &= y2.size() == r*m;
     66                //
    6767                // Y_0  (t)    = F[X_0(t)] = X_0(t)
    6868                //             =  0.5 + 1t + 2t^2
    6969                double y_1_0   = 1.0;
    7070                double y_2_0   = 2.0;
    71                 // 
    72                 // Y_1  (t)    = F[X_1(t)] = X_1(t) 
     71                //
     72                // Y_1  (t)    = F[X_1(t)] = X_1(t)
    7373                //             =  0.5 + 2t + 3t^2
    7474                double y_1_1   = 2.0;
     
    8383        }
    8484        // ---------------------------------------------------------------------
    85         // AbsOp 
     85        // AbsOp
    8686        bool abs_op(void)
    8787        {       bool ok = true;
    8888                double eps = 10. * std::numeric_limits<double>::epsilon();
    8989                size_t j;
    90        
     90
    9191                // domain space vector
    9292                size_t n = 2;
    9393                CPPAD_TESTVECTOR(AD<double>) ax(n);
    94                 ax[0] = 0.5; 
     94                ax[0] = 0.5;
    9595                ax[1] = -1.0;
    96        
    97                 // declare independent variables and starting recording
    98                 CppAD::Independent(ax);
    99        
     96
     97                // declare independent variables and starting recording
     98                CppAD::Independent(ax);
     99
    100100                // range space vector
    101101                size_t m = 1;
    102102                CPPAD_TESTVECTOR(AD<double>) ay(m);
    103103                ay[0] = abs( ax[0] ) + abs( 2.0 * ax[1] );
    104        
    105                 // create f: x -> y and stop tape recording
    106                 CppAD::ADFun<double> f(ax, ay);
    107        
    108                 // first order Taylor coefficients
    109                 size_t r = 2, ell;
    110                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    111                 for(ell = 0; ell < r; ell++)
    112                 {       for(j = 0; j < n; j++)
    113                                 x1[ r * j + ell ] = double(j + ell + 1);
    114                 }
    115                 y1  = f.Forward(1, r, x1);
    116                 ok &= y1.size() == r*m;
    117                
    118                 // secondorder Taylor coefficients
    119                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    120                 for(ell = 0; ell < r; ell++)
    121                 {       for(j = 0; j < n; j++)
    122                                 x2[ r * j + ell ] = double(j + ell + 2);
    123                 }
    124                 y2  = f.Forward(2, r, x2);
    125                 ok &= y2.size() == r*m;
    126                 // 
    127                 // Y_0  (t)    = F[X_0(t)] 
     104
     105                // create f: x -> y and stop tape recording
     106                CppAD::ADFun<double> f(ax, ay);
     107
     108                // first order Taylor coefficients
     109                size_t r = 2, ell;
     110                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     111                for(ell = 0; ell < r; ell++)
     112                {       for(j = 0; j < n; j++)
     113                                x1[ r * j + ell ] = double(j + ell + 1);
     114                }
     115                y1  = f.Forward(1, r, x1);
     116                ok &= y1.size() == r*m;
     117
     118                // secondorder Taylor coefficients
     119                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     120                for(ell = 0; ell < r; ell++)
     121                {       for(j = 0; j < n; j++)
     122                                x2[ r * j + ell ] = double(j + ell + 2);
     123                }
     124                y2  = f.Forward(2, r, x2);
     125                ok &= y2.size() == r*m;
     126                //
     127                // Y_0  (t)    = F[X_0(t)]
    128128                //             = abs(0.5 + 1t + 2t^2) + abs( 2*(-1.0 + 2t + 3t^2 ) )
    129129                double y_1_0   = -3.0;
    130130                double y_2_0   = -4.0;
    131                 // 
    132                 // Y_1  (t)    = F[X_1(t)] 
     131                //
     132                // Y_1  (t)    = F[X_1(t)]
    133133                //             = abs(0.5 + 2t + 3t^2) + abs( 2*(-1.0 + 3t + 4t^2 ) )
    134134                double y_1_1   = -4.0;
     
    143143        }
    144144        // ---------------------------------------------------------------------
    145         // AddpvOp 
     145        // AddpvOp
    146146        bool addpv_op(void)
    147147        {       bool ok = true;
    148148                double eps = 10. * std::numeric_limits<double>::epsilon();
    149149                size_t j;
    150        
     150
    151151                // domain space vector
    152152                size_t n = 1;
    153153                CPPAD_TESTVECTOR(AD<double>) ax(n);
    154                 ax[0] = 0.5; 
    155        
    156                 // declare independent variables and starting recording
    157                 CppAD::Independent(ax);
    158        
     154                ax[0] = 0.5;
     155
     156                // declare independent variables and starting recording
     157                CppAD::Independent(ax);
     158
    159159                // range space vector
    160160                size_t m = 1;
    161161                CPPAD_TESTVECTOR(AD<double>) ay(m);
    162162                ay[0] = 2.0 + ax[0];
    163        
    164                 // create f: x -> y and stop tape recording
    165                 CppAD::ADFun<double> f(ax, ay);
    166        
    167                 // first order Taylor coefficients
    168                 size_t r = 2, ell;
    169                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    170                 for(ell = 0; ell < r; ell++)
    171                 {       for(j = 0; j < n; j++)
    172                                 x1[ r * j + ell ] = double(j + ell + 1);
    173                 }
    174                 y1  = f.Forward(1, r, x1);
    175                 ok &= y1.size() == r*m;
    176                
     163
     164                // create f: x -> y and stop tape recording
     165                CppAD::ADFun<double> f(ax, ay);
     166
     167                // first order Taylor coefficients
     168                size_t r = 2, ell;
     169                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     170                for(ell = 0; ell < r; ell++)
     171                {       for(j = 0; j < n; j++)
     172                                x1[ r * j + ell ] = double(j + ell + 1);
     173                }
     174                y1  = f.Forward(1, r, x1);
     175                ok &= y1.size() == r*m;
     176
    177177                // secondorder Taylor coefficients
    178178                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    183183                y2  = f.Forward(2, r, x2);
    184184                ok &= y2.size() == r*m;
    185                 // 
    186                 // Y_0 (t)     = F[X_0(t)] 
     185                //
     186                // Y_0 (t)     = F[X_0(t)]
    187187                //             =  2.0 + (0.5 + 1t + 3t^2)
    188188                double y_1_0   = 1.0;
    189189                double y_2_0   = 3.0;
    190                 // 
    191                 // Y_1 (t)     = F[X_1(t)] 
     190                //
     191                // Y_1 (t)     = F[X_1(t)]
    192192                //             =  2.0 + (0.5 + 2t + 4t^2)
    193193                double y_1_1   = 2.0;
     
    202202        }
    203203        // ---------------------------------------------------------------------
    204         // AddvvOp 
     204        // AddvvOp
    205205        bool addvv_op(void)
    206206        {       bool ok = true;
    207207                double eps = 10. * std::numeric_limits<double>::epsilon();
    208208                size_t j;
    209        
     209
    210210                // domain space vector
    211211                size_t n = 2;
    212212                CPPAD_TESTVECTOR(AD<double>) ax(n);
    213                 ax[0] = 0.5; 
     213                ax[0] = 0.5;
    214214                ax[1] = 2.0;
    215        
    216                 // declare independent variables and starting recording
    217                 CppAD::Independent(ax);
    218        
     215
     216                // declare independent variables and starting recording
     217                CppAD::Independent(ax);
     218
    219219                // range space vector
    220220                size_t m = 1;
    221221                CPPAD_TESTVECTOR(AD<double>) ay(m);
    222222                ay[0] = ax[0] + ax[1];
    223        
    224                 // create f: x -> y and stop tape recording
    225                 CppAD::ADFun<double> f(ax, ay);
    226        
    227                 // first order Taylor coefficients
    228                 size_t r = 2, ell;
    229                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    230                 for(ell = 0; ell < r; ell++)
    231                 {       for(j = 0; j < n; j++)
    232                                 x1[ r * j + ell ] = double(j + ell + 1);
    233                 }
    234                 y1  = f.Forward(1, r, x1);
    235                 ok &= y1.size() == r*m;
    236                
    237                 // secondorder Taylor coefficients
    238                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    239                 for(ell = 0; ell < r; ell++)
    240                 {       for(j = 0; j < n; j++)
    241                                 x2[ r * j + ell ] = double(j + ell + 2);
    242                 }
    243                 y2  = f.Forward(2, r, x2);
    244                 ok &= y2.size() == r*m;
    245                 // 
    246                 // Y_0 (t)     = F[X_0(t)] 
     223
     224                // create f: x -> y and stop tape recording
     225                CppAD::ADFun<double> f(ax, ay);
     226
     227                // first order Taylor coefficients
     228                size_t r = 2, ell;
     229                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     230                for(ell = 0; ell < r; ell++)
     231                {       for(j = 0; j < n; j++)
     232                                x1[ r * j + ell ] = double(j + ell + 1);
     233                }
     234                y1  = f.Forward(1, r, x1);
     235                ok &= y1.size() == r*m;
     236
     237                // secondorder Taylor coefficients
     238                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     239                for(ell = 0; ell < r; ell++)
     240                {       for(j = 0; j < n; j++)
     241                                x2[ r * j + ell ] = double(j + ell + 2);
     242                }
     243                y2  = f.Forward(2, r, x2);
     244                ok &= y2.size() == r*m;
     245                //
     246                // Y_0 (t)     = F[X_0(t)]
    247247                //             =  (0.5 + 1t + 2t^2) + (2.0 + 2t + 3t^2)
    248248                double y_1_0   = 1.0 + 2.0;
    249249                double y_2_0   = 2.0 + 3.0;
    250                 // 
    251                 // Y_1 (t)     = F[X_1(t)] 
     250                //
     251                // Y_1 (t)     = F[X_1(t)]
    252252                //             =  (2.0 + 2t + 3t^2) + (2.0 + 3t + 4t^2)
    253253                double y_1_1   = 2.0 + 3.0;
     
    262262        }
    263263        // ---------------------------------------------------------------------
    264         // CosOp 
     264        // CosOp
    265265        bool cos_op(void)
    266266        {       bool ok = true;
     
    268268                size_t j;
    269269
    270        
     270
    271271                // domain space vector
    272272                size_t n = 1;
    273273                CPPAD_TESTVECTOR(AD<double>) ax(n);
    274                 ax[0] = 0.5; 
    275        
    276                 // declare independent variables and starting recording
    277                 CppAD::Independent(ax);
    278        
     274                ax[0] = 0.5;
     275
     276                // declare independent variables and starting recording
     277                CppAD::Independent(ax);
     278
    279279                // range space vector
    280280                size_t m = 1;
    281281                CPPAD_TESTVECTOR(AD<double>) ay(m);
    282282                ay[0] = cos( ax[0] );
    283        
    284                 // create f: x -> y and stop tape recording
    285                 CppAD::ADFun<double> f(ax, ay);
    286        
    287                 // first order Taylor coefficients
    288                 size_t r = 2, ell;
    289                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    290                 for(ell = 0; ell < r; ell++)
    291                 {       for(j = 0; j < n; j++)
    292                                 x1[ r * j + ell ] = double(j + ell + 1);
    293                 }
    294                 y1  = f.Forward(1, r, x1);
    295                 ok &= y1.size() == r*m;
    296                
    297                 // secondorder Taylor coefficients
    298                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    299                 for(ell = 0; ell < r; ell++)
    300                 {       for(j = 0; j < n; j++)
    301                                 x2[ r * j + ell ] = double(j + ell + 2);
    302                 }
    303                 y2  = f.Forward(2, r, x2);
    304                 ok &= y2.size() == r*m;
    305                 // 
    306                 // Y_0  (t)    = F[X_0(t)] 
     283
     284                // create f: x -> y and stop tape recording
     285                CppAD::ADFun<double> f(ax, ay);
     286
     287                // first order Taylor coefficients
     288                size_t r = 2, ell;
     289                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     290                for(ell = 0; ell < r; ell++)
     291                {       for(j = 0; j < n; j++)
     292                                x1[ r * j + ell ] = double(j + ell + 1);
     293                }
     294                y1  = f.Forward(1, r, x1);
     295                ok &= y1.size() == r*m;
     296
     297                // secondorder Taylor coefficients
     298                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     299                for(ell = 0; ell < r; ell++)
     300                {       for(j = 0; j < n; j++)
     301                                x2[ r * j + ell ] = double(j + ell + 2);
     302                }
     303                y2  = f.Forward(2, r, x2);
     304                ok &= y2.size() == r*m;
     305                //
     306                // Y_0  (t)    = F[X_0(t)]
    307307                //             =  cos( 0.5 + 1t + 2t^2 )
    308308                // Y_0' (t)    = -sin( 0.5 + 1t + 2t^2) * (1 + 4t)
    309309                double y_1_0   = - sin(0.5);
    310310                double y_2_0   = - ( cos(0.5) + 4.0 * sin(0.5) ) / 2.0;
    311                 // 
    312                 // Y_1  (t)    = F[X_1(t)] 
     311                //
     312                // Y_1  (t)    = F[X_1(t)]
    313313                //             =  cos( 0.5 + 2t + 3t^2 )
    314314                // Y_1' (t)    = -sin( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    324324        }
    325325        // ---------------------------------------------------------------------
    326         // CoshOp 
     326        // CoshOp
    327327        bool cosh_op(void)
    328328        {       bool ok = true;
     
    330330                size_t j;
    331331
    332        
     332
    333333                // domain space vector
    334334                size_t n = 1;
    335335                CPPAD_TESTVECTOR(AD<double>) ax(n);
    336                 ax[0] = 0.5; 
    337        
    338                 // declare independent variables and starting recording
    339                 CppAD::Independent(ax);
    340        
     336                ax[0] = 0.5;
     337
     338                // declare independent variables and starting recording
     339                CppAD::Independent(ax);
     340
    341341                // range space vector
    342342                size_t m = 1;
    343343                CPPAD_TESTVECTOR(AD<double>) ay(m);
    344344                ay[0] = cosh( ax[0] );
    345        
    346                 // create f: x -> y and stop tape recording
    347                 CppAD::ADFun<double> f(ax, ay);
    348        
    349                 // first order Taylor coefficients
    350                 size_t r = 2, ell;
    351                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    352                 for(ell = 0; ell < r; ell++)
    353                 {       for(j = 0; j < n; j++)
    354                                 x1[ r * j + ell ] = double(j + ell + 1);
    355                 }
    356                 y1  = f.Forward(1, r, x1);
    357                 ok &= y1.size() == r*m;
    358                
    359                 // secondorder Taylor coefficients
    360                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    361                 for(ell = 0; ell < r; ell++)
    362                 {       for(j = 0; j < n; j++)
    363                                 x2[ r * j + ell ] = double(j + ell + 2);
    364                 }
    365                 y2  = f.Forward(2, r, x2);
    366                 ok &= y2.size() == r*m;
    367                 // 
    368                 // Y_0  (t)    = F[X_0(t)] 
     345
     346                // create f: x -> y and stop tape recording
     347                CppAD::ADFun<double> f(ax, ay);
     348
     349                // first order Taylor coefficients
     350                size_t r = 2, ell;
     351                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     352                for(ell = 0; ell < r; ell++)
     353                {       for(j = 0; j < n; j++)
     354                                x1[ r * j + ell ] = double(j + ell + 1);
     355                }
     356                y1  = f.Forward(1, r, x1);
     357                ok &= y1.size() == r*m;
     358
     359                // secondorder Taylor coefficients
     360                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     361                for(ell = 0; ell < r; ell++)
     362                {       for(j = 0; j < n; j++)
     363                                x2[ r * j + ell ] = double(j + ell + 2);
     364                }
     365                y2  = f.Forward(2, r, x2);
     366                ok &= y2.size() == r*m;
     367                //
     368                // Y_0  (t)    = F[X_0(t)]
    369369                //             = cosh( 0.5 + 1t + 2t^2 )
    370370                // Y_0' (t)    = sinh( 0.5 + 1t + 2t^2) * (1 + 4t)
    371371                double y_1_0   = sinh(0.5);
    372372                double y_2_0   = ( sinh(0.5) * 4.0 + cosh(0.5) ) / 2.0;
    373                 // 
    374                 // Y_1  (t)    = F[X_1(t)] 
     373                //
     374                // Y_1  (t)    = F[X_1(t)]
    375375                //             = cosh( 0.5 + 2t + 3t^2 )
    376376                // Y_1' (t)    = sinh( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    391391                double eps = 10. * std::numeric_limits<double>::epsilon();
    392392                size_t j;
    393        
     393
    394394                // domain space vector
    395395                size_t n = 4;
     
    397397                for(j = 0; j < n; j++)
    398398                        ax[j] = double(j);
    399        
    400                 // declare independent variables and starting recording
    401                 CppAD::Independent(ax);
    402        
     399
     400                // declare independent variables and starting recording
     401                CppAD::Independent(ax);
     402
    403403                // range space vector
    404404                size_t m = 2;
     
    409409                // create f: x -> y and stop tape recording
    410410                CppAD::ADFun<double> f(ax, ay);
    411        
    412                 // first order Taylor coefficients
    413                 size_t r = 2, ell;
    414                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    415                 for(ell = 0; ell < r; ell++)
    416                 {       for(j = 0; j < n; j++)
    417                                 x1[ r * j + ell ] = double(j + ell + 1);
    418                 }
    419                 y1  = f.Forward(1, r, x1);
    420                 ok &= y1.size() == r*m;
    421                
    422                 // secondorder Taylor coefficients
    423                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    424                 for(ell = 0; ell < r; ell++)
    425                 {       for(j = 0; j < n; j++)
    426                                 x2[ r * j + ell ] = double(j + ell + 2);
    427                 }
    428                 y2  = f.Forward(2, r, x2);
    429                 ok &= y2.size() == r*m;
    430                 // 
     411
     412                // first order Taylor coefficients
     413                size_t r = 2, ell;
     414                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     415                for(ell = 0; ell < r; ell++)
     416                {       for(j = 0; j < n; j++)
     417                                x1[ r * j + ell ] = double(j + ell + 1);
     418                }
     419                y1  = f.Forward(1, r, x1);
     420                ok &= y1.size() == r*m;
     421
     422                // secondorder Taylor coefficients
     423                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     424                for(ell = 0; ell < r; ell++)
     425                {       for(j = 0; j < n; j++)
     426                                x2[ r * j + ell ] = double(j + ell + 2);
     427                }
     428                y2  = f.Forward(2, r, x2);
     429                ok &= y2.size() == r*m;
     430                //
    431431                // Y0_0 (t)     = X2_0(t)
    432432                //             =  2.0 + 3t + 4t^2
    433433                double y0_1_0  = 3.0;
    434434                double y0_2_0  = 4.0;
    435                 // 
     435                //
    436436                // Y1_0 (t)     = X3_0(t)
    437437                //             =  3.0 + 4t + 5t^2
    438438                double y1_1_0  = 4.0;
    439439                double y1_2_0  = 5.0;
    440                 // 
     440                //
    441441                // Y0_1 (t)     = X2_1(t)
    442442                //             =  2.0 + 4t + 5t^2
    443443                double y0_1_1  = 4.0;
    444444                double y0_2_1  = 5.0;
    445                 // 
     445                //
    446446                // Y1_1 (t)     = X3_0(t)
    447447                //             =  3.0 + 5t + 6t^2
     
    463463
    464464        // ---------------------------------------------------------------------
    465         // CSumOp 
     465        // CSumOp
    466466        bool csum_op(void)
    467467        {       bool ok = true;
    468468                double eps = 10. * std::numeric_limits<double>::epsilon();
    469469                size_t j;
    470        
     470
    471471                // domain space vector
    472472                size_t n = 3;
     
    474474                for(j = 0; j < n; j++)
    475475                        ax[j] = double(j);
    476        
    477                 // declare independent variables and starting recording
    478                 CppAD::Independent(ax);
    479        
     476
     477                // declare independent variables and starting recording
     478                CppAD::Independent(ax);
     479
    480480                // range space vector
    481481                size_t m = 1;
     
    484484                for(j = 0; j < n; j++)
    485485                        ay[0] += ax[j];
    486        
     486
    487487                // create f: x -> y and stop tape recording
    488488                CppAD::ADFun<double> f(ax, ay);
     
    491491                f.optimize();
    492492
    493                 // zero order 
     493                // zero order
    494494                CPPAD_TESTVECTOR(double) x0(n);
    495495                for(j = 0; j < n; j++)
    496496                        x0[j] = double(j);
    497497                f.Forward(0, x0);
    498        
    499                 // first order Taylor coefficients
    500                 size_t r = 2, ell;
    501                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    502                 for(ell = 0; ell < r; ell++)
    503                 {       for(j = 0; j < n; j++)
    504                                 x1[ r * j + ell ] = double(j + ell + 1);
    505                 }
    506                 y1  = f.Forward(1, r, x1);
    507                 ok &= y1.size() == r*m;
    508                
     498
     499                // first order Taylor coefficients
     500                size_t r = 2, ell;
     501                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     502                for(ell = 0; ell < r; ell++)
     503                {       for(j = 0; j < n; j++)
     504                                x1[ r * j + ell ] = double(j + ell + 1);
     505                }
     506                y1  = f.Forward(1, r, x1);
     507                ok &= y1.size() == r*m;
     508
    509509                // secondorder Taylor coefficients
    510510                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    515515                y2  = f.Forward(2, r, x2);
    516516                ok &= y2.size() == r*m;
    517                 // 
     517                //
    518518                double check = 0.0;
    519519                for(j = 0; j < n; j++)
     
    549549                double eps = 10. * std::numeric_limits<double>::epsilon();
    550550                size_t j;
    551        
     551
    552552                // domain space vector
    553553                size_t n = 1;
    554554                CPPAD_TESTVECTOR(AD<double>) ax(n);
    555                 ax[0] = 0.5; 
    556        
    557                 // declare independent variables and starting recording
    558                 CppAD::Independent(ax);
    559        
     555                ax[0] = 0.5;
     556
     557                // declare independent variables and starting recording
     558                CppAD::Independent(ax);
     559
    560560                // range space vector
    561561                size_t m = 1;
    562562                CPPAD_TESTVECTOR(AD<double>) ay(m);
    563563                ay[0] = round_off( ax[0] ) + ax[0];
    564        
     564
    565565                // create f: x -> y and stop tape recording
    566566                CppAD::ADFun<double> f(ax, ay);
     
    571571                y0  = f.Forward(0, x0);
    572572                ok &= y0.size() == m;
    573                 ok &= NearEqual(y0[0], round_off(x0[0]) + x0[0], eps, eps); 
    574        
    575                 // first order Taylor coefficients
    576                 size_t r = 2, ell;
    577                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    578                 for(ell = 0; ell < r; ell++)
    579                 {       for(j = 0; j < n; j++)
    580                                 x1[ r * j + ell ] = double(j + ell + 1);
    581                 }
    582                 y1  = f.Forward(1, r, x1);
    583                 ok &= y1.size() == r*m;
    584                
    585                 // secondorder Taylor coefficients
    586                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    587                 for(ell = 0; ell < r; ell++)
    588                 {       for(j = 0; j < n; j++)
    589                                 x2[ r * j + ell ] = double(j + ell + 2);
    590                 }
    591                 y2  = f.Forward(2, r, x2);
    592                 ok &= y2.size() == r*m;
    593                 // 
    594                 // 
    595                 // Y_0 (t)     = F[X_0(t)] 
    596                 //             =  2.0 + (2.2 + 1t + 2t^2) 
     573                ok &= NearEqual(y0[0], round_off(x0[0]) + x0[0], eps, eps);
     574
     575                // first order Taylor coefficients
     576                size_t r = 2, ell;
     577                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     578                for(ell = 0; ell < r; ell++)
     579                {       for(j = 0; j < n; j++)
     580                                x1[ r * j + ell ] = double(j + ell + 1);
     581                }
     582                y1  = f.Forward(1, r, x1);
     583                ok &= y1.size() == r*m;
     584
     585                // secondorder Taylor coefficients
     586                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     587                for(ell = 0; ell < r; ell++)
     588                {       for(j = 0; j < n; j++)
     589                                x2[ r * j + ell ] = double(j + ell + 2);
     590                }
     591                y2  = f.Forward(2, r, x2);
     592                ok &= y2.size() == r*m;
     593                //
     594                //
     595                // Y_0 (t)     = F[X_0(t)]
     596                //             =  2.0 + (2.2 + 1t + 2t^2)
    597597                double y_1_0   = 1.0;
    598598                double y_2_0   = 2.0;
    599                 // 
    600                 // Y_1 (t)     = F[X_1(t)] 
    601                 //             =  2.0 + (2.2 + 2t + 3t^2) 
     599                //
     600                // Y_1 (t)     = F[X_1(t)]
     601                //             =  2.0 + (2.2 + 2t + 3t^2)
    602602                double y_1_1   = 2.0;
    603603                double y_2_1   = 3.0;
     
    616616                double eps = 10. * std::numeric_limits<double>::epsilon();
    617617                size_t j;
    618        
     618
    619619                // domain space vector
    620620                size_t n = 1;
    621621                CPPAD_TESTVECTOR(AD<double>) ax(n);
    622                 ax[0] = 0.5; 
    623        
    624                 // declare independent variables and starting recording
    625                 CppAD::Independent(ax);
    626        
     622                ax[0] = 0.5;
     623
     624                // declare independent variables and starting recording
     625                CppAD::Independent(ax);
     626
    627627                // range space vector
    628628                size_t m = 1;
     
    632632                // create f: x -> y and stop tape recording
    633633                CppAD::ADFun<double> f(ax, ay);
    634        
    635                 // first order Taylor coefficients
    636                 size_t r = 2, ell;
    637                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    638                 for(ell = 0; ell < r; ell++)
    639                 {       for(j = 0; j < n; j++)
    640                                 x1[ r * j + ell ] = double(j + ell + 1);
    641                 }
    642                 y1  = f.Forward(1, r, x1);
    643                 ok &= y1.size() == r*m;
    644                
    645                 // secondorder Taylor coefficients
    646                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    647                 for(ell = 0; ell < r; ell++)
    648                 {       for(j = 0; j < n; j++)
    649                                 x2[ r * j + ell ] = double(j + ell + 2);
    650                 }
    651                 y2  = f.Forward(2, r, x2);
    652                 ok &= y2.size() == r*m;
    653                 // 
    654                 // Y_0 (t)     = F[X_0(t)] 
     634
     635                // first order Taylor coefficients
     636                size_t r = 2, ell;
     637                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     638                for(ell = 0; ell < r; ell++)
     639                {       for(j = 0; j < n; j++)
     640                                x1[ r * j + ell ] = double(j + ell + 1);
     641                }
     642                y1  = f.Forward(1, r, x1);
     643                ok &= y1.size() == r*m;
     644
     645                // secondorder Taylor coefficients
     646                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     647                for(ell = 0; ell < r; ell++)
     648                {       for(j = 0; j < n; j++)
     649                                x2[ r * j + ell ] = double(j + ell + 2);
     650                }
     651                y2  = f.Forward(2, r, x2);
     652                ok &= y2.size() == r*m;
     653                //
     654                // Y_0 (t)     = F[X_0(t)]
    655655                //             = 2.0 * (0.5 + 1t + 2t^2)
    656656                double y_1_0   = 2.0;
    657657                double y_2_0   = 4.0;
    658                 // 
    659                 // Y_1 (t)     = F[X_1(t)] 
     658                //
     659                // Y_1 (t)     = F[X_1(t)]
    660660                //             = 2.0 * (0.5 + 2t + 3t^2)/2.0
    661661                double y_1_1   = 4.0;
     
    670670        }
    671671        // ---------------------------------------------------------------------
    672         // DivvpOp 
     672        // DivvpOp
    673673        bool divvp_op(void)
    674674        {       bool ok = true;
    675675                double eps = 10. * std::numeric_limits<double>::epsilon();
    676676                size_t j;
    677        
     677
    678678                // domain space vector
    679679                size_t n = 1;
    680680                CPPAD_TESTVECTOR(AD<double>) ax(n);
    681                 ax[0] = 0.5; 
    682        
    683                 // declare independent variables and starting recording
    684                 CppAD::Independent(ax);
    685        
     681                ax[0] = 0.5;
     682
     683                // declare independent variables and starting recording
     684                CppAD::Independent(ax);
     685
    686686                // range space vector
    687687                size_t m = 1;
     
    691691                // create f: x -> y and stop tape recording
    692692                CppAD::ADFun<double> f(ax, ay);
    693        
    694                 // first order Taylor coefficients
    695                 size_t r = 2, ell;
    696                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    697                 for(ell = 0; ell < r; ell++)
    698                 {       for(j = 0; j < n; j++)
    699                                 x1[ r * j + ell ] = double(j + ell + 1);
    700                 }
    701                 y1  = f.Forward(1, r, x1);
    702                 ok &= y1.size() == r*m;
    703                
     693
     694                // first order Taylor coefficients
     695                size_t r = 2, ell;
     696                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     697                for(ell = 0; ell < r; ell++)
     698                {       for(j = 0; j < n; j++)
     699                                x1[ r * j + ell ] = double(j + ell + 1);
     700                }
     701                y1  = f.Forward(1, r, x1);
     702                ok &= y1.size() == r*m;
     703
    704704                // secondorder Taylor coefficients
    705705                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    710710                y2  = f.Forward(2, r, x2);
    711711                ok &= y2.size() == r*m;
    712                 // 
    713                 // Y_0 (t)     = F[X_0(t)] 
     712                //
     713                // Y_0 (t)     = F[X_0(t)]
    714714                //             =  (0.5 + 1t + 3t^2)/2.0
    715715                double y_1_0   = 1.0 / 2.0;
    716716                double y_2_0   = 3.0 / 2.0;
    717                 // 
    718                 // Y_1 (t)     = F[X_1(t)] 
     717                //
     718                // Y_1 (t)     = F[X_1(t)]
    719719                //             =  (0.5 + 2t + 4t^2)/2.0
    720720                double y_1_1   = 2.0 / 2.0;
     
    729729        }
    730730        // ---------------------------------------------------------------------
    731         // ExpOp 
     731        // ExpOp
    732732        bool exp_op(void)
    733733        {       bool ok = true;
    734734                double eps = 10. * std::numeric_limits<double>::epsilon();
    735735                size_t j;
    736        
     736
    737737                // domain space vector
    738738                size_t n = 1;
    739739                CPPAD_TESTVECTOR(AD<double>) ax(n);
    740                 ax[0] = 0.5; 
    741        
    742                 // declare independent variables and starting recording
    743                 CppAD::Independent(ax);
    744        
     740                ax[0] = 0.5;
     741
     742                // declare independent variables and starting recording
     743                CppAD::Independent(ax);
     744
    745745                // range space vector
    746746                size_t m = 1;
    747747                CPPAD_TESTVECTOR(AD<double>) ay(m);
    748748                ay[0] = exp( ax[0] );
    749        
    750                 // create f: x -> y and stop tape recording
    751                 CppAD::ADFun<double> f(ax, ay);
    752        
    753                 // first order Taylor coefficients
    754                 size_t r = 2, ell;
    755                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    756                 for(ell = 0; ell < r; ell++)
    757                 {       for(j = 0; j < n; j++)
    758                                 x1[ r * j + ell ] = double(j + ell + 1);
    759                 }
    760                 y1  = f.Forward(1, r, x1);
    761                 ok &= y1.size() == r*m;
    762                
    763                 // secondorder Taylor coefficients
    764                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    765                 for(ell = 0; ell < r; ell++)
    766                 {       for(j = 0; j < n; j++)
    767                                 x2[ r * j + ell ] = double(j + ell + 2);
    768                 }
    769                 y2  = f.Forward(2, r, x2);
    770                 ok &= y2.size() == r*m;
    771                 // 
    772                 // Y_0  (t)    = F[X_0(t)] 
     749
     750                // create f: x -> y and stop tape recording
     751                CppAD::ADFun<double> f(ax, ay);
     752
     753                // first order Taylor coefficients
     754                size_t r = 2, ell;
     755                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     756                for(ell = 0; ell < r; ell++)
     757                {       for(j = 0; j < n; j++)
     758                                x1[ r * j + ell ] = double(j + ell + 1);
     759                }
     760                y1  = f.Forward(1, r, x1);
     761                ok &= y1.size() == r*m;
     762
     763                // secondorder Taylor coefficients
     764                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     765                for(ell = 0; ell < r; ell++)
     766                {       for(j = 0; j < n; j++)
     767                                x2[ r * j + ell ] = double(j + ell + 2);
     768                }
     769                y2  = f.Forward(2, r, x2);
     770                ok &= y2.size() == r*m;
     771                //
     772                // Y_0  (t)    = F[X_0(t)]
    773773                //             =  exp(0.5 + 1t + 2t^2)
    774774                // Y_0' (t)    =  exp(0.5 + 1t + 2t^2)*(1 + 4t)
    775775                double y_1_0   = exp(0.5);
    776776                double y_2_0   = ( exp(0.5)*4.0 + exp(0.5) ) / 2.0;
    777                 // 
    778                 // Y_1  (t)    = F[X_1(t)] 
     777                //
     778                // Y_1  (t)    = F[X_1(t)]
    779779                //             =  exp(0.5 + 2t + 3t^2)
    780780                // Y_1' (t)    =  exp(0.5 + 2t + 3t^2)*(2 + 6t)
     
    795795                double eps = 10. * std::numeric_limits<double>::epsilon();
    796796                size_t j;
    797        
     797
    798798                // domain space vector
    799799                size_t n = 2;
    800800                CPPAD_TESTVECTOR(AD<double>) ax(n);
    801                 ax[0] = 0.0; 
     801                ax[0] = 0.0;
    802802                ax[1] = 1.0;
    803        
     803
    804804                // declare independent variables and starting recording
    805805                CppAD::Independent(ax);
     
    810810                avec[ AD<double>(1) ]    = ax[1];  // store a variable
    811811                avec[ AD<double>(2) ]    = 5.0;    // store a parameter
    812        
    813                 // range space vector 
     812
     813                // range space vector
    814814                size_t m = 2;
    815815                CPPAD_TESTVECTOR(AD<double>) ay(m);
    816816                ay[0] = avec[ AD<double>(0) ];     // load using parameter index
    817817                ay[1] = avec[ ax[0] ];             // load using variable index
    818        
     818
    819819                // create f: x -> y and stop tape recording
    820820                CppAD::ADFun<double> f(ax, ay);
     
    829829                ok &= y0[0] == x0[0];
    830830                // y[1] = avec[ x[0] ] = avec[2] = 5.0
    831                 ok &= y0[1] == 5.0; 
    832 
    833                 // first order Taylor coefficients
    834                 size_t r = 2, ell;
    835                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    836                 for(ell = 0; ell < r; ell++)
    837                 {       for(j = 0; j < n; j++)
    838                                 x1[ r * j + ell ] = double(j + ell + 1);
    839                 }
    840                 y1  = f.Forward(1, r, x1);
    841                 ok &= y1.size() == r*m;
    842                
    843                 // secondorder Taylor coefficients
    844                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    845                 for(ell = 0; ell < r; ell++)
    846                 {       for(j = 0; j < n; j++)
    847                                 x2[ r * j + ell ] = double(j + ell + 2);
    848                 }
    849                 y2  = f.Forward(2, r, x2);
    850                 ok &= y2.size() == r*m;
    851                 // 
     831                ok &= y0[1] == 5.0;
     832
     833                // first order Taylor coefficients
     834                size_t r = 2, ell;
     835                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     836                for(ell = 0; ell < r; ell++)
     837                {       for(j = 0; j < n; j++)
     838                                x1[ r * j + ell ] = double(j + ell + 1);
     839                }
     840                y1  = f.Forward(1, r, x1);
     841                ok &= y1.size() == r*m;
     842
     843                // secondorder Taylor coefficients
     844                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     845                for(ell = 0; ell < r; ell++)
     846                {       for(j = 0; j < n; j++)
     847                                x2[ r * j + ell ] = double(j + ell + 2);
     848                }
     849                y2  = f.Forward(2, r, x2);
     850                ok &= y2.size() == r*m;
     851                //
    852852                // Y0_0 (t)    = 2.0 + 1t + 2t^2
    853853                double y0_1_0  = 1.0;
    854854                double y0_2_0  = 2.0;
    855                 // 
     855                //
    856856                // Y1_0 (t)    = 5.0
    857857                double y1_1_0  = 0.0;
    858858                double y1_2_0  = 0.0;
    859                 // 
     859                //
    860860                // Y0_1 (t)    = 2.0 + 2t + 3t^2
    861861                double y0_1_1  = 2.0;
    862862                double y0_2_1  = 3.0;
    863                 // 
     863                //
    864864                // Y1_1 (t)    = 5.0
    865865                double y1_1_1  = 0.0;
     
    878878                return ok;
    879879        }
    880        
    881         // ---------------------------------------------------------------------
    882         // MulpvOp 
     880
     881        // ---------------------------------------------------------------------
     882        // MulpvOp
    883883        bool mulpv_op(void)
    884884        {       bool ok = true;
    885885                double eps = 10. * std::numeric_limits<double>::epsilon();
    886886                size_t j;
    887        
     887
    888888                // domain space vector
    889889                size_t n = 1;
    890890                CPPAD_TESTVECTOR(AD<double>) ax(n);
    891                 ax[0] = 0.5; 
    892        
    893                 // declare independent variables and starting recording
    894                 CppAD::Independent(ax);
    895        
     891                ax[0] = 0.5;
     892
     893                // declare independent variables and starting recording
     894                CppAD::Independent(ax);
     895
    896896                // range space vector
    897897                size_t m = 1;
    898898                CPPAD_TESTVECTOR(AD<double>) ay(m);
    899899                ay[0] = 2.0 * ax[0];
    900        
    901                 // create f: x -> y and stop tape recording
    902                 CppAD::ADFun<double> f(ax, ay);
    903        
    904                 // first order Taylor coefficients
    905                 size_t r = 2, ell;
    906                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    907                 for(ell = 0; ell < r; ell++)
    908                 {       for(j = 0; j < n; j++)
    909                                 x1[ r * j + ell ] = double(j + ell + 1);
    910                 }
    911                 y1  = f.Forward(1, r, x1);
    912                 ok &= y1.size() == r*m;
    913                
     900
     901                // create f: x -> y and stop tape recording
     902                CppAD::ADFun<double> f(ax, ay);
     903
     904                // first order Taylor coefficients
     905                size_t r = 2, ell;
     906                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     907                for(ell = 0; ell < r; ell++)
     908                {       for(j = 0; j < n; j++)
     909                                x1[ r * j + ell ] = double(j + ell + 1);
     910                }
     911                y1  = f.Forward(1, r, x1);
     912                ok &= y1.size() == r*m;
     913
    914914                // secondorder Taylor coefficients
    915915                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    920920                y2  = f.Forward(2, r, x2);
    921921                ok &= y2.size() == r*m;
    922                 // 
    923                 // Y_0 (t)     = F[X_0(t)] 
     922                //
     923                // Y_0 (t)     = F[X_0(t)]
    924924                //             =  2.0 * (0.5 + 1t + 3t^2)
    925925                double y_1_0   = 2.0 * 1.0;
    926926                double y_2_0   = 2.0 * 3.0;
    927                 // 
    928                 // Y_1 (t)     = F[X_1(t)] 
     927                //
     928                // Y_1 (t)     = F[X_1(t)]
    929929                //             =  2.0 * (0.5 + 2t + 4t^2)
    930930                double y_1_1   = 2.0 * 2.0;
     
    992992                double eps = 10. * std::numeric_limits<double>::epsilon();
    993993                size_t j;
    994        
     994
    995995                // domain space vector
    996996                size_t n = 2;
    997997                CPPAD_TESTVECTOR(AD<double>) ax(n);
    998                 ax[0] = 0.5; 
     998                ax[0] = 0.5;
    999999                ax[1] = 2.0;
    1000        
    1001                 // declare independent variables and starting recording
    1002                 CppAD::Independent(ax);
    1003        
     1000
     1001                // declare independent variables and starting recording
     1002                CppAD::Independent(ax);
     1003
    10041004                // range space vector
    10051005                size_t m = 2;
     
    10071007                ay[0] = log( pow( exp(ax[0]) , ax[1] ) ) / ax[1] ;
    10081008                ay[1] = log( pow( exp(ax[0]) , ax[1] ) ) / ax[0] ;
    1009        
    1010                 // create f: x -> y and stop tape recording
    1011                 CppAD::ADFun<double> f(ax, ay);
    1012        
    1013                 // first order Taylor coefficients
    1014                 size_t r = 2, ell;
    1015                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1016                 for(ell = 0; ell < r; ell++)
    1017                 {       for(j = 0; j < n; j++)
    1018                                 x1[ r * j + ell ] = double(j + ell + 1);
    1019                 }
    1020                 y1  = f.Forward(1, r, x1);
    1021                 ok &= y1.size() == r*m;
    1022                
    1023                 // secondorder Taylor coefficients
    1024                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1025                 for(ell = 0; ell < r; ell++)
    1026                 {       for(j = 0; j < n; j++)
    1027                                 x2[ r * j + ell ] = double(j + ell + 2);
    1028                 }
    1029                 y2  = f.Forward(2, r, x2);
    1030                 ok &= y2.size() == r*m;
    1031                 // 
     1009
     1010                // create f: x -> y and stop tape recording
     1011                CppAD::ADFun<double> f(ax, ay);
     1012
     1013                // first order Taylor coefficients
     1014                size_t r = 2, ell;
     1015                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1016                for(ell = 0; ell < r; ell++)
     1017                {       for(j = 0; j < n; j++)
     1018                                x1[ r * j + ell ] = double(j + ell + 1);
     1019                }
     1020                y1  = f.Forward(1, r, x1);
     1021                ok &= y1.size() == r*m;
     1022
     1023                // secondorder Taylor coefficients
     1024                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1025                for(ell = 0; ell < r; ell++)
     1026                {       for(j = 0; j < n; j++)
     1027                                x2[ r * j + ell ] = double(j + ell + 2);
     1028                }
     1029                y2  = f.Forward(2, r, x2);
     1030                ok &= y2.size() == r*m;
     1031                //
    10321032                // Y0_0 (t)    = 0.5 + 1t + 2t^2
    10331033                double y0_1_0  = 1.0;
    10341034                double y0_2_0  = 2.0;
    1035                 // 
     1035                //
    10361036                // Y0_1 (t)    = 0.5 + 2t + 3t^2
    10371037                double y0_1_1  = 2.0;
    10381038                double y0_2_1  = 3.0;
    1039                 // 
     1039                //
    10401040                // Y1_0 (t)    = 2.0 + 2t + 3t^2
    10411041                double y1_1_0  = 2.0;
    10421042                double y1_2_0  = 3.0;
    1043                 // 
     1043                //
    10441044                // Y1_1 (t)    = 2.0 + 3t + 4t^2
    10451045                double y1_1_1  = 3.0;
     
    10641064                double eps = 10. * std::numeric_limits<double>::epsilon();
    10651065                size_t j;
    1066        
     1066
    10671067                // domain space vector
    10681068                size_t n = 1;
    10691069                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1070                 ax[0] = 0.5; 
    1071        
    1072                 // declare independent variables and starting recording
    1073                 CppAD::Independent(ax);
    1074        
     1070                ax[0] = 0.5;
     1071
     1072                // declare independent variables and starting recording
     1073                CppAD::Independent(ax);
     1074
    10751075                // range space vector
    10761076                size_t m = 1;
    10771077                CPPAD_TESTVECTOR(AD<double>) ay(m);
    10781078                ay[0] = sign( ax[0] ) * ax[0];
    1079        
     1079
    10801080                // create f: x -> y and stop tape recording
    10811081                CppAD::ADFun<double> f(ax, ay);
     
    10861086                y0  = f.Forward(0, x0);
    10871087                ok &= y0.size() == m;
    1088                 ok &= NearEqual(y0[0], CppAD::abs(x0[0]), eps, eps); 
    1089        
    1090                 // first order Taylor coefficients
    1091                 size_t r = 2, ell;
    1092                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1093                 for(ell = 0; ell < r; ell++)
    1094                 {       for(j = 0; j < n; j++)
    1095                                 x1[ r * j + ell ] = double(j + ell + 1);
    1096                 }
    1097                 y1  = f.Forward(1, r, x1);
    1098                 ok &= y1.size() == r*m;
    1099                
    1100                 // secondorder Taylor coefficients
    1101                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1102                 for(ell = 0; ell < r; ell++)
    1103                 {       for(j = 0; j < n; j++)
    1104                                 x2[ r * j + ell ] = double(j + ell + 2);
    1105                 }
    1106                 y2  = f.Forward(2, r, x2);
    1107                 ok &= y2.size() == r*m;
    1108                 // 
    1109                 // 
    1110                 // Y_0 (t)     = F[X_0(t)] 
    1111                 //             =  -(-3.0 + 1t + 2t^2) 
     1088                ok &= NearEqual(y0[0], CppAD::abs(x0[0]), eps, eps);
     1089
     1090                // first order Taylor coefficients
     1091                size_t r = 2, ell;
     1092                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1093                for(ell = 0; ell < r; ell++)
     1094                {       for(j = 0; j < n; j++)
     1095                                x1[ r * j + ell ] = double(j + ell + 1);
     1096                }
     1097                y1  = f.Forward(1, r, x1);
     1098                ok &= y1.size() == r*m;
     1099
     1100                // secondorder Taylor coefficients
     1101                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1102                for(ell = 0; ell < r; ell++)
     1103                {       for(j = 0; j < n; j++)
     1104                                x2[ r * j + ell ] = double(j + ell + 2);
     1105                }
     1106                y2  = f.Forward(2, r, x2);
     1107                ok &= y2.size() == r*m;
     1108                //
     1109                //
     1110                // Y_0 (t)     = F[X_0(t)]
     1111                //             =  -(-3.0 + 1t + 2t^2)
    11121112                double y_1_0   = -1.0;
    11131113                double y_2_0   = -2.0;
    1114                 // 
    1115                 // Y_1 (t)     = F[X_1(t)] 
    1116                 //             =  -(-3.0 + 2t + 3t^2) 
     1114                //
     1115                // Y_1 (t)     = F[X_1(t)]
     1116                //             =  -(-3.0 + 2t + 3t^2)
    11171117                double y_1_1   = -2.0;
    11181118                double y_2_1   = -3.0;
     
    11271127
    11281128        // ---------------------------------------------------------------------
    1129         // SinOp 
     1129        // SinOp
    11301130        bool sin_op(void)
    11311131        {       bool ok = true;
     
    11331133                size_t j;
    11341134
    1135        
     1135
    11361136                // domain space vector
    11371137                size_t n = 1;
    11381138                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1139                 ax[0] = 0.5; 
    1140        
    1141                 // declare independent variables and starting recording
    1142                 CppAD::Independent(ax);
    1143        
     1139                ax[0] = 0.5;
     1140
     1141                // declare independent variables and starting recording
     1142                CppAD::Independent(ax);
     1143
    11441144                // range space vector
    11451145                size_t m = 1;
    11461146                CPPAD_TESTVECTOR(AD<double>) ay(m);
    11471147                ay[0] = sin( ax[0] );
    1148        
    1149                 // create f: x -> y and stop tape recording
    1150                 CppAD::ADFun<double> f(ax, ay);
    1151        
    1152                 // first order Taylor coefficients
    1153                 size_t r = 2, ell;
    1154                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1155                 for(ell = 0; ell < r; ell++)
    1156                 {       for(j = 0; j < n; j++)
    1157                                 x1[ r * j + ell ] = double(j + ell + 1);
    1158                 }
    1159                 y1  = f.Forward(1, r, x1);
    1160                 ok &= y1.size() == r*m;
    1161                
    1162                 // secondorder Taylor coefficients
    1163                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1164                 for(ell = 0; ell < r; ell++)
    1165                 {       for(j = 0; j < n; j++)
    1166                                 x2[ r * j + ell ] = double(j + ell + 2);
    1167                 }
    1168                 y2  = f.Forward(2, r, x2);
    1169                 ok &= y2.size() == r*m;
    1170                 // 
    1171                 // Y_0  (t)    = F[X_0(t)] 
     1148
     1149                // create f: x -> y and stop tape recording
     1150                CppAD::ADFun<double> f(ax, ay);
     1151
     1152                // first order Taylor coefficients
     1153                size_t r = 2, ell;
     1154                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1155                for(ell = 0; ell < r; ell++)
     1156                {       for(j = 0; j < n; j++)
     1157                                x1[ r * j + ell ] = double(j + ell + 1);
     1158                }
     1159                y1  = f.Forward(1, r, x1);
     1160                ok &= y1.size() == r*m;
     1161
     1162                // secondorder Taylor coefficients
     1163                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1164                for(ell = 0; ell < r; ell++)
     1165                {       for(j = 0; j < n; j++)
     1166                                x2[ r * j + ell ] = double(j + ell + 2);
     1167                }
     1168                y2  = f.Forward(2, r, x2);
     1169                ok &= y2.size() == r*m;
     1170                //
     1171                // Y_0  (t)    = F[X_0(t)]
    11721172                //             = sin( 0.5 + 1t + 2t^2 )
    11731173                // Y_0' (t)    = cos( 0.5 + 1t + 2t^2) * (1 + 4t)
    11741174                double y_1_0   = cos(0.5);
    11751175                double y_2_0   = ( cos(0.5) * 4.0 - sin(0.5) ) / 2.0;
    1176                 // 
    1177                 // Y_1  (t)    = F[X_1(t)] 
     1176                //
     1177                // Y_1  (t)    = F[X_1(t)]
    11781178                //             = sin( 0.5 + 2t + 3t^2 )
    11791179                // Y_1' (t)    = cos( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    11891189        }
    11901190        // ---------------------------------------------------------------------
    1191         // SinhOp 
     1191        // SinhOp
    11921192        bool sinh_op(void)
    11931193        {       bool ok = true;
     
    11951195                size_t j;
    11961196
    1197        
     1197
    11981198                // domain space vector
    11991199                size_t n = 1;
    12001200                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1201                 ax[0] = 0.5; 
    1202        
    1203                 // declare independent variables and starting recording
    1204                 CppAD::Independent(ax);
    1205        
     1201                ax[0] = 0.5;
     1202
     1203                // declare independent variables and starting recording
     1204                CppAD::Independent(ax);
     1205
    12061206                // range space vector
    12071207                size_t m = 1;
    12081208                CPPAD_TESTVECTOR(AD<double>) ay(m);
    12091209                ay[0] = sinh( ax[0] );
    1210        
    1211                 // create f: x -> y and stop tape recording
    1212                 CppAD::ADFun<double> f(ax, ay);
    1213        
    1214                 // first order Taylor coefficients
    1215                 size_t r = 2, ell;
    1216                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1217                 for(ell = 0; ell < r; ell++)
    1218                 {       for(j = 0; j < n; j++)
    1219                                 x1[ r * j + ell ] = double(j + ell + 1);
    1220                 }
    1221                 y1  = f.Forward(1, r, x1);
    1222                 ok &= y1.size() == r*m;
    1223                
    1224                 // secondorder Taylor coefficients
    1225                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1226                 for(ell = 0; ell < r; ell++)
    1227                 {       for(j = 0; j < n; j++)
    1228                                 x2[ r * j + ell ] = double(j + ell + 2);
    1229                 }
    1230                 y2  = f.Forward(2, r, x2);
    1231                 ok &= y2.size() == r*m;
    1232                 // 
    1233                 // Y_0  (t)    = F[X_0(t)] 
     1210
     1211                // create f: x -> y and stop tape recording
     1212                CppAD::ADFun<double> f(ax, ay);
     1213
     1214                // first order Taylor coefficients
     1215                size_t r = 2, ell;
     1216                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1217                for(ell = 0; ell < r; ell++)
     1218                {       for(j = 0; j < n; j++)
     1219                                x1[ r * j + ell ] = double(j + ell + 1);
     1220                }
     1221                y1  = f.Forward(1, r, x1);
     1222                ok &= y1.size() == r*m;
     1223
     1224                // secondorder Taylor coefficients
     1225                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1226                for(ell = 0; ell < r; ell++)
     1227                {       for(j = 0; j < n; j++)
     1228                                x2[ r * j + ell ] = double(j + ell + 2);
     1229                }
     1230                y2  = f.Forward(2, r, x2);
     1231                ok &= y2.size() == r*m;
     1232                //
     1233                // Y_0  (t)    = F[X_0(t)]
    12341234                //             = sinh( 0.5 + 1t + 2t^2 )
    12351235                // Y_0' (t)    = cosh( 0.5 + 1t + 2t^2) * (1 + 4t)
    12361236                double y_1_0   = cosh(0.5);
    12371237                double y_2_0   = ( cosh(0.5) * 4.0 + sinh(0.5) ) / 2.0;
    1238                 // 
    1239                 // Y_1  (t)    = F[X_1(t)] 
     1238                //
     1239                // Y_1  (t)    = F[X_1(t)]
    12401240                //             = sinh( 0.5 + 2t + 3t^2 )
    12411241                // Y_1' (t)    = cosh( 0.5 + 2t + 3t^2) * (2 + 6t)
     
    12511251        }
    12521252        // ---------------------------------------------------------------------
    1253         // SubpvOp 
     1253        // SubpvOp
    12541254        bool subpv_op(void)
    12551255        {       bool ok = true;
    12561256                double eps = 10. * std::numeric_limits<double>::epsilon();
    12571257                size_t j;
    1258        
     1258
    12591259                // domain space vector
    12601260                size_t n = 1;
    12611261                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1262                 ax[0] = 0.5; 
    1263        
    1264                 // declare independent variables and starting recording
    1265                 CppAD::Independent(ax);
    1266        
     1262                ax[0] = 0.5;
     1263
     1264                // declare independent variables and starting recording
     1265                CppAD::Independent(ax);
     1266
    12671267                // range space vector
    12681268                size_t m = 1;
    12691269                CPPAD_TESTVECTOR(AD<double>) ay(m);
    12701270                ay[0] = 2.0 - ax[0];
    1271        
    1272                 // create f: x -> y and stop tape recording
    1273                 CppAD::ADFun<double> f(ax, ay);
    1274        
    1275                 // first order Taylor coefficients
    1276                 size_t r = 2, ell;
    1277                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1278                 for(ell = 0; ell < r; ell++)
    1279                 {       for(j = 0; j < n; j++)
    1280                                 x1[ r * j + ell ] = double(j + ell + 1);
    1281                 }
    1282                 y1  = f.Forward(1, r, x1);
    1283                 ok &= y1.size() == r*m;
    1284                
     1271
     1272                // create f: x -> y and stop tape recording
     1273                CppAD::ADFun<double> f(ax, ay);
     1274
     1275                // first order Taylor coefficients
     1276                size_t r = 2, ell;
     1277                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1278                for(ell = 0; ell < r; ell++)
     1279                {       for(j = 0; j < n; j++)
     1280                                x1[ r * j + ell ] = double(j + ell + 1);
     1281                }
     1282                y1  = f.Forward(1, r, x1);
     1283                ok &= y1.size() == r*m;
     1284
    12851285                // secondorder Taylor coefficients
    12861286                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     
    12911291                y2  = f.Forward(2, r, x2);
    12921292                ok &= y2.size() == r*m;
    1293                 // 
    1294                 // Y_0 (t)     = F[X_0(t)] 
     1293                //
     1294                // Y_0 (t)     = F[X_0(t)]
    12951295                //             =  2.0 - (0.5 + 1t + 3t^2)/2.0
    12961296                double y_1_0   = - 1.0;
    12971297                double y_2_0   = - 3.0;
    1298                 // 
    1299                 // Y_1 (t)     = F[X_1(t)] 
     1298                //
     1299                // Y_1 (t)     = F[X_1(t)]
    13001300                //             =  3.0 - (0.5 + 2t + 4t^2)/2.0
    13011301                double y_1_1   = - 2.0;
     
    13101310        }
    13111311        // ---------------------------------------------------------------------
    1312         // SubvvOp 
     1312        // SubvvOp
    13131313        bool subvv_op(void)
    13141314        {       bool ok = true;
    13151315                double eps = 10. * std::numeric_limits<double>::epsilon();
    13161316                size_t j;
    1317        
     1317
    13181318                // domain space vector
    13191319                size_t n = 2;
    13201320                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1321                 ax[0] = 0.5; 
     1321                ax[0] = 0.5;
    13221322                ax[1] = 2.0;
    1323        
    1324                 // declare independent variables and starting recording
    1325                 CppAD::Independent(ax);
    1326        
     1323
     1324                // declare independent variables and starting recording
     1325                CppAD::Independent(ax);
     1326
    13271327                // range space vector
    13281328                size_t m = 1;
    13291329                CPPAD_TESTVECTOR(AD<double>) ay(m);
    13301330                ay[0] = ax[0] - 2.0 * ax[1];
    1331        
    1332                 // create f: x -> y and stop tape recording
    1333                 CppAD::ADFun<double> f(ax, ay);
    1334        
    1335                 // first order Taylor coefficients
    1336                 size_t r = 2, ell;
    1337                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1338                 for(ell = 0; ell < r; ell++)
    1339                 {       for(j = 0; j < n; j++)
    1340                                 x1[ r * j + ell ] = double(j + ell + 1);
    1341                 }
    1342                 y1  = f.Forward(1, r, x1);
    1343                 ok &= y1.size() == r*m;
    1344                
    1345                 // secondorder Taylor coefficients
    1346                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1347                 for(ell = 0; ell < r; ell++)
    1348                 {       for(j = 0; j < n; j++)
    1349                                 x2[ r * j + ell ] = double(j + ell + 2);
    1350                 }
    1351                 y2  = f.Forward(2, r, x2);
    1352                 ok &= y2.size() == r*m;
    1353                 // 
    1354                 // Y_0 (t)     = F[X_0(t)] 
     1331
     1332                // create f: x -> y and stop tape recording
     1333                CppAD::ADFun<double> f(ax, ay);
     1334
     1335                // first order Taylor coefficients
     1336                size_t r = 2, ell;
     1337                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1338                for(ell = 0; ell < r; ell++)
     1339                {       for(j = 0; j < n; j++)
     1340                                x1[ r * j + ell ] = double(j + ell + 1);
     1341                }
     1342                y1  = f.Forward(1, r, x1);
     1343                ok &= y1.size() == r*m;
     1344
     1345                // secondorder Taylor coefficients
     1346                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1347                for(ell = 0; ell < r; ell++)
     1348                {       for(j = 0; j < n; j++)
     1349                                x2[ r * j + ell ] = double(j + ell + 2);
     1350                }
     1351                y2  = f.Forward(2, r, x2);
     1352                ok &= y2.size() == r*m;
     1353                //
     1354                // Y_0 (t)     = F[X_0(t)]
    13551355                //             =  (0.5 + 1t + 2t^2) - 2.0 * (2.0 + 2t + 3t^2)
    13561356                double y_1_0   = 1.0 - 4.0;
    13571357                double y_2_0   = 2.0 - 6.0;
    1358                 // 
    1359                 // Y_1 (t)     = F[X_1(t)] 
     1358                //
     1359                // Y_1 (t)     = F[X_1(t)]
    13601360                //             =  (2.0 + 2t + 3t^2) - 2.0 * (2.0 + 3t + 4t^2)
    13611361                double y_1_1   = 2.0 - 6.0;
     
    13701370        }
    13711371        // ---------------------------------------------------------------------
    1372         // TanOp 
     1372        // TanOp
    13731373        bool tan_op(void)
    13741374        {       bool ok = true;
    13751375                double eps = 10. * std::numeric_limits<double>::epsilon();
    13761376                size_t j;
    1377        
     1377
    13781378                // domain space vector
    13791379                size_t n = 1;
    13801380                CPPAD_TESTVECTOR(AD<double>) ax(n);
    1381                 ax[0] = 0.5; 
    1382        
    1383                 // declare independent variables and starting recording
    1384                 CppAD::Independent(ax);
    1385        
     1381                ax[0] = 0.5;
     1382
     1383                // declare independent variables and starting recording
     1384                CppAD::Independent(ax);
     1385
    13861386                // range space vector
    13871387                size_t m = 1;
    13881388                CPPAD_TESTVECTOR(AD<double>) ay(m);
    13891389                ay[0] = tan( ax[0] );
    1390        
    1391                 // create f: x -> y and stop tape recording
    1392                 CppAD::ADFun<double> f(ax, ay);
    1393        
    1394                 // first order Taylor coefficients
    1395                 size_t r = 2, ell;
    1396                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1397                 for(ell = 0; ell < r; ell++)
    1398                 {       for(j = 0; j < n; j++)
    1399                                 x1[ r * j + ell ] = double(j + ell + 1);
    1400                 }
    1401                 y1  = f.Forward(1, r, x1);
    1402                 ok &= y1.size() == r*m;
    1403                
    1404                 // secondorder Taylor coefficients
    1405                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1406                 for(ell = 0; ell < r; ell++)
    1407                 {       for(j = 0; j < n; j++)
    1408                                 x2[ r * j + ell ] = double(j + ell + 2);
    1409                 }
    1410                 y2  = f.Forward(2, r, x2);
    1411                 ok &= y2.size() == r*m;
    1412                 // 
    1413                 // Y_0  (t)    = F[X_0(t)] 
     1390
     1391                // create f: x -> y and stop tape recording
     1392                CppAD::ADFun<double> f(ax, ay);
     1393
     1394                // first order Taylor coefficients
     1395                size_t r = 2, ell;
     1396                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1397                for(ell = 0; ell < r; ell++)
     1398                {       for(j = 0; j < n; j++)
     1399                                x1[ r * j + ell ] = double(j + ell + 1);
     1400                }
     1401                y1  = f.Forward(1, r, x1);
     1402                ok &= y1.size() == r*m;
     1403
     1404                // secondorder Taylor coefficients
     1405                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1406                for(ell = 0; ell < r; ell++)
     1407                {       for(j = 0; j < n; j++)
     1408                                x2[ r * j + ell ] = double(j + ell + 2);
     1409                }
     1410                y2  = f.Forward(2, r, x2);
     1411                ok &= y2.size() == r*m;
     1412                //
     1413                // Y_0  (t)    = F[X_0(t)]
    14141414                //             =  tan(0.5 + 1t + 2t^2)
    14151415                // Y_0' (t)    =  cos(0.5 + 1t + 2t^2)^(-2)*(1 + 4t)
     
    14181418                double y_1_0   = sec_sq;
    14191419                double y_2_0   = (2.0 * tan(0.5) + 4.0) * sec_sq / 2.0;
    1420                 // 
    1421                 // Y_1  (t)    = F[X_1(t)] 
     1420                //
     1421                // Y_1  (t)    = F[X_1(t)]
    14221422                //             = tan(0.5 + 2t + 3t^2)
    14231423                // Y_1' (t)    = cos(0.5 + 2t + 3t^2)^(-2)*(2 + 6t)
     
    14341434        }
    14351435        // ---------------------------------------------------------------------
    1436         // Usr*Op 
     1436        // Usr*Op
    14371437        typedef CPPAD_TESTVECTOR(AD<double>) avector;
    14381438        void usr_algo(const avector& x, avector& z)
     
    14501450                size_t n = 2;
    14511451                avector ax(n), az(3);
    1452                 ax[0] = 0.5; 
     1452                ax[0] = 0.5;
    14531453                ax[1] = 2.0;
    14541454                CppAD::checkpoint<double> usr_check("usr_check", usr_algo, ax, az);
     
    14591459                // record checkpoint function
    14601460                usr_check(ax, az);
    1461        
     1461
    14621462                // range space vector
    14631463                size_t m = 2;
     
    14681468                // create f: x -> y and stop tape recording
    14691469                CppAD::ADFun<double> f(ax, ay);
    1470        
    1471                 // first order Taylor coefficients
    1472                 size_t r = 2, ell;
    1473                 CPPAD_TESTVECTOR(double) x1(r*n), y1;
    1474                 for(ell = 0; ell < r; ell++)
    1475                 {       for(j = 0; j < n; j++)
    1476                                 x1[ r * j + ell ] = double(j + ell + 1);
    1477                 }
    1478                 y1  = f.Forward(1, r, x1);
    1479                 ok &= y1.size() == r*m;
    1480                
    1481                 // secondorder Taylor coefficients
    1482                 CPPAD_TESTVECTOR(double) x2(r*n), y2;
    1483                 for(ell = 0; ell < r; ell++)
    1484                 {       for(j = 0; j < n; j++)
    1485                                 x2[ r * j + ell ] = double(j + ell + 2);
    1486                 }
    1487                 y2  = f.Forward(2, r, x2);
    1488                 ok &= y2.size() == r*m;
    1489                 // 
     1470
     1471                // first order Taylor coefficients
     1472                size_t r = 2, ell;
     1473                CPPAD_TESTVECTOR(double) x1(r*n), y1;
     1474                for(ell = 0; ell < r; ell++)
     1475                {       for(j = 0; j < n; j++)
     1476                                x1[ r * j + ell ] = double(j + ell + 1);
     1477                }
     1478                y1  = f.Forward(1, r, x1);
     1479                ok &= y1.size() == r*m;
     1480
     1481                // secondorder Taylor coefficients
     1482                CPPAD_TESTVECTOR(double) x2(r*n), y2;
     1483                for(ell = 0; ell < r; ell++)
     1484                {       for(j = 0; j < n; j++)
     1485                                x2[ r * j + ell ] = double(j + ell + 2);
     1486                }
     1487                y2  = f.Forward(2, r, x2);
     1488                ok &= y2.size() == r*m;
     1489                //
    14901490                // Y0_0 (t)    = 0.5 + 1t + 2t^2
    14911491                double y0_1_0  = 1.0;
    14921492                double y0_2_0  = 2.0;
    1493                 // 
     1493                //
    14941494                // Y0_1 (t)    = 0.5 + 2t + 3t^2
    14951495                double y0_1_1  = 2.0;
    14961496                double y0_2_1  = 3.0;
    1497                 // 
     1497                //
    14981498                // Y1_0 (t)    = 2.0 + 2t + 3t^2
    14991499                double y1_1_0  = 2.0;
    15001500                double y1_2_0  = 3.0;
    1501                 // 
     1501                //
    15021502                // Y1_1 (t)    = 2.0 + 3t + 4t^2
    15031503                double y1_1_1  = 3.0;
     
    15201520        // CosOp, SinOp, TanOp, ExpOp, MulvvOp, DivvpOp, AddpvOp
    15211521        //
    1522         // AcosOp 
     1522        // AcosOp
    15231523        AD<double> acos_fun(const AD<double>& x)
    15241524        {       return acos( cos(x) ); }
     
    15261526        {       return check_identity(acos_fun, 0.5); }
    15271527        //
    1528         // AsinOp
     1528        // AcoshOp
     1529        AD<double> acosh_fun(const AD<double>& x)
     1530        {       return acosh( cosh(x) ); }
     1531        bool acosh_op(void)
     1532        {       return check_identity(acosh_fun, 0.5); }
     1533        //
     1534        // AsinOp
    15291535        AD<double> asin_fun(const AD<double>& x)
    15301536        {       return asin( sin(x) ); }
     
    15321538        {       return check_identity(asin_fun, 0.5); }
    15331539        //
    1534         // AtanOp
     1540        // AsinhOp
     1541        AD<double> asinh_fun(const AD<double>& x)
     1542        {       return asinh( sinh(x) ); }
     1543        bool asinh_op(void)
     1544        {       return check_identity(asinh_fun, 0.5); }
     1545        //
     1546        // AtanOp
    15351547        AD<double> atan_fun(const AD<double>& x)
    15361548        {       return atan( tan(x) ); }
     
    15381550        {       return check_identity(atan_fun, 0.5); }
    15391551        //
    1540         // LogOp
     1552        // AtanhOp
     1553        AD<double> atanh_fun(const AD<double>& x)
     1554        {       return atanh( tanh(x) ); }
     1555        bool atanh_op(void)
     1556        {       return check_identity(atanh_fun, 0.5); }
     1557        //
     1558        // LogOp
    15411559        AD<double> log_fun(const AD<double>& x)
    15421560        {       return log( exp(x) ); }
     
    15881606        ok     &= abs_op();
    15891607        ok     &= acos_op();
     1608        ok     &= acosh_op();
    15901609        ok     &= asin_op();
     1610        ok     &= asinh_op();
    15911611        ok     &= atan_op();
     1612        ok     &= atanh_op();
    15921613        ok     &= addpv_op();
    15931614        ok     &= addvv_op();
  • trunk/test_more/makefile.am

    r3680 r3682  
    101101        add_zero.cpp \
    102102        atan.cpp \
     103        atanh.cpp \
    103104        atan2.cpp \
    104105        base_alloc.cpp \
  • trunk/test_more/makefile.in

    r3681 r3682  
    105105        alloc_openmp.cpp test_more.cpp abs.cpp acos.cpp acosh.cpp \
    106106        adfun_copy.cpp asin.cpp asinh.cpp assign.cpp add.cpp \
    107         add_eq.cpp add_zero.cpp atan.cpp atan2.cpp base_alloc.cpp \
    108         check_simple_vector.cpp checkpoint.cpp compare.cpp \
    109         compare_change.cpp cond_exp.cpp cond_exp_ad.cpp \
     107        add_eq.cpp add_zero.cpp atan.cpp atanh.cpp atan2.cpp \
     108        base_alloc.cpp check_simple_vector.cpp checkpoint.cpp \
     109        compare.cpp compare_change.cpp cond_exp.cpp cond_exp_ad.cpp \
    110110        cond_exp_rev.cpp copy.cpp cos.cpp cosh.cpp dbl_epsilon.cpp \
    111111        div.cpp div_eq.cpp div_zero_one.cpp erf.cpp exp.cpp \
     
    131131        asin.$(OBJEXT) asinh.$(OBJEXT) assign.$(OBJEXT) add.$(OBJEXT) \
    132132        add_eq.$(OBJEXT) add_zero.$(OBJEXT) atan.$(OBJEXT) \
    133         atan2.$(OBJEXT) base_alloc.$(OBJEXT) \
     133        atanh.$(OBJEXT) atan2.$(OBJEXT) base_alloc.$(OBJEXT) \
    134134        check_simple_vector.$(OBJEXT) checkpoint.$(OBJEXT) \
    135135        compare.$(OBJEXT) compare_change.$(OBJEXT) cond_exp.$(OBJEXT) \
     
    352352cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
    353353cppad_boostvector = @cppad_boostvector@
     354cppad_compiler_has_acosh = @cppad_compiler_has_acosh@
    354355cppad_compiler_has_asinh = @cppad_compiler_has_asinh@
     356cppad_compiler_has_atanh = @cppad_compiler_has_atanh@
    355357cppad_compiler_has_erf = @cppad_compiler_has_erf@
    356358cppad_cppadvector = @cppad_cppadvector@
     
    487489        add_zero.cpp \
    488490        atan.cpp \
     491        atanh.cpp \
    489492        atan2.cpp \
    490493        base_alloc.cpp \
     
    629632@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan.Po@am__quote@
    630633@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atan2.Po@am__quote@
     634@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atanh.Po@am__quote@
    631635@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_adolc.Po@am__quote@
    632636@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_alloc.Po@am__quote@
  • trunk/test_more/test_more.cpp

    r3680 r3682  
    2929extern bool asinh(void);
    3030extern bool assign(void);
    31 extern bool Atan(void);
     31extern bool atan(void);
     32extern bool atanh(void);
    3233extern bool atan2(void);
    3334extern bool base_adolc(void);
     
    145146        ok &= Run( asinh,           "asinh"          );
    146147        ok &= Run( assign,          "assign"         );
    147         ok &= Run( Atan,            "Atan"           );
     148        ok &= Run( atan,            "atan"           );
     149        ok &= Run( atanh,           "atanh"          );
    148150        ok &= Run( atan2,           "atan2"          );
    149151        ok &= Run( check_simple_vector, "check_simple_vector" );
Note: See TracChangeset for help on using the changeset viewer.