Changeset 2401 for trunk/test_more


Ignore:
Timestamp:
May 24, 2012 12:30:25 PM (8 years ago)
Author:
bradbell
Message:

Merge in changes from branches/sparse.

  1. Update version number to today.
  2. Add sparse return user API interfaces to SparseJacobian? and SparseHessian?.
  3. Include new interface and imporve sparse Hessian and Jacobian examples.
  4. More testing of sparse Hessian and Jacobians.
  5. Add is_element to sparse_set and sparse_pack.

.: merge information.
search.sh: search cppad/speed directory, drop makefile.in from results.
svn_merge.sh: parameters for this merge.
parallel_ad.hpp: initilize is_element statics.
sparse_evaluate.hpp: fix typo in documentation.
glossary.omh: convert to modern omhelp, improve AD Function entry.
link_sparse_hessian.cpp: fix typo in documentation.

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/test_more/sparse_hessian.cpp

    r1558 r2401  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1717# include <cppad/cppad.hpp>
    1818namespace { // ---------------------------------------------------------
     19
     20bool rc_tridiagonal(void)
     21{       bool ok = true;
     22        using CppAD::AD;
     23        using CppAD::NearEqual;
     24        size_t i, j, k, ell;
     25        double eps = 10. * CppAD::epsilon<double>();
     26
     27        size_t n = 12; // must be greater than or equal 3; see n_sweep.
     28        size_t m = n - 1;
     29        CPPAD_TEST_VECTOR< AD<double> > a_x(n), a_y(m);
     30        CPPAD_TEST_VECTOR<double> x(n), check(n * n), w(m);
     31        for(j = 0; j < n; j++)
     32                a_x[j] = x[j] = double(j+1);
     33
     34        // declare independent variables and start taping
     35        CppAD::Independent(a_x);
     36
     37        for(ell = 0; ell < n * n; ell++)
     38                check[ell] = 0.0;
     39
     40        for(i = 0; i < m; i++)
     41        {       AD<double> diff = a_x[i+1] - a_x[i];   
     42                a_y[i] = 0.5 * diff * diff / double(i+2);
     43                w[i] = double(i+1);
     44                ell         = i * n + i;
     45                check[ell] += w[i] / double(i+2);
     46                ell         = (i+1) * n + i+1;
     47                check[ell] += w[i] / double(i+2);
     48                ell         = (i+1) * n + i;
     49                check[ell] -= w[i] / double(i+2);
     50                ell         = i * n + i+1;
     51                check[ell] -= w[i] / double(i+2);
     52        }
     53
     54        // create f: x -> y
     55        CppAD::ADFun<double> f(a_x, a_y);
     56                 
     57        // determine the sparsity pattern p for Hessian of w^T f
     58        typedef CppAD::vector< std::set<size_t> > VectorSet;
     59        VectorSet p_r(n);
     60        for(j = 0; j < n; j++)
     61                p_r[j].insert(j);
     62        f.ForSparseJac(n, p_r);
     63        //
     64        VectorSet p_s(1);
     65        for(i = 0; i < m; i++)
     66                if( w[i] != 0 )
     67                        p_s[0].insert(i);
     68        VectorSet p_h = f.RevSparseHes(n, p_s);
     69
     70        // requres the upper triangle of the Hessian
     71        size_t K = 2 * n - 1;
     72        CPPAD_TEST_VECTOR<size_t> r(K), c(K);
     73        CPPAD_TEST_VECTOR<double> hes(K);
     74        k = 0;
     75        for(i = 0; i < n; i++)
     76        {       r[k] = i;
     77                c[k] = i;
     78                k++;
     79                if( i < n-1 )
     80                {       r[k] = i;
     81                        c[k] = i+1;
     82                        k++;
     83                }
     84        }
     85        ok &= k == K;
     86
     87        // test computing sparse Hessian
     88        CppAD::sparse_hessian_work work;
     89        size_t n_sweep = f.SparseHessian(x, w, p_h, r, c, hes, work);
     90        ok &= n_sweep == 3;
     91        for(k = 0; k < K; k++)
     92        {       ell = r[k] * n + c[k];
     93                ok &=  NearEqual(check[ell], hes[k], eps, eps);
     94                ell = c[k] * n + r[k];
     95                ok &=  NearEqual(check[ell], hes[k], eps, eps);
     96        }
     97
     98        return ok;
     99}
     100
     101
    19102template <class VectorBase, class VectorBool>
    20103bool bool_case()
     
    63146
    64147        // determine the sparsity pattern p for Hessian of w^T F
    65         VectorBool r(n * n);
    66         for(j = 0; j < n; j++)
    67         {       for(k = 0; k < n; k++)
    68                         r[j * n + k] = false;
    69                 r[j * n + j] = true;
    70         }
    71         f.ForSparseJac(n, r);
    72         //
    73         VectorBool s(m);
    74         for(i = 0; i < m; i++)
    75                 s[i] = w[i] != 0;
    76         VectorBool p = f.RevSparseHes(n, s);
     148        VectorBool r(n * n);
     149        for(j = 0; j < n; j++)
     150        {       for(k = 0; k < n; k++)
     151                r[j * n + k] = false;
     152                r[j * n + j] = true;
     153        }
     154        f.ForSparseJac(n, r);
     155        //
     156        VectorBool s(m);
     157        for(i = 0; i < m; i++)
     158                s[i] = w[i] != 0;
     159        VectorBool p = f.RevSparseHes(n, s);
    77160
    78161        // test passing sparsity pattern
     
    129212
    130213        // determine the sparsity pattern p for Hessian of w^T F
    131         VectorSet r(n);
    132         for(j = 0; j < n; j++)
     214        VectorSet r(n);
     215        for(j = 0; j < n; j++)
    133216                r[j].insert(j);
    134         f.ForSparseJac(n, r);
    135         //
    136         VectorSet s(1);
    137         for(i = 0; i < m; i++)
    138                 if( w[i] != 0 )
     217        f.ForSparseJac(n, r);
     218        //
     219        VectorSet s(1);
     220        for(i = 0; i < m; i++)
     221                if( w[i] != 0 )
    139222                        s[0].insert(i);
    140         VectorSet p = f.RevSparseHes(n, s);
     223        VectorSet p = f.RevSparseHes(n, s);
    141224
    142225        // test passing sparsity pattern
     
    152235bool sparse_hessian(void)
    153236{       bool ok = true;
     237
     238        ok &= rc_tridiagonal();
     239        // ---------------------------------------------------------------
    154240        // vector of bool cases
    155241        ok &= bool_case< CppAD::vector  <double>, CppAD::vectorBool   >();
  • trunk/test_more/sparse_jacobian.cpp

    r1658 r2401  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    1818namespace { // ---------------------------------------------------------
    1919
     20bool rc_tridiagonal(void)
     21{       bool ok = true;
     22        using CppAD::AD;
     23        using CppAD::NearEqual;
     24        size_t i, j, k, ell;
     25        double eps = 10. * CppAD::epsilon<double>();
     26
     27        // domain space vector
     28        size_t n = 13; // must be greater than or equal 3 (see n_sweep below)
     29        CPPAD_TEST_VECTOR< AD<double> >  X(n);
     30        CPPAD_TEST_VECTOR<double>        x(n);
     31        for(j = 0; j < n; j++)
     32                X[j] = x[j] = double(j+1);
     33
     34        // declare independent variables and starting recording
     35        CppAD::Independent(X);
     36
     37        size_t m = n;
     38        CPPAD_TEST_VECTOR< AD<double> >  Y(m);
     39        CPPAD_TEST_VECTOR<double> check(m * n );
     40        for(ell = 0; ell < m * n; ell++)
     41                check[ell] = 0.0;
     42
     43        size_t K = 0;
     44        for(i = 0; i < n; i++)
     45        {       ell        = i * n + i;
     46                Y[i]       = (ell+1) * 0.5 * X[i] * X[i];
     47                check[ell] = (ell+1) * x[i];
     48                K++;
     49                if( i < n-1 )
     50                {       j          = i + 1;
     51                        ell        = i * n + j;
     52                        Y[i]      += (ell+1) * 0.5 * X[i+1] * X[i+1];
     53                        check[ell] = (ell+1) * x[i+1];
     54                        K++;
     55                }
     56                if(i > 0 )
     57                {       j          = i - 1;
     58                        ell        = i * n + j;
     59                        Y[i]      += (ell+1) * 0.5 * X[i-1] * X[i-1];
     60                        check[ell] = (ell+1) * x[i-1];
     61                }
     62        }
     63
     64        // create f: X -> Y and stop tape recording
     65        CppAD::ADFun<double> f(X, Y);
     66
     67        // sparsity pattern
     68        CppAD::vector< std::set<size_t> > s(m), p(m);
     69        for(i = 0; i < m; i++)
     70                s[i].insert(i);
     71        p   = f.RevSparseJac(m, s);
     72
     73        // Request the upper triangle of the array
     74        CPPAD_TEST_VECTOR<size_t> r(K), c(K);
     75        CPPAD_TEST_VECTOR<double> jac(K);
     76        k = 0;
     77        for(i = 0; i < n; i++)
     78        {       r[k] = i;
     79                c[k] = i;
     80                k++;   
     81                if( i < n-1 )
     82                {       r[k] = i;
     83                        c[k] = i+1;
     84                        k++;
     85                }
     86        }
     87        ok &= K == k;
     88
     89        CppAD::sparse_jacobian_work work;
     90        size_t n_sweep = f.SparseJacobianForward(x, p, r, c, jac, work);
     91        ok &= n_sweep == 3;
     92        for(k = 0; k < K; k++)
     93        {       ell = r[k] * n + c[k];
     94                ok &=  NearEqual(check[ell], jac[k], eps, eps);
     95        }
     96        work.clear();
     97        n_sweep = f.SparseJacobianReverse(x, p, r, c, jac, work);
     98        ok &= n_sweep == 3;
     99        for(k = 0; k < K; k++)
     100        {       ell = r[k] * n + c[k];
     101                ok &=  NearEqual(check[ell], jac[k], eps, eps);
     102        }
     103
     104        return ok;
     105}
     106
     107template <class VectorBase, class VectorSet>
     108bool rc_set(void)
     109{       bool ok = true;
     110        using CppAD::AD;
     111        using CppAD::NearEqual;
     112        size_t i, j, k, ell;
     113        double eps = 10. * CppAD::epsilon<double>();
     114
     115        // domain space vector
     116        size_t n = 4;
     117        CPPAD_TEST_VECTOR< AD<double> >  X(n);
     118        for(j = 0; j < n; j++)
     119                X[j] = AD<double> (0);
     120
     121        // declare independent variables and starting recording
     122        CppAD::Independent(X);
     123
     124        size_t m = 3;
     125        CPPAD_TEST_VECTOR< AD<double> >  Y(m);
     126        Y[0] = 1.0*X[0] + 2.0*X[1];
     127        Y[1] = 3.0*X[2] + 4.0*X[3];
     128        Y[2] = 5.0*X[0] + 6.0*X[1] + 7.0*X[3]*X[3]/2.;
     129
     130        // create f: X -> Y and stop tape recording
     131        CppAD::ADFun<double> f(X, Y);
     132
     133        // new value for the independent variable vector
     134        VectorBase x(n);
     135        for(j = 0; j < n; j++)
     136                x[j] = double(j);
     137
     138        // Jacobian of y
     139        /*
     140              [ 1 2 0 0    ]
     141        jac = [ 0 0 3 4    ]
     142              [ 5 6 0 7*x_3]
     143        */
     144        VectorBase check(m * n);
     145        check[0] = 1.; check[1] = 2.; check[2]  = 0.; check[3]  = 0.;
     146        check[4] = 0.; check[5] = 0.; check[6]  = 3.; check[7]  = 4.;
     147        check[8] = 5.; check[9] = 6.; check[10] = 0.; check[11] = 7.*x[3];
     148
     149        // sparsity pattern
     150        VectorSet s(m), p(m);
     151        for(i = 0; i < m; i++)
     152                s[i].insert(i);
     153        p   = f.RevSparseJac(m, s);
     154
     155        // Use forward mode to compute columns 0 and 2
     156        // (make sure order of rows and columns does not matter)
     157        CPPAD_TEST_VECTOR<size_t> r(3), c(3);
     158        VectorBase jac(3);
     159        r[0] = 2; c[0] = 0;
     160        r[1] = 1; c[1] = 2;
     161        r[2] = 0; c[2] = 0;
     162        CppAD::sparse_jacobian_work work;
     163        size_t n_sweep = f.SparseJacobianForward(x, p, r, c, jac, work);
     164        for(k = 0; k < 3; k++)
     165        {       ell = r[k] * n + c[k];
     166                ok &=  NearEqual(check[ell], jac[k], eps, eps);
     167        }
     168        ok &= (n_sweep == 1);
     169
     170        // Use reverse mode to compute rows 0 and 1
     171        // (make sure order of rows and columns does not matter)
     172        r.resize(4), c.resize(4); jac.resize(4);
     173        r[0] = 0; c[0] = 0;
     174        r[1] = 1; c[1] = 2;
     175        r[2] = 0; c[2] = 1;
     176        r[3] = 1; c[3] = 3;
     177        work.clear();
     178        n_sweep = f.SparseJacobianReverse(x, p, r, c, jac, work);
     179        for(k = 0; k < 4; k++)
     180        {       ell = r[k] * n + c[k];
     181                ok &=  NearEqual(check[ell], jac[k], eps, eps);
     182        }
     183        ok &= (n_sweep == 1);
     184
     185        return ok;
     186}
    20187template <class VectorBase, class VectorBool>
    21 bool reverse_bool()
     188bool rc_bool(void)
     189{       bool ok = true;
     190        using CppAD::AD;
     191        using CppAD::NearEqual;
     192        size_t j, k, ell;
     193        double eps = 10. * CppAD::epsilon<double>();
     194
     195        // domain space vector
     196        size_t n = 4;
     197        CPPAD_TEST_VECTOR< AD<double> >  X(n);
     198        for(j = 0; j < n; j++)
     199                X[j] = AD<double> (0);
     200
     201        // declare independent variables and starting recording
     202        CppAD::Independent(X);
     203
     204        size_t m = 3;
     205        CPPAD_TEST_VECTOR< AD<double> >  Y(m);
     206        Y[0] = 1.0*X[0] + 2.0*X[1];
     207        Y[1] = 3.0*X[2] + 4.0*X[3];
     208        Y[2] = 5.0*X[0] + 6.0*X[1] + 7.0*X[3]*X[3]/2.;
     209
     210        // create f: X -> Y and stop tape recording
     211        CppAD::ADFun<double> f(X, Y);
     212
     213        // new value for the independent variable vector
     214        VectorBase x(n);
     215        for(j = 0; j < n; j++)
     216                x[j] = double(j);
     217
     218        // Jacobian of y
     219        /*
     220              [ 1 2 0 0    ]
     221        jac = [ 0 0 3 4    ]
     222              [ 5 6 0 7*x_3]
     223        */
     224        VectorBase check(m * n);
     225        check[0] = 1.; check[1] = 2.; check[2]  = 0.; check[3]  = 0.;
     226        check[4] = 0.; check[5] = 0.; check[6]  = 3.; check[7]  = 4.;
     227        check[8] = 5.; check[9] = 6.; check[10] = 0.; check[11] = 7.*x[3];
     228        VectorBool s(m * n);
     229        s[0] = true;   s[1] = true;   s[2] = false;   s[3] = false;
     230        s[4] = false;  s[5] = false;  s[6] = true;    s[7] = true;
     231        s[8] = true;   s[9] = true;  s[10] = false;  s[11] = true;
     232
     233        // Use forward mode to compute columns 0 and 2
     234        // (make sure order of rows and columns does not matter)
     235        CPPAD_TEST_VECTOR<size_t> r(3), c(3);
     236        VectorBase jac(3);
     237        r[0] = 2; c[0] = 0;
     238        r[1] = 1; c[1] = 2;
     239        r[2] = 0; c[2] = 0;
     240        CppAD::sparse_jacobian_work work;
     241        size_t n_sweep = f.SparseJacobianForward(x, s, r, c, jac, work);
     242        for(k = 0; k < 3; k++)
     243        {       ell = r[k] * n + c[k];
     244                ok &=  NearEqual(check[ell], jac[k], eps, eps);
     245        }
     246        ok &= (n_sweep == 1);
     247
     248        // Use reverse mode to compute rows 0 and 1
     249        // (make sure order of rows and columns does not matter)
     250        r.resize(4), c.resize(4); jac.resize(4);
     251        r[0] = 0; c[0] = 0;
     252        r[1] = 1; c[1] = 2;
     253        r[2] = 0; c[2] = 1;
     254        r[3] = 1; c[3] = 3;
     255        work.clear();
     256        n_sweep = f.SparseJacobianReverse(x, s, r, c, jac, work);
     257        for(k = 0; k < 4; k++)
     258        {       ell = r[k] * n + c[k];
     259                ok &=  NearEqual(check[ell], jac[k], eps, eps);
     260        }
     261        ok &= (n_sweep == 1);
     262
     263        return ok;
     264}
     265
     266
     267template <class VectorBase, class VectorBool>
     268bool reverse_bool(void)
     269{       bool ok = true;
     270        using CppAD::AD;
     271        using CppAD::NearEqual;
     272        size_t i, j, k;
     273
     274        // domain space vector
     275        size_t n = 4;
     276        CPPAD_TEST_VECTOR< AD<double> >  X(n);
     277        for(j = 0; j < n; j++)
     278                X[j] = AD<double> (0);
     279
     280        // declare independent variables and starting recording
     281        CppAD::Independent(X);
     282
     283        size_t m = 3;
     284        CPPAD_TEST_VECTOR< AD<double> >  Y(m);
     285        Y[0] = 1.0*X[0] + 2.0*X[1];
     286        Y[1] = 3.0*X[2] + 4.0*X[3];
     287        Y[2] = 5.0*X[0] + 6.0*X[1] + 7.0*X[2] + 8.0*X[3]*X[3]/2.;
     288
     289        // create f: X -> Y and stop tape recording
     290        CppAD::ADFun<double> f(X, Y);
     291
     292        // new value for the independent variable vector
     293        VectorBase x(n);
     294        for(j = 0; j < n; j++)
     295                x[j] = double(j);
     296
     297        // Jacobian of y without sparsity pattern
     298        VectorBase jac(m * n);
     299        jac = f.SparseJacobian(x);
     300        /*
     301              [ 1 2 0 0    ]
     302        jac = [ 0 0 3 4    ]
     303              [ 5 6 7 8*x_3]
     304        */
     305        VectorBase check(m * n);
     306        check[0] = 1.; check[1] = 2.; check[2]  = 0.; check[3]  = 0.;
     307        check[4] = 0.; check[5] = 0.; check[6]  = 3.; check[7]  = 4.;
     308        check[8] = 5.; check[9] = 6.; check[10] = 7.; check[11] = 8.*x[3];
     309        for(k = 0; k < 12; k++)
     310                ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     311
     312        // test passing sparsity pattern
     313        VectorBool s(m * m);
     314        VectorBool p(m * n);
     315        for(i = 0; i < m; i++)
     316        {       for(k = 0; k < m; k++)
     317                        s[i * m + k] = false;
     318                s[i * m + i] = true;
     319        }
     320        p   = f.RevSparseJac(m, s);
     321        jac = f.SparseJacobian(x);
     322        for(k = 0; k < 12; k++)
     323                ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
     324
     325        return ok;
     326}
     327
     328template <class VectorBase, class VectorSet>
     329bool reverse_set(void)
    22330{       bool ok = true;
    23331        using CppAD::AD;
     
    64372
    65373        // test passing sparsity pattern
    66         VectorBool s(m * m);
    67         VectorBool p(m * n);
    68         for(i = 0; i < m; i++)
    69         {       for(k = 0; k < m; k++)
    70                         s[i * m + k] = false;
    71                 s[i * m + i] = true;
    72         }
    73         p   = f.RevSparseJac(m, s);
    74         jac = f.SparseJacobian(x);
    75         for(k = 0; k < 12; k++)
    76                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
    77 
    78         return ok;
    79 }
    80 
    81 template <class VectorBase, class VectorSet>
    82 bool reverse_set()
    83 {       bool ok = true;
    84         using CppAD::AD;
    85         using CppAD::NearEqual;
    86         size_t i, j, k;
    87 
    88         // domain space vector
    89         size_t n = 4;
    90         CPPAD_TEST_VECTOR< AD<double> >  X(n);
    91         for(j = 0; j < n; j++)
    92                 X[j] = AD<double> (0);
    93 
    94         // declare independent variables and starting recording
    95         CppAD::Independent(X);
    96 
    97         size_t m = 3;
    98         CPPAD_TEST_VECTOR< AD<double> >  Y(m);
    99         Y[0] = X[0] + X[1];
    100         Y[1] = X[2] + X[3];
    101         Y[2] = X[0] + X[1] + X[2] + X[3] * X[3] / 2.;
    102 
    103         // create f: X -> Y and stop tape recording
    104         CppAD::ADFun<double> f(X, Y);
    105 
    106         // new value for the independent variable vector
    107         VectorBase x(n);
    108         for(j = 0; j < n; j++)
    109                 x[j] = double(j);
    110 
    111         // Jacobian of y without sparsity pattern
    112         VectorBase jac(m * n);
    113         jac = f.SparseJacobian(x);
    114         /*
    115               [ 1 1 0 0  ]
    116         jac = [ 0 0 1 1  ]
    117               [ 1 1 1 x_3]
    118         */
    119         VectorBase check(m * n);
    120         check[0] = 1.; check[1] = 1.; check[2]  = 0.; check[3]  = 0.;
    121         check[4] = 0.; check[5] = 0.; check[6]  = 1.; check[7]  = 1.;
    122         check[8] = 1.; check[9] = 1.; check[10] = 1.; check[11] = x[3];
    123         for(k = 0; k < 12; k++)
    124                 ok &=  NearEqual(check[k], jac[k], 1e-10, 1e-10 );
    125 
    126         // test passing sparsity pattern
    127374        VectorSet s(m), p(m);
    128375        for(i = 0; i < m; i++)
     
    137384
    138385template <class VectorBase, class VectorBool>
    139 bool forward_bool()
     386bool forward_bool(void)
    140387{       bool ok = true;
    141388        using CppAD::AD;
     
    201448
    202449template <class VectorBase, class VectorSet>
    203 bool forward_set()
     450bool forward_set(void)
    204451{       bool ok = true;
    205452        using CppAD::AD;
     
    260507}
    261508
    262 bool multiple_of_n_bit()
     509bool multiple_of_n_bit(void)
    263510{       bool ok = true;
    264511        using CppAD::AD;
     
    308555bool sparse_jacobian(void)
    309556{       bool ok = true;
     557        ok &= rc_tridiagonal();
     558        ok &= multiple_of_n_bit();
    310559        // ---------------------------------------------------------------
    311560        // vector of bool cases
    312         ok &= forward_bool< CppAD::vector<double>, CppAD::vectorBool   >();
    313         ok &= reverse_bool< CppAD::vector<double>, CppAD::vector<bool> >();
     561        ok &=      rc_bool< CppAD::vector<double>, CppAD::vectorBool   >();
     562        ok &= forward_bool< CppAD::vector<double>, CppAD::vector<bool> >();
    314563        //
    315         ok &= forward_bool< std::vector<double>,   std::vector<bool>   >();
    316         ok &= reverse_bool< std::vector<double>,   std::valarray<bool> >();
     564        ok &= reverse_bool< std::vector<double>,   std::vector<bool>   >();
     565        ok &=      rc_bool< std::vector<double>,   std::valarray<bool> >();
    317566        //
    318567        ok &= forward_bool< std::valarray<double>, CppAD::vectorBool   >();
     
    324573        typedef CppAD::vector< std::set<size_t> > cppad_vector_set;
    325574        //
    326         ok &= forward_set< CppAD::vector<double>, std_vector_set   >();
    327         ok &= reverse_set< std::valarray<double>, std_vector_set   >();
     575        ok &=      rc_set< CppAD::vector<double>, std_vector_set   >();
     576        ok &= forward_set< std::valarray<double>, std_vector_set   >();
    328577        //
    329         ok &= forward_set< std::vector<double>,   cppad_vector_set >();
    330         ok &= reverse_set< CppAD::vector<double>, cppad_vector_set >();
     578        ok &= reverse_set< std::vector<double>,   cppad_vector_set >();
     579        ok &=      rc_set< CppAD::vector<double>, cppad_vector_set >();
    331580        //
    332581        // According to section 26.3.2.3 of the 1998 C++ standard
     
    336585        // ---------------------------------------------------------------
    337586        //
    338         ok &= multiple_of_n_bit();
    339         return ok;
    340 }
     587        return ok;
     588}
Note: See TracChangeset for help on using the changeset viewer.