Changeset 1531


Ignore:
Timestamp:
Sep 25, 2009 12:23:54 PM (11 years ago)
Author:
bradbell
Message:

trunk: Change BaseVector? to VectorBase?, BoolVector? to VectorBool?.

makefile.in: update corresponding version of makefile.am.

Location:
trunk
Files:
9 edited

Legend:

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

    r1524 r1531  
    102102
    103103        // reverse mode Jacobian sparsity
    104         template <typename VectorBase>
    105         VectorBase RevSparseJac(size_t q, const VectorBase &Py);
     104        template <typename VectorBool>
     105        VectorBool RevSparseJac(size_t q, const VectorBool &Py);
    106106
    107107        // reverse mode Hessian sparsity
    108         template <typename VectorBase>
    109         VectorBase RevSparseHes(size_t q, const VectorBase &Py);
     108        template <typename VectorBool>
     109        VectorBool RevSparseHes(size_t q, const VectorBool &Py);
    110110
    111111        // does this AD operation sequence use VecAD<Base>::reference operands
     
    192192
    193193        // calculate sparse Jacobians
    194         template <typename BaseVector>
    195         BaseVector SparseJacobian(const BaseVector &x);
    196 
    197         template <typename BaseVector, typename BoolVector>
    198         BaseVector SparseJacobian(const BaseVector &x, const BoolVector &p);
     194        template <typename VectorBase>
     195        VectorBase SparseJacobian(const VectorBase &x);
     196
     197        template <typename VectorBase, typename VectorBool>
     198        VectorBase SparseJacobian(const VectorBase &x, const VectorBool &p);
    199199
    200200        // calculate sparse Hessians
    201         template <typename BaseVector>
    202         BaseVector SparseHessian(const BaseVector &x, const BaseVector &w);
    203 
    204         template <typename BaseVector, typename BoolVector>
    205         BaseVector SparseHessian(
    206                 const BaseVector &x, const BaseVector &w, const BoolVector &p
     201        template <typename VectorBase>
     202        VectorBase SparseHessian(const VectorBase &x, const VectorBase &w);
     203
     204        template <typename VectorBase, typename VectorBool>
     205        VectorBase SparseHessian(
     206                const VectorBase &x, const VectorBase &w, const VectorBool &p
    207207        );
    208208
  • trunk/cppad/local/for_sparse_jac.hpp

    r1527 r1531  
    8484The argument $italic r$$ has prototype
    8585$syntax%
    86         const %Vector% &%r%
    87 %$$
    88 (see $xref/ForSparseJac/Vector/Vector/$$ below)
     86        const %VectorBool% &%r%
     87%$$
     88(see $xref/ForSparseJac/VectorBool/VectorBool/$$ below)
    8989and its size is $latex n * q$$.
    9090It specifies a
     
    9999The return value $italic s$$ has prototype
    100100$syntax%
    101         %Vector% %s%
    102 %$$
    103 (see $xref/ForSparseJac/Vector/Vector/$$ below)
     101        %VectorBool% %s%
     102%$$
     103(see $xref/ForSparseJac/VectorBool/VectorBool/$$ below)
    104104and its size is $latex m * q$$.
    105105It specifies a
     
    113113\] $$
    114114
    115 $head Vector$$
    116 The type $italic Vector$$ must be a $xref/SimpleVector/$$ class with
     115$head VectorBool$$
     116The type $italic VectorBool$$ must be a $xref/SimpleVector/$$ class with
    117117$xref/SimpleVector/Elements of Specified Type/elements of type bool/$$.
    118118The routine $xref/CheckSimpleVector/$$ will generate an error message
     
    156156
    157157template <class Base>
    158 template <class Vector>
    159 Vector ADFun<Base>::ForSparseJac(size_t q, const Vector &r)
     158template <class VectorBool>
     159VectorBool ADFun<Base>::ForSparseJac(size_t q, const VectorBool &r)
    160160{
    161161        // temporary indices
    162162        size_t i, j;
    163163
    164         // check Vector is Simple Vector class with bool elements
    165         CheckSimpleVector<bool, Vector>();
     164        // check VectorBool is Simple Vector class with bool elements
     165        CheckSimpleVector<bool, VectorBool>();
    166166
    167167        // range and domain dimensions for F
     
    203203
    204204        // return values corresponding to dependent variables
    205         Vector s(m * q);
     205        VectorBool s(m * q);
    206206        for(i = 0; i < m; i++)
    207207        {       CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < total_num_var_ );
  • trunk/cppad/local/rev_sparse_hes.hpp

    r1527 r1531  
    112112The argument $italic s$$ has prototype
    113113$syntax%
    114         const %Vector% &%s%
    115 %$$
    116 (see $xref/RevSparseHes/Vector/Vector/$$ below)
     114        const %VectorBool% &%s%
     115%$$
     116(see $xref/RevSparseHes/VectorBool/VectorBool/$$ below)
    117117and its size is $latex m$$.
    118118It specifies a
     
    127127The result $italic h$$ has prototype
    128128$syntax%
    129         %Vector% &%h%
    130 %$$
    131 (see $xref/RevSparseHes/Vector/Vector/$$ below)
     129        %VectorBool% &%h%
     130%$$
     131(see $xref/RevSparseHes/VectorBool/VectorBool/$$ below)
    132132and its size is $latex q * n$$,
    133133It specifies a
     
    141141\] $$
    142142
    143 $head Vector$$
    144 The type $italic Vector$$ must be a $xref/SimpleVector/$$ class with
     143$head VectorBool$$
     144The type $italic VectorBool$$ must be a $xref/SimpleVector/$$ class with
    145145$xref/SimpleVector/Elements of Specified Type/elements of type bool/$$.
    146146The routine $xref/CheckSimpleVector/$$ will generate an error message
     
    195195
    196196template <class Base>
    197 template <class Vector>
    198 Vector ADFun<Base>::RevSparseHes(size_t q,  const Vector &s)
     197template <class VectorBool>
     198VectorBool ADFun<Base>::RevSparseHes(size_t q,  const VectorBool &s)
    199199{
    200200        // temporary indices
    201201        size_t i, j;
    202202
    203         // check Vector is Simple Vector class with bool elements
    204         CheckSimpleVector<bool, Vector>();
     203        // check Vector is Simple VectorBool class with bool elements
     204        CheckSimpleVector<bool, VectorBool>();
    205205
    206206        // range and domain dimensions for F
     
    247247
    248248        // return values corresponding to independent variables
    249         Vector h(n * q);
     249        VectorBool h(n * q);
    250250
    251251        // j is index corresponding to reverse mode martial
  • trunk/cppad/local/rev_sparse_jac.hpp

    r1527 r1531  
    8080The argument $italic s$$ has prototype
    8181$syntax%
    82         const %Vector% &%s%
    83 %$$
    84 (see $xref/RevSparseJac/Vector/Vector/$$ below)
     82        const %VectorBool% &%s%
     83%$$
     84(see $xref/RevSparseJac/VectorBool/VectorBool/$$ below)
    8585and its size is $latex p * m$$.
    8686It specifies a
     
    9595The return value $italic r$$ has prototype
    9696$syntax%
    97         %Vector% %r%
    98 %$$
    99 (see $xref/RevSparseJac/Vector/Vector/$$ below)
     97        %VectorBool% %r%
     98%$$
     99(see $xref/RevSparseJac/VectorBool/VectorBool/$$ below)
    100100and its size is $latex p * n$$.
    101101It specifies a
     
    109109\] $$
    110110
    111 $head Vector$$
    112 The type $italic Vector$$ must be a $xref/SimpleVector/$$ class with
     111$head VectorBool$$
     112The type $italic VectorBool$$ must be a $xref/SimpleVector/$$ class with
    113113$xref/SimpleVector/Elements of Specified Type/elements of type bool/$$.
    114114The routine $xref/CheckSimpleVector/$$ will generate an error message
     
    154154
    155155template <class Base>
    156 template <class Vector>
    157 Vector ADFun<Base>::RevSparseJac(size_t p, const Vector &s)
     156template <class VectorBool>
     157VectorBool ADFun<Base>::RevSparseJac(size_t p, const VectorBool &s)
    158158{
    159159        // temporary indices
    160160        size_t i, j;
    161161
    162         // check Vector is Simple Vector class with bool elements
    163         CheckSimpleVector<bool, Vector>();
     162        // check VectorBool is Simple Vector class with bool elements
     163        CheckSimpleVector<bool, VectorBool>();
    164164
    165165        // range and domain dimensions for F
     
    199199
    200200        // return values corresponding to dependent variables
    201         Vector r(p * n);
     201        VectorBool r(p * n);
    202202        for(j = 0; j < n; j++)
    203203        {       CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] == (j+1) );
  • trunk/cppad/local/sparse_hessian.hpp

    r1369 r1531  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5656The argument $icode x$$ has prototype
    5757$codei%
    58         const %BaseVector% &%x%
    59 %$$
    60 (see $cref/BaseVector/sparse_hessian/BaseVector/$$ below)
     58        const %VectorBase% &%x%
     59%$$
     60(see $cref/VectorBase/sparse_hessian/VectorBase/$$ below)
    6161and its size
    6262must be equal to $icode n$$, the dimension of the
     
    6868The argument $icode w$$ has prototype
    6969$codei%
    70         const %BaseVector% &%w%
     70        const %VectorBase% &%w%
    7171%$$
    7272and size $latex m$$.
     
    8080The argument $icode p$$ is optional and has prototype
    8181$syntax%
    82         const %BoolVector% &%p%
    83 %$$
    84 (see $cref/BoolVector/sparse_hessian/BoolVector/$$ below)
     82        const %VectorBool% &%p%
     83%$$
     84(see $cref/VectorBool/sparse_hessian/VectorBool/$$ below)
    8585and its size is $latex n * n$$.
    8686It specifies a
     
    102102The result $icode hes$$ has prototype
    103103$codei%
    104         %BaseVector% %hes%
     104        %VectorBase% %hes%
    105105%$$
    106106and its size is $latex n * n$$.
     
    111111\] $$
    112112
    113 $head BaseVector$$
    114 The type $icode BaseVector$$ must be a $cref/SimpleVector/$$ class with
     113$head VectorBase$$
     114The type $icode VectorBase$$ must be a $cref/SimpleVector/$$ class with
    115115$cref/elements of type/SimpleVector/Elements of Specified Type/$$
    116116$icode Base$$.
     
    118118if this is not the case.
    119119
    120 $head BoolVector$$
    121 The type $icode BoolVector$$ must be a $xref/SimpleVector/$$ class with
     120$head VectorBool$$
     121The type $icode VectorBool$$ must be a $xref/SimpleVector/$$ class with
    122122$xref/SimpleVector/Elements of Specified Type/elements of type bool/$$.
    123123The routine $xref/CheckSimpleVector/$$ will generate an error message
     
    156156
    157157template <typename Base>
    158 template <typename BaseVector>
    159 BaseVector ADFun<Base>::SparseHessian(const BaseVector &x, const BaseVector &w)
     158template <typename VectorBase>
     159VectorBase ADFun<Base>::SparseHessian(const VectorBase &x, const VectorBase &w)
    160160{       size_t i, j, k;
    161161
    162         typedef CppAD::vector<bool>   BoolVector;
     162        typedef CppAD::vector<bool>   VectorBool;
    163163
    164164        size_t m = Range();
     
    166166
    167167        // determine the sparsity pattern p for Hessian of w^T F
    168         BoolVector r(n * n);
     168        VectorBool r(n * n);
    169169        for(j = 0; j < n; j++)
    170170        {       for(k = 0; k < n; k++)
     
    174174        ForSparseJac(n, r);
    175175        //
    176         BoolVector s(m);
     176        VectorBool s(m);
    177177        for(i = 0; i < m; i++)
    178178                s[i] = w[i] != 0;
    179         BoolVector p = RevSparseHes(n, s);
     179        VectorBool p = RevSparseHes(n, s);
    180180
    181181        // compute sparse Hessian
     
    184184
    185185template <typename Base>
    186 template <typename BaseVector, typename BoolVector>
    187 BaseVector ADFun<Base>::SparseHessian(
    188         const BaseVector &x ,
    189         const BaseVector &w ,
    190         const BoolVector &p )
     186template <typename VectorBase, typename VectorBool>
     187VectorBase ADFun<Base>::SparseHessian(
     188        const VectorBase &x ,
     189        const VectorBase &w ,
     190        const VectorBool &p )
    191191{
    192192        typedef CppAD::vector<size_t> SizeVector;
     
    196196
    197197        // check Vector is Simple Vector class with bool elements
    198         CheckSimpleVector<bool, BoolVector>();
     198        CheckSimpleVector<bool, VectorBool>();
    199199
    200200        // check Vector is Simple Vector class with Base type elements
    201         CheckSimpleVector<Base, BaseVector>();
     201        CheckSimpleVector<Base, VectorBase>();
    202202
    203203        CPPAD_ASSERT_KNOWN(
     
    223223        // Graph Coloring in Optimization Revisited by
    224224        // Assefaw Gebremedhin, Fredrik Maane, Alex Pothen
    225         BoolVector    forbidden(n);
     225        VectorBool    forbidden(n);
    226226        for(j = 0; j < n; j++)
    227227        {       // initial all colors as ok for this column
     
    252252
    253253        // define the return value
    254         BaseVector h(n * n);
     254        VectorBase h(n * n);
    255255        for(j = 0; j < n; j++)
    256256                for(k = 0; k < n; k++)
     
    258258
    259259        // direction vector for calls to forward
    260         BaseVector u(n);
     260        VectorBase u(n);
    261261
    262262        // location for return values from Reverse
    263         BaseVector ddw(n * 2);
     263        VectorBase ddw(n * 2);
    264264
    265265        // loop over colors
  • trunk/cppad/local/sparse_jacobian.hpp

    r1369 r1531  
    44
    55/* --------------------------------------------------------------------------
    6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    77
    88CppAD is distributed under multiple licenses. This distribution is under
     
    5757The argument $icode x$$ has prototype
    5858$codei%
    59         const %BaseVector% &%x%
    60 %$$
    61 (see $cref/BaseVector/sparse_jacobian/BaseVector/$$ below)
     59        const %VectorBase% &%x%
     60%$$
     61(see $cref/VectorBase/sparse_jacobian/VectorBase/$$ below)
    6262and its size
    6363must be equal to $icode n$$, the dimension of the
     
    6969The argument $icode p$$ is optional and has prototype
    7070$syntax%
    71         const %BoolVector% &%p%
    72 %$$
    73 (see $cref/BoolVector/sparse_jacobian/BoolVector/$$ below)
     71        const %VectorBool% &%p%
     72%$$
     73(see $cref/VectorBool/sparse_jacobian/VectorBool/$$ below)
    7474and its size is $latex m * n$$.
    7575It specifies a
     
    9090The result $icode jac$$ has prototype
    9191$codei%
    92         %BaseVector% %jac%
     92        %VectorBase% %jac%
    9393%$$
    9494and its size is $latex m * n$$.
     
    9999\] $$
    100100
    101 $head BaseVector$$
    102 The type $icode BaseVector$$ must be a $cref/SimpleVector/$$ class with
     101$head VectorBase$$
     102The type $icode VectorBase$$ must be a $cref/SimpleVector/$$ class with
    103103$cref/elements of type/SimpleVector/Elements of Specified Type/$$
    104104$icode Base$$.
     
    106106if this is not the case.
    107107
    108 $head BoolVector$$
    109 The type $icode BoolVector$$ must be a $xref/SimpleVector/$$ class with
     108$head VectorBool$$
     109The type $icode VectorBool$$ must be a $xref/SimpleVector/$$ class with
    110110$xref/SimpleVector/Elements of Specified Type/elements of type bool/$$.
    111111The routine $xref/CheckSimpleVector/$$ will generate an error message
     
    143143
    144144template <class Base>
    145 template <class BaseVector>
    146 BaseVector ADFun<Base>::SparseJacobian(const BaseVector &x)
    147 {       typedef CppAD::vector<bool>   BoolVector;
     145template <class VectorBase>
     146VectorBase ADFun<Base>::SparseJacobian(const VectorBase &x)
     147{       typedef CppAD::vector<bool>   VectorBool;
    148148
    149149        size_t m = Range();
     
    151151
    152152        // sparsity pattern for Jacobian
    153         BoolVector p(n * m);
     153        VectorBool p(n * m);
    154154
    155155        if( n <= m )
     
    157157
    158158                // use forward mode
    159                 BoolVector r(n * n);
     159                VectorBool r(n * n);
    160160                for(j = 0; j < n; j++)
    161161                {       for(k = 0; k < n; k++)
     
    169169
    170170                // use reverse mode
    171                 BoolVector s(m * m);
     171                VectorBool s(m * m);
    172172                for(i = 0; i < m; i++)
    173173                {       for(k = 0; k < m; k++)
     
    181181
    182182template <class Base>
    183 template <class BaseVector, class BoolVector>
    184 BaseVector ADFun<Base>::SparseJacobian(const BaseVector &x, const BoolVector &p)
     183template <class VectorBase, class VectorBool>
     184VectorBase ADFun<Base>::SparseJacobian(const VectorBase &x, const VectorBool &p)
    185185{
    186186        typedef CppAD::vector<size_t> SizeVector;
     
    194194        const Base one(1);
    195195
    196         // check BoolVector is Simple Vector class with bool elements
    197         CheckSimpleVector<bool, BoolVector>();
    198 
    199         // check BaseVector is Simple Vector class with Base type elements
    200         CheckSimpleVector<Base, BaseVector>();
     196        // check VectorBool is Simple Vector class with bool elements
     197        CheckSimpleVector<bool, VectorBool>();
     198
     199        // check VectorBase is Simple Vector class with Base type elements
     200        CheckSimpleVector<Base, VectorBase>();
    201201
    202202        CPPAD_ASSERT_KNOWN(
     
    215215
    216216        // initialize the return value
    217         BaseVector jac(m * n);
     217        VectorBase jac(m * n);
    218218        for(i = 0; i < m; i++)
    219219                for(j = 0; j < n; j++)
     
    231231                // Graph Coloring in Optimization Revisited by
    232232                // Assefaw Gebremedhin, Fredrik Maane, Alex Pothen
    233                 BoolVector    forbidden(n);
     233                VectorBool    forbidden(n);
    234234                for(j = 0; j < n; j++)
    235235                {       // initial all colors as ok for this column
     
    255255
    256256                // direction vector for calls to forward
    257                 BaseVector dx(n);
     257                VectorBase dx(n);
    258258
    259259                // location for return values from Reverse
    260                 BaseVector dy(m);
     260                VectorBase dy(m);
    261261
    262262                // loop over colors
     
    291291                // Graph Coloring in Optimization Revisited by
    292292                // Assefaw Gebremedhin, Fredrik Maane, Alex Pothen
    293                 BoolVector    forbidden(m);
     293                VectorBool    forbidden(m);
    294294                for(i = 0; i < m; i++)
    295295                {       // initial all colors as ok for this row
     
    315315
    316316                // weight vector for calls to reverse
    317                 BaseVector w(m);
     317                VectorBase w(m);
    318318
    319319                // location for return values from Reverse
    320                 BaseVector dw(n);
     320                VectorBase dw(n);
    321321
    322322                // loop over colors
  • trunk/example/sparse_hessian.cpp

    r1370 r1531  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3636namespace { // ---------------------------------------------------------
    3737// define the template function in empty namespace
    38 template <class BaseVector, class BoolVector>
     38template <class VectorBase, class VectorBool>
    3939bool Case()
    4040{       bool ok = true;
     
    6060
    6161        // new value for the independent variable vector
    62         BaseVector x(n);
     62        VectorBase x(n);
    6363        for(i = 0; i < n; i++)
    6464                x[i] = double(i);
    6565
    6666        // second derivative of y[1]
    67         BaseVector w(m);
     67        VectorBase w(m);
    6868        w[0] = 1.;
    69         BaseVector h( n * n );
     69        VectorBase h( n * n );
    7070        h = f.SparseHessian(x, w);
    7171        /*
     
    7474            [ 0 0 2 ]
    7575        */
    76         BaseVector check(n * n);
     76        VectorBase check(n * n);
    7777        check[0] = 2.; check[1] = 1.; check[2] = 0.;
    7878        check[3] = 1.; check[4] = 2.; check[5] = 0.;
     
    8282
    8383        // determine the sparsity pattern p for Hessian of w^T F
    84         BoolVector r(n * n);
     84        VectorBool r(n * n);
    8585        for(j = 0; j < n; j++)
    8686        {       for(k = 0; k < n; k++)
     
    9090        f.ForSparseJac(n, r);
    9191        //
    92         BoolVector s(m);
     92        VectorBool s(m);
    9393        for(i = 0; i < m; i++)
    9494                s[i] = w[i] != 0;
    95         BoolVector p = f.RevSparseHes(n, s);
     95        VectorBool p = f.RevSparseHes(n, s);
    9696
    9797        // test passing sparsity pattern
     
    107107bool sparse_hessian(void)
    108108{       bool ok = true;
    109         // Run with BaseVector equal to three different cases
     109        // Run with VectorBase equal to three different cases
    110110        // all of which are Simple Vectors with elements of type double.
    111         // Also vary the type of vector for BoolVector.
     111        // Also vary the type of vector for VectorBool.
    112112        ok &= Case< CppAD::vector  <double>, CppAD::vectorBool   >();
    113113        ok &= Case< std::vector    <double>, CppAD::vector<bool> >();
  • trunk/example/sparse_jacobian.cpp

    r1370 r1531  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    3636namespace { // ---------------------------------------------------------
    3737// define the template function in empty namespace
    38 template <class BaseVector, class BoolVector>
     38template <class VectorBase, class VectorBool>
    3939bool reverse_case()
    4040{       bool ok = true;
     
    6262
    6363        // new value for the independent variable vector
    64         BaseVector x(n);
     64        VectorBase x(n);
    6565        for(j = 0; j < n; j++)
    6666                x[j] = double(j);
    6767
    6868        // Jacobian of y without sparsity pattern
    69         BaseVector jac(m * n);
     69        VectorBase jac(m * n);
    7070        jac = f.SparseJacobian(x);
    7171        /*
     
    7474              [ 1 1 1 x_3]
    7575        */
    76         BaseVector check(m * n);
     76        VectorBase check(m * n);
    7777        check[0] = 1.; check[1] = 1.; check[2]  = 0.; check[3]  = 0.;
    7878        check[4] = 0.; check[5] = 0.; check[6]  = 1.; check[7]  = 1.;
     
    8282
    8383        // test passing sparsity pattern
    84         BoolVector s(m * m);
    85         BoolVector p(m * n);
     84        VectorBool s(m * m);
     85        VectorBool p(m * n);
    8686        for(i = 0; i < m; i++)
    8787        {       for(k = 0; k < m; k++)
     
    9797}
    9898
    99 template <class BaseVector, class BoolVector>
     99template <class VectorBase, class VectorBool>
    100100bool forward_case()
    101101{       bool ok = true;
     
    124124
    125125        // new value for the independent variable vector
    126         BaseVector x(n);
     126        VectorBase x(n);
    127127        for(j = 0; j < n; j++)
    128128                x[j] = double(j);
    129129
    130130        // Jacobian of y without sparsity pattern
    131         BaseVector jac(m * n);
     131        VectorBase jac(m * n);
    132132        jac = f.SparseJacobian(x);
    133133        /*
     
    137137              [ 0 1 x_2 ]
    138138        */
    139         BaseVector check(m * n);
     139        VectorBase check(m * n);
    140140        check[0] = 1.; check[1]  = 0.; check[2]  = 1.;
    141141        check[3] = 1.; check[4]  = 0.; check[5]  = 1.;
     
    146146
    147147        // test passing sparsity pattern
    148         BoolVector r(n * n);
    149         BoolVector p(m * n);
     148        VectorBool r(n * n);
     149        VectorBool p(m * n);
    150150        for(j = 0; j < n; j++)
    151151        {       for(k = 0; k < n; k++)
     
    165165bool sparse_jacobian(void)
    166166{       bool ok = true;
    167         // Run with BaseVector equal to three different cases
     167        // Run with VectorBase equal to three different cases
    168168        // all of which are Simple Vectors with elements of type double.
    169         // Also vary the type of vector for BoolVector.
     169        // Also vary the type of vector for VectorBool.
    170170        ok &= forward_case< CppAD::vector<double>, CppAD::vectorBool   >();
    171171        ok &= reverse_case< CppAD::vector<double>, CppAD::vector<bool> >();
  • trunk/makefile.in

    r1529 r1531  
    236236@CppAD_POSTFIX_FALSE@postfix_dir = .
    237237
    238 # $Id: makefile.am 1528 2009-09-22 15:49:50Z bradbell $
     238# $Id: makefile.am 1529 2009-09-25 14:54:21Z bradbell $
    239239# -----------------------------------------------------------------------------
    240240# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
Note: See TracChangeset for help on using the changeset viewer.