Changeset 1697


Ignore:
Timestamp:
Apr 28, 2010 11:23:30 PM (10 years ago)
Author:
bradbell
Message:

trunk:
Improve the multi-level AD examples.

mul_level_adolc.cpp: new example.
example/mul_level.cpp: new example.
test_more/mul_level.cpp: move old examples here as tests.
test_one.sh.in: fix ADOLC_DIR setting.
*/makefile.in: set revision for corresponding makefile.am.
whats_new_10.omh: user's view of the changes.

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad_ipopt/example/makefile.in

    r1695 r1697  
    9090CYGPATH_W = @CYGPATH_W@
    9191
    92 # $Id: makefile.am 1693 2010-04-27 03:04:53Z bradbell $
     92# $Id: makefile.am 1695 2010-04-28 03:07:19Z bradbell $
    9393# -----------------------------------------------------------------------------
    9494# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
  • trunk/cppad_ipopt/speed/makefile.in

    r1695 r1697  
    9191CYGPATH_W = @CYGPATH_W@
    9292
    93 # $Id: makefile.am 1693 2010-04-27 03:04:53Z bradbell $
     93# $Id: makefile.am 1695 2010-04-28 03:07:19Z bradbell $
    9494# -----------------------------------------------------------------------------
    9595# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
  • trunk/cppad_ipopt/test/makefile.in

    r1695 r1697  
    8686CYGPATH_W = @CYGPATH_W@
    8787
    88 # $Id: makefile.am 1693 2010-04-27 03:04:53Z bradbell $
     88# $Id: makefile.am 1695 2010-04-28 03:07:19Z bradbell $
    8989# -----------------------------------------------------------------------------
    9090# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
  • trunk/example/mul_level.cpp

    r1370 r1697  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2626
    2727$head Purpose$$
    28 This is an example and test of using the $code AD<double>$$ type,
    29 together with the $code AD< AD<double> >$$ type,
    30 for multiple levels of taping.
    31 The example computes
    32 the value
     28In this example, we use $code AD< AD<double> >$$ (level two taping),
     29the compute values of the function $latex f : \R^n \rightarrow \R$$ where
    3330$latex \[
    34         \frac{d}{dx} \left[ f^{(1)} (x) * v \right]
     31        f(x) = \frac{1}{2} \left( x_0^2 + \cdots + x_{n-1}^2 \right)
    3532\] $$
    36 where $latex f : \R^n \rightarrow \R$$ and
    37 $latex v \in \R^n$$.
    38 The example $xref/HesTimesDir.cpp/$$ computes the same value using only
    39 one level of taping (more efficient) and the identity
     33We then use $code AD<double>$$ (level one taping) to compute
     34the directional derivative
     35$latex \[
     36f^{(1)} (x) * v  = x_0 v_0 + \cdots + x_{n-1} v_{n-1}
     37\] $$.
     38where $latex v \in \R^n$$.
     39We then use $code double$$ (no taping) to compute
     40$latex \[
     41\frac{d}{dx} \left[ f^{(1)} (x) * v \right] = v
     42\] $$
     43This is only meant as an example of multiple levels of taping.
     44The example $xref/HesTimesDir.cpp/$$ computes the same value more
     45efficiently by using the identity:
    4046$latex \[
    4147        \frac{d}{dx} \left[ f^{(1)} (x) * v \right] = f^{(2)} (x) * v
     
    5460# include <cppad/cppad.hpp>
    5561
    56 namespace { // put this function in the empty namespace
    57         // f(x) = |x|^2 = .5 * ( x[0]^2 + ... + x[n-1]^2 + .5 )
     62namespace {
     63        // f(x) = |x|^2 / 2 = .5 * ( x[0]^2 + ... + x[n-1]^2 )
    5864        template <class Type>
    5965        Type f(CPPAD_TEST_VECTOR<Type> &x)
    6066        {       Type sum;
    6167
    62                 // check assignment of AD< AD<double> > = double
    63                 sum  = .5;
    64                 sum += .5;
    65 
     68                sum  = 0.;
    6669                size_t i = x.size();
    67                 while(i--)
     70                for(i = 0; i < x.size(); i++)
    6871                        sum += x[i] * x[i];
    6972
    70                 // check computed assignment AD< AD<double> > -= int
    71                 sum -= 1;
    72        
    73                 // check double * AD< AD<double> >
    7473                return .5 * sum;
    7574        }
     
    8887        CPPAD_TEST_VECTOR<ADDdouble> aa_x(n);
    8988
    90         // value of the independent variables
     89        // Values for the independent variables while taping the function f(x)
    9190        for(j = 0; j < n; j++)
    92                 a_x[j] = x[j] = double(j); // x[j] = j
    93         Independent(a_x);                  // a_x is indedendent for ADdouble
     91                aa_x[j] = double(j);
     92        // Declare the independent variable for taping f(x)
     93        CppAD::Independent(aa_x);
     94
     95        // Use AD< AD<double> > to tape the evaluation of f(x)
     96        CPPAD_TEST_VECTOR<ADDdouble> aa_f(1);
     97        aa_f[0] = f(aa_x);
     98
     99        // Declare a_F as the corresponding ADFun< AD<double> > function f(x)
     100        // (make sure we do not run zero order forward during constructor)
     101        CppAD::ADFun<ADdouble> a_F;
     102        a_F.Dependent(aa_x, aa_f);
     103
     104        // Values for the independent variables while taping f'(x) * v
    94105        for(j = 0; j < n; j++)
    95                 aa_x[j] = a_x[j];          // track how aa_x depends on a_x
    96         CppAD::Independent(aa_x);          // aa_x is independent for ADDdouble
     106                a_x[j] = double(j);
     107        // Declare the independent variable for taping f'(x) * v
     108        CppAD::Independent(a_x);
     109        // set the argument value x for computing f'(x) * v
     110        a_F.Forward(0, a_x);
     111        // compute f'(x) * v
     112        CPPAD_TEST_VECTOR<ADdouble> a_v(n);
     113        CPPAD_TEST_VECTOR<ADdouble> a_df(1);
     114        for(j = 0; j < n; j++)
     115                a_v[j] = double(n - j);
     116        a_df = a_F.Forward(1, a_v);
    97117
    98         // compute function
    99         CPPAD_TEST_VECTOR<ADDdouble> aa_f(1);    // scalar valued function
    100         aa_f[0] = f(aa_x);                 // has only one component
    101 
    102         // declare inner function (corresponding to ADDdouble calculation)
    103         CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
    104 
    105         // compute f'(x)
    106         size_t p = 1;                        // order of derivative of a_F
    107         CPPAD_TEST_VECTOR<ADdouble> a_w(1);  // weight vector for a_F
    108         CPPAD_TEST_VECTOR<ADdouble> a_df(n); // value of derivative
    109         a_w[0] = 1;                          // weighted function same as a_F
    110         a_df   = a_F.Reverse(p, a_w);        // gradient of f
    111 
    112         // declare outter function (corresponding to ADdouble calculation)
     118        // declare dF as ADFun<double> function corresponding to f'(x) * v
    113119        CppAD::ADFun<double> df(a_x, a_df);
    114120
    115121        // compute the d/dx of f'(x) * v = f''(x) * v
    116         CPPAD_TEST_VECTOR<double> v(n);
    117         CPPAD_TEST_VECTOR<double> ddf_v(n);
     122        CPPAD_TEST_VECTOR<double> w(1);
     123        CPPAD_TEST_VECTOR<double> dw(n);
     124        w[0] = 1.;
     125        dw   = df.Reverse(1, w);
     126
    118127        for(j = 0; j < n; j++)
    119                 v[j] = double(n - j);
    120         ddf_v = df.Reverse(p, v);
    121 
    122         // f(x)       = .5 * ( x[0]^2 + x[1]^2 + ... + x[n-1]^2 )
    123         // f'(x)      = (x[0], x[1], ... , x[n-1])
    124         // f''(x) * v = ( v[0], v[1],  ... , x[n-1] )
    125         for(j = 0; j < n; j++)
    126                 ok &= CppAD::NearEqual(ddf_v[j], v[j], 1e-10, 1e-10);
     128                ok &= CppAD::NearEqual(dw[j], a_v[j], 1e-10, 1e-10);
    127129
    128130        return ok;
  • trunk/example/mul_level_adolc.cpp

    r1613 r1697  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    2525
    2626$head Purpose$$
    27 This is an example and test of using Adolc's $code adouble$$ type,
    28 together with CppAD's $syntax%AD<adouble>%$$ type,
    29 for multiple levels of taping.
    30 The example computes
     27In this example, we use $code AD< adouble> >$$ (level two taping),
     28the compute values of the function $latex f : \R^n \rightarrow \R$$ where
    3129$latex \[
    32         \frac{d}{dx} \left[ f^{(1)} (x) * v \right]
     30        f(x) = \frac{1}{2} \left( x_0^2 + \cdots + x_{n-1}^2 \right)
    3331\] $$
    34 where $latex f : \R^n \rightarrow \R$$ and
    35 $latex v \in \R^n$$.
    36 The example $xref/HesTimesDir.cpp/$$ computes the same value using only
    37 one level of taping (more efficient) and the identity
     32We then use Adolc's $code adouble$$ (level one taping) to compute
     33the directional derivative
     34$latex \[
     35f^{(1)} (x) * v  = x_0 v_0 + \cdots + x_{n-1} v_{n-1}
     36\] $$.
     37where $latex v \in \R^n$$.
     38We then use $code double$$ (no taping) to compute
     39$latex \[
     40\frac{d}{dx} \left[ f^{(1)} (x) * v \right] = v
     41\] $$
     42This is only meant as an example of multiple levels of taping.
     43The example $xref/HesTimesDir.cpp/$$ computes the same value more
     44efficiently by using the identity:
    3845$latex \[
    3946        \frac{d}{dx} \left[ f^{(1)} (x) * v \right] = f^{(2)} (x) * v
    4047\] $$
    4148The example $cref/mul_level.cpp/$$ computes the same values using
    42 $code AD<double>$$ and $code AD< AD<double> >$$.
     49$code AD< AD<double> >$$ and $code AD<double>$$.
    4350
    4451$head Tracking New and Delete$$
     
    8188# include <cppad/cppad.hpp>
    8289
    83 
    84 
    85 namespace { // put this function in the empty namespace
    86 
    87         // f(x) = |x|^2 = .5 * ( x[0]^2 + ... + x[n-1]^2 + .5 )
     90namespace {
     91        // f(x) = |x|^2 / 2 = .5 * ( x[0]^2 + ... + x[n-1]^2 )
    8892        template <class Type>
    8993        Type f(CPPAD_TEST_VECTOR<Type> &x)
    9094        {       Type sum;
    9195
    92                 // check assignment of AD< AD<double> > = double
    93                 sum  = .5;
    94                 sum += .5;
    95 
     96                sum  = 0.;
    9697                size_t i = x.size();
    97                 while(i--)
     98                for(i = 0; i < x.size(); i++)
    9899                        sum += x[i] * x[i];
    99100
    100                 // check computed assignment AD< AD<double> > -= int
    101                 sum -= 1;
    102        
    103                 // check double * AD< AD<double> >
    104101                return .5 * sum;
    105102        }
     
    107104
    108105bool mul_level_adolc(void)
    109 {       bool ok = true;                   // initialize test result
     106{       bool ok = true;                         // initialize test result
    110107
    111         typedef adouble      ADdouble;         // for first level of taping
     108        typedef adouble             ADdouble;  // for first level of taping
    112109        typedef CppAD::AD<ADdouble> ADDdouble; // for second level of taping
    113110        size_t n = 5;                          // number independent variables
     111        size_t j;
    114112
    115113        CPPAD_TEST_VECTOR<double>       x(n);
     
    117115        CPPAD_TEST_VECTOR<ADDdouble> aa_x(n);
    118116
    119         // value of the independent variables
    120         int tag = 0;                         // Adolc setup
     117        // Values for the independent variables while taping the function f(x)
     118        for(j = 0; j < n; j++)
     119                aa_x[j] = double(j);
     120        // Declare the independent variable for taping f(x)
     121        CppAD::Independent(aa_x);
     122
     123        // Use AD<adouble> to tape the evaluation of f(x)
     124        CPPAD_TEST_VECTOR<ADDdouble> aa_f(1);
     125        aa_f[0] = f(aa_x);
     126
     127        // Declare a_F as the corresponding ADFun<adouble> function f(x)
     128        // (make sure we do not run zero order forward during constructor)
     129        CppAD::ADFun<ADdouble> a_F;
     130        a_F.Dependent(aa_x, aa_f);
     131
     132        // Value of the independent variables whitle taping f'(x) * v
     133        int tag = 0;
    121134        int keep = 1;
    122135        trace_on(tag, keep);
    123         size_t j;
    124136        for(j = 0; j < n; j++)
    125         {       x[j] = double(j);           // x[j] = j
    126                 a_x[j] <<= x[j];            // a_x is independent for ADdouble
    127         }
     137                a_x[j] <<= double(j);
     138
     139        // set the argument value x for computing f'(x) * v
     140        a_F.Forward(0, a_x);
     141
     142        // compute f'(x) * v
     143        CPPAD_TEST_VECTOR<ADdouble> a_v(n);
     144        CPPAD_TEST_VECTOR<ADdouble> a_df(1);
    128145        for(j = 0; j < n; j++)
    129                 aa_x[j] = a_x[j];          // track how aa_x depends on a_x
    130         CppAD::Independent(aa_x);          // aa_x is independent for ADDdouble
     146                a_v[j] = double(n - j);
     147        a_df = a_F.Forward(1, a_v);
    131148
    132         // compute function
    133         CPPAD_TEST_VECTOR<ADDdouble> aa_f(1);    // scalar valued function
    134         aa_f[0] = f(aa_x);                 // has only one component
    135 
    136         // declare inner function (corresponding to ADDdouble calculation)
    137         CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
    138 
    139         // compute f'(x)
    140         size_t p = 1;                        // order of derivative of a_F
    141         CPPAD_TEST_VECTOR<ADdouble> a_w(1);  // weight vector for a_F
    142         CPPAD_TEST_VECTOR<ADdouble> a_df(n); // value of derivative
    143         a_w[0] = 1;                          // weighted function same as a_F
    144         a_df   = a_F.Reverse(p, a_w);        // gradient of f
    145 
    146         // declare outter function
    147         // (corresponding to the tape of adouble operations)
    148         double df_j;
    149         for(j = 0; j < n; j++)
    150                 a_df[j] >>= df_j;
     149        // declare Adolc function corresponding to f'(x) * v
     150        double df;
     151        a_df[0] >>= df;
    151152        trace_off();
    152153
    153154        // compute the d/dx of f'(x) * v = f''(x) * v
    154         size_t m      = n;                     // # dependent in f'(x)
    155         double *v = 0, *ddf_v = 0;
    156         v     = CPPAD_TRACK_NEW_VEC(m, v);     // track v = new double[m]
    157         ddf_v = CPPAD_TRACK_NEW_VEC(n, ddf_v); // track ddf_v = new double[n]
     155        size_t m      = 1;                     // # dependent in f'(x) * v
     156        double *w = 0, *dw = 0;
     157        w     = CPPAD_TRACK_NEW_VEC(m, w);     // track w  = new double[m]
     158        dw    = CPPAD_TRACK_NEW_VEC(n, dw);    // track dw = new double[n]
     159        w[0]  = 1.;
     160        fos_reverse(tag, int(m), int(n), w, dw);
     161
    158162        for(j = 0; j < n; j++)
    159                 v[j] = double(n - j);
    160         fos_reverse(tag, int(m), int(n), v, ddf_v);
     163        {       double vj = a_v[j].value();
     164                ok &= CppAD::NearEqual(dw[j], vj, 1e-10, 1e-10);
     165        }
    161166
    162         // f(x)       = .5 * ( x[0]^2 + x[1]^2 + ... + x[n-1]^2 )
    163         // f'(x)      = (x[0], x[1], ... , x[n-1])
    164         // f''(x) * v = ( v[0], v[1],  ... , x[n-1] )
    165         for(j = 0; j < n; j++)
    166                 ok &= CppAD::NearEqual(ddf_v[j], v[j], 1e-10, 1e-10);
    167 
    168         CPPAD_TRACK_DEL_VEC(v);                 // check usage of delete
    169         CPPAD_TRACK_DEL_VEC(ddf_v);
     167        CPPAD_TRACK_DEL_VEC(w);                 // check usage of delete
     168        CPPAD_TRACK_DEL_VEC(dw);
    170169        return ok;
    171170}
  • trunk/omh/whats_new_10.omh

    r1693 r1697  
    4444assist you in learning about changes between various versions of CppAD.
    4545
     46$head 04-28$$
     47Change the multi-level taping examples
     48$cref mul_level.cpp$$ and $cref mul_level_adolc.cpp$$
     49to be more efficient.
     50
    4651$head 04-26$$
    4752Include Blas and Linpack libraries in makefile links for
  • trunk/test_more/mul_level.cpp

    r1370 r1697  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1111-------------------------------------------------------------------------- */
    1212
     13
     14# ifdef CPPAD_ADOLC_TEST
     15# include <adolc/adouble.h>
     16# include <adolc/taping.h>
     17# include <adolc/interfaces.h>
     18// adouble definitions not in Adolc distribution and
     19// required in order to use CppAD::AD<adouble>
     20# include "../example/base_adolc.hpp"
     21# endif
     22
    1323# include <cppad/cppad.hpp>
    14 
    1524# include <limits>
    1625
    17 bool mul_level(void)
     26namespace { // BEGIN empty namespace
     27
     28bool One(void)
    1829{       bool ok = true;                          // initialize test result
    1930        using CppAD::NearEqual;
     
    6778        return ok;
    6879}
    69 // END PROGRAM
     80
     81// f(x) = |x|^2 = .5 * ( x[0]^2 + ... + x[n-1]^2 )
     82template <class Type>
     83Type f_Two(CPPAD_TEST_VECTOR<Type> &x)
     84{       Type sum;
     85
     86        // check assignment of AD< AD<double> > = double
     87        sum  = .5;
     88        sum += .5;
     89
     90        size_t i = x.size();
     91        while(i--)
     92                sum += x[i] * x[i];
     93
     94        // check computed assignment AD< AD<double> > -= int
     95        sum -= 1;
     96
     97        // check double * AD< AD<double> >
     98        return .5 * sum;
     99}
     100
     101bool Two(void)
     102{       bool ok = true;                          // initialize test result
     103
     104        typedef CppAD::AD<double>   ADdouble;    // for one level of taping
     105        typedef CppAD::AD<ADdouble> ADDdouble;   // for two levels of taping
     106        size_t n = 5;                            // dimension for example
     107        size_t j;                                // a temporary index variable
     108
     109        CPPAD_TEST_VECTOR<double>       x(n);
     110        CPPAD_TEST_VECTOR<ADdouble>   a_x(n);
     111        CPPAD_TEST_VECTOR<ADDdouble> aa_x(n);
     112
     113        // value of the independent variables
     114        for(j = 0; j < n; j++)
     115                a_x[j] = x[j] = double(j); // x[j] = j
     116        Independent(a_x);                  // a_x is indedendent for ADdouble
     117        for(j = 0; j < n; j++)
     118                aa_x[j] = a_x[j];          // track how aa_x depends on a_x
     119        CppAD::Independent(aa_x);          // aa_x is independent for ADDdouble
     120
     121        // compute function
     122        CPPAD_TEST_VECTOR<ADDdouble> aa_f(1);    // scalar valued function
     123        aa_f[0] = f_Two(aa_x);                   // has only one component
     124
     125        // declare inner function (corresponding to ADDdouble calculation)
     126        CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
     127
     128        // compute f'(x)
     129        size_t p = 1;                        // order of derivative of a_F
     130        CPPAD_TEST_VECTOR<ADdouble> a_w(1);  // weight vector for a_F
     131        CPPAD_TEST_VECTOR<ADdouble> a_df(n); // value of derivative
     132        a_w[0] = 1;                          // weighted function same as a_F
     133        a_df   = a_F.Reverse(p, a_w);        // gradient of f
     134
     135        // declare outter function (corresponding to ADdouble calculation)
     136        CppAD::ADFun<double> df(a_x, a_df);
     137
     138        // compute the d/dx of f'(x) * v = f''(x) * v
     139        CPPAD_TEST_VECTOR<double> v(n);
     140        CPPAD_TEST_VECTOR<double> ddf_v(n);
     141        for(j = 0; j < n; j++)
     142                v[j] = double(n - j);
     143        ddf_v = df.Reverse(p, v);
     144
     145        // f(x)       = .5 * ( x[0]^2 + x[1]^2 + ... + x[n-1]^2 )
     146        // f'(x)      = (x[0], x[1], ... , x[n-1])
     147        // f''(x) * v = ( v[0], v[1],  ... , x[n-1] )
     148        for(j = 0; j < n; j++)
     149                ok &= CppAD::NearEqual(ddf_v[j], v[j], 1e-10, 1e-10);
     150
     151        return ok;
     152}
     153
     154# ifdef CPPAD_ADOLC_TEST
     155
     156bool Three(void)
     157{       bool ok = true;                   // initialize test result
     158
     159        typedef adouble      ADdouble;         // for first level of taping
     160        typedef CppAD::AD<ADdouble> ADDdouble; // for second level of taping
     161        size_t n = 5;                          // number independent variables
     162
     163        CPPAD_TEST_VECTOR<double>       x(n);
     164        CPPAD_TEST_VECTOR<ADdouble>   a_x(n);
     165        CPPAD_TEST_VECTOR<ADDdouble> aa_x(n);
     166
     167        // value of the independent variables
     168        int tag = 0;                         // Adolc setup
     169        int keep = 1;
     170        trace_on(tag, keep);
     171        size_t j;
     172        for(j = 0; j < n; j++)
     173        {       x[j] = double(j);           // x[j] = j
     174                a_x[j] <<= x[j];            // a_x is independent for ADdouble
     175        }
     176        for(j = 0; j < n; j++)
     177                aa_x[j] = a_x[j];          // track how aa_x depends on a_x
     178        CppAD::Independent(aa_x);          // aa_x is independent for ADDdouble
     179
     180        // compute function
     181        CPPAD_TEST_VECTOR<ADDdouble> aa_f(1);    // scalar valued function
     182        aa_f[0] = f_Two(aa_x);                   // has only one component
     183
     184        // declare inner function (corresponding to ADDdouble calculation)
     185        CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
     186
     187        // compute f'(x)
     188        size_t p = 1;                        // order of derivative of a_F
     189        CPPAD_TEST_VECTOR<ADdouble> a_w(1);  // weight vector for a_F
     190        CPPAD_TEST_VECTOR<ADdouble> a_df(n); // value of derivative
     191        a_w[0] = 1;                          // weighted function same as a_F
     192        a_df   = a_F.Reverse(p, a_w);        // gradient of f
     193
     194        // declare outter function
     195        // (corresponding to the tape of adouble operations)
     196        double df_j;
     197        for(j = 0; j < n; j++)
     198                a_df[j] >>= df_j;
     199        trace_off();
     200
     201        // compute the d/dx of f'(x) * v = f''(x) * v
     202        size_t m      = n;                     // # dependent in f'(x)
     203        double *v = 0, *ddf_v = 0;
     204        v     = CPPAD_TRACK_NEW_VEC(m, v);     // track v = new double[m]
     205        ddf_v = CPPAD_TRACK_NEW_VEC(n, ddf_v); // track ddf_v = new double[n]
     206        for(j = 0; j < n; j++)
     207                v[j] = double(n - j);
     208        fos_reverse(tag, int(m), int(n), v, ddf_v);
     209
     210        // f(x)       = .5 * ( x[0]^2 + x[1]^2 + ... + x[n-1]^2 )
     211        // f'(x)      = (x[0], x[1], ... , x[n-1])
     212        // f''(x) * v = ( v[0], v[1],  ... , x[n-1] )
     213        for(j = 0; j < n; j++)
     214                ok &= CppAD::NearEqual(ddf_v[j], v[j], 1e-10, 1e-10);
     215
     216        CPPAD_TRACK_DEL_VEC(v);                 // check usage of delete
     217        CPPAD_TRACK_DEL_VEC(ddf_v);
     218        return ok;
     219}
     220
     221# endif // CPPAD_ADOLC_TEST
     222
     223} // END empty namespace
     224
     225bool mul_level(void)
     226{       bool ok = true;
     227        ok     &= One();
     228        ok     &= Two();
     229# ifdef CPPAD_ADOLC_TEST
     230        ok     &= Three();
     231# endif
     232        return ok;
     233}
  • trunk/test_more/test_one.sh.in

    r1638 r1697  
    4040        -I.. -I/usr/include/boost-1_33_1
    4141"
    42 if [ -e @ADOLD_DIR@/include/adolc/adouble.h ]
     42if [ -e @ADOLC_DIR@/include/adolc/adouble.h ]
    4343then
    4444        cmd="$cmd -I@ADOLC_DIR@/include -L@ADOLC_DIR@/lib -ladolc"
Note: See TracChangeset for help on using the changeset viewer.