Changeset 1539


Ignore:
Timestamp:
Oct 6, 2009 8:13:06 AM (11 years ago)
Author:
bradbell
Message:

trunk: Change VectorSet? to Sparsity (will use VectorSet? for something else).

Automatic editing sed script:

s/VectorSet& /Sparsity\& /g
s/VectorSet /Sparsity /g
s/VectorSet/Sparsity/g
s/vector_pack/sparse_pack/g
s/vector_set/sparse_set/g

Moved files:

vector_pack.hpp -> sparse_pack.hpp
vector_set.hpp -> sparse_set.hpp

./makefile.am: edit with sed script above.
*/makefile.in: update date for corresponding makefile.am.

Location:
trunk
Files:
19 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/check_doxygen.sh

    r1535 r1539  
    1616        player
    1717        recorder
    18         vector_pack
    19         vector_set
     18        sparse_pack
     19        sparse_set
    2020"
    2121# files that have been completely documented
     
    6060        store_op.hpp
    6161        sub_op.hpp
    62         vector_pack.hpp
    63         vector_set.hpp
     62        sparse_pack.hpp
     63        sparse_set.hpp
    6464"
    6565# --------------------------------------------------------------------------
  • trunk/cppad/local/ad_fun.hpp

    r1535 r1539  
    109109        /// (\c for_jac_sparse_pack_.n_set() != 0  implies
    110110        /// for_jac_sparse_set_.n_set() == 0)
    111         vector_pack      for_jac_sparse_pack_;
     111        sparse_pack      for_jac_sparse_pack_;
    112112
    113113        /// set results of the forward mode Jacobian sparsity calculations
    114114        /// (\c for_jac_sparse_set_.n_set() != 0  implies
    115115        /// for_jac_sparse_pack_.n_set() == 0)
    116         vector_set       for_jac_sparse_set_;
     116        sparse_set       for_jac_sparse_set_;
    117117
    118118        /// change the operation sequence corresponding to this object
  • trunk/cppad/local/for_jac_sweep.hpp

    r1536 r1539  
    3838\tparam Vector_set
    3939is the type used for vectors of sets. It can be either
    40 \c vector_pack or \c vector_set.
     40\c sparse_pack or \c sparse_set.
    4141
    4242\param n
  • trunk/cppad/local/for_sparse_jac.hpp

    r1537 r1539  
    188188is a simple vector with elements of type bool.
    189189
    190 \tparam VectorSet
    191 is either \c vector_pack or \c vector_set.
     190\tparam Sparsity
     191is either \c sparse_pack or \c sparse_set.
    192192
    193193\param q
     
    231231tape (given the sparsity pattern for the independent variables is \f$ R \f$).
    232232*/
    233 template <class Base, class VectorBool, class VectorSet>
     233template <class Base, class VectorBool, class Sparsity>
    234234void ForSparseJac(
    235235        size_t                 q                ,
     
    240240        CppAD::vector<size_t>& ind_taddr        ,
    241241        CppAD::player<Base>&   play             ,
    242         VectorSet&             for_jac_sparsity )
     242        Sparsity&              for_jac_sparsity )
    243243{
    244244        // temporary indices
     
    325325
    326326\param packed
    327 If \a packed is true, the type \c vector_pack is used for the calculations.
    328 Otherwise the type \c vector_set is used for the calculations.
     327If \a packed is true, the type \c sparse_pack is used for the calculations.
     328Otherwise the type \c sparse_set is used for the calculations.
    329329
    330330\return
  • trunk/cppad/local/op.hpp

    r1529 r1539  
    1515
    1616// used by the sparse operators
    17 # include <cppad/local/vector_pack.hpp>
    18 # include <cppad/local/vector_set.hpp>
     17# include <cppad/local/sparse_pack.hpp>
     18# include <cppad/local/sparse_set.hpp>
    1919
    2020// operations
  • trunk/cppad/local/prototype_op.hpp

    r1529 r1539  
    10391039\tparam Vector_set
    10401040is the type used for vectors of sets. It can be either
    1041 \c vector_pack or \c vector_set.
     1041\c sparse_pack or \c sparse_set.
    10421042
    10431043\param op
     
    12261226\tparam Vector_set
    12271227is the type used for vectors of sets. It can be either
    1228 \c vector_pack or \c vector_set.
     1228\c sparse_pack or \c sparse_set.
    12291229
    12301230
     
    13071307\tparam Vector_set
    13081308is the type used for vectors of sets. It can be either
    1309 \c vector_pack or \c vector_set.
     1309\c sparse_pack or \c sparse_set.
    13101310
    13111311\param i_z
     
    13721372\tparam Vector_set
    13731373is the type used for vectors of sets. It can be either
    1374 \c vector_pack or \c vector_set.
     1374\c sparse_pack or \c sparse_set.
    13751375
    13761376\param i_z
     
    15501550\tparam Vector_set
    15511551is the type used for vectors of sets. It can be either
    1552 \c vector_pack or \c vector_set.
     1552\c sparse_pack or \c sparse_set.
    15531553
    15541554\param i_z
  • trunk/cppad/local/rev_hes_sweep.hpp

    r1536 r1539  
    4141\tparam Vector_set
    4242is the type used for vectors of sets. It can be either
    43 \c vector_pack or \c vector_set.
     43\c sparse_pack or \c sparse_set.
    4444
    4545\param n
  • trunk/cppad/local/rev_jac_sweep.hpp

    r1536 r1539  
    3939\tparam Vector_set
    4040is the type used for vectors of sets. It can be either
    41 \c vector_pack or \c vector_set.
     41\c sparse_pack or \c sparse_set.
    4242
    4343\param n
  • trunk/cppad/local/rev_sparse_hes.hpp

    r1536 r1539  
    226226is a simple vector with elements of type bool.
    227227
    228 \tparam VectorSet
    229 is either \c vector_pack or \c vector_set.
     228\tparam Sparsity
     229is either \c sparse_pack or \c sparse_set.
    230230
    231231\param q
     
    273273*/
    274274
    275 template <class Base, class VectorBool, class VectorSet>
     275template <class Base, class VectorBool, class Sparsity>
    276276void RevSparseHes(
    277277        size_t                    q                 ,
     
    282282        CppAD::vector<size_t>&    ind_taddr         ,
    283283        CppAD::player<Base>&      play              ,
    284         VectorSet&                for_jac_sparsity  )
     284        Sparsity&                 for_jac_sparsity  )
    285285{
    286286        // temporary indices
     
    318318
    319319        // vector of sets that will hold packed reverse Hessain values
    320         VectorSet      rev_hes_sparsity;
     320        Sparsity       rev_hes_sparsity;
    321321        rev_hes_sparsity.resize(total_num_var, q);
    322322
     
    409409        if( for_jac_sparse_pack_.n_set() > 0 )
    410410        {       CPPAD_ASSERT_UNKNOWN( for_jac_sparse_set_.n_set() == 0 );
    411                 // use vector_pack for the calculation
     411                // use sparse_pack for the calculation
    412412                CppAD::RevSparseHes(
    413413                        q                 ,
     
    423423        else
    424424        {       CPPAD_ASSERT_UNKNOWN( for_jac_sparse_pack_.n_set() == 0 );
    425                 // use vector_pack for the calculation
     425                // use sparse_pack for the calculation
    426426                CppAD::RevSparseHes(
    427427                        q                    ,
  • trunk/cppad/local/rev_sparse_jac.hpp

    r1536 r1539  
    187187is a simple vector with elements of type bool.
    188188
    189 \tparam VectorSet
    190 is either \c vector_pack or \c vector_set.
     189\tparam Sparsity
     190is either \c sparse_pack or \c sparse_set.
    191191
    192192\param p
     
    224224*/
    225225
    226 template <class Base, class VectorBool, class VectorSet>
     226template <class Base, class VectorBool, class Sparsity>
    227227void ForSparseJac(
    228228        size_t                 p                ,
     
    256256
    257257        // vector of sets that will hold the results
    258         VectorSet      var_sparsity;
     258        Sparsity       var_sparsity;
    259259        var_sparsity.resize(total_num_var, p);
    260260
     
    318318
    319319\param packed
    320 If \a packed is true, the type \c vector_pack is used for the calculations.
    321 Otherwise the type \c vector_set is used for the calculations.
     320If \a packed is true, the type \c sparse_pack is used for the calculations.
     321Otherwise the type \c sparse_set is used for the calculations.
    322322
    323323\return
     
    342342
    343343        if( packed )
    344         {       CppAD::ForSparseJac<Base, VectorBool, vector_pack>(
     344        {       CppAD::ForSparseJac<Base, VectorBool, sparse_pack>(
    345345                        p                ,
    346346                        s                ,
     
    353353        }
    354354        else
    355         {       CppAD::ForSparseJac<Base, VectorBool, vector_set>(
     355        {       CppAD::ForSparseJac<Base, VectorBool, sparse_set>(
    356356                        p                ,
    357357                        s                ,
  • trunk/cppad/local/sparse_binary_op.hpp

    r1529 r1539  
    3636\tparam Vector_set
    3737is the type used for vectors of sets. It can be either
    38 \c vector_pack or \c vector_set.
     38\c sparse_pack or \c sparse_set.
    3939
    4040\param i_z
     
    115115\tparam Vector_set
    116116is the type used for vectors of sets. It can be either
    117 \c vector_pack or \c vector_set.
     117\c sparse_pack or \c sparse_set.
    118118
    119119\param i_z
  • trunk/cppad/local/sparse_pack.hpp

    r1538 r1539  
    1 # ifndef CPPAD_VECTOR_PACK_INCLUDED
    2 # define CPPAD_VECTOR_PACK_INCLUDED
     1# ifndef CPPAD_SPARSE_PACK_INCLUDED
     2# define CPPAD_SPARSE_PACK_INCLUDED
    33
    44/* --------------------------------------------------------------------------
     
    1414
    1515/*!
    16 \file vector_pack.hpp
     16\file sparse_pack.hpp
    1717Vector of sets of positive integers.
    1818*/
     
    2525
    2626CPPAD_BEGIN_NAMESPACE
    27 class vector_pack {
     27class sparse_pack {
    2828private:
    2929        /// type used to pack elements
     
    5555        /*! Default constructor (no sets)
    5656        */
    57         vector_pack(void) :
     57        sparse_pack(void) :
    5858        n_set_(0)                     ,
    5959        end_(0)                       ,
     
    7070        vector that we are attempting to make a copy of.
    7171        */
    72         vector_pack(const vector_pack& v)
     72        sparse_pack(const sparse_pack& v)
    7373        {       // Error:
    74                 // Probably a vector_pack argument has been passed by value
     74                // Probably a sparse_pack argument has been passed by value
    7575                CPPAD_ASSERT_UNKNOWN(0);
    7676        }
     
    7878        /*! Destructor
    7979        */
    80         ~vector_pack(void)
     80        ~sparse_pack(void)
    8181        {       if( allocated_ )
    8282                {       allocated_ = false;
     
    221221
    222222        \param this_target
    223         is the index (in this \c vector_pack object) of the set being assinged.
     223        is the index (in this \c sparse_pack object) of the set being assinged.
    224224
    225225        \param other_value
    226         is the index (in the other \c vector_pack object) of the
     226        is the index (in the other \c sparse_pack object) of the
    227227        that we are using as the value to assign to the target set.
    228228
    229229        \param other
    230         is the other \c vector_pack object (which may be the same as this
    231         \c vector_pack object).
     230        is the other \c sparse_pack object (which may be the same as this
     231        \c sparse_pack object).
    232232
    233233        \par Checked Assertions
     
    239239                size_t               this_target  ,
    240240                size_t               other_value  ,
    241                 const vector_pack&   other        )
     241                const sparse_pack&   other        )
    242242        {       CPPAD_ASSERT_UNKNOWN( this_target  <   n_set_        );
    243243                CPPAD_ASSERT_UNKNOWN( other_value  <   other.n_set_  );
     
    255255
    256256        \param this_target
    257         is the index (in this \c vector_pack object) of the set being assinged.
     257        is the index (in this \c sparse_pack object) of the set being assinged.
    258258
    259259        \param this_left
    260         is the index (in this \c vector_pack object) of the
     260        is the index (in this \c sparse_pack object) of the
    261261        left operand for the union operation.
    262262        It is OK for \a this_target and \a this_left to be the same value.
    263263
    264264        \param other_right
    265         is the index (in the other \c vector_pack object) of the
     265        is the index (in the other \c sparse_pack object) of the
    266266        right operand for the union operation.
    267267        It is OK for \a this_target and \a other_right to be the same value.
    268268
    269269        \param other
    270         is the other \c vector_pack object (which may be the same as this
    271         \c vector_pack object).
     270        is the other \c sparse_pack object (which may be the same as this
     271        \c sparse_pack object).
    272272
    273273        \par Checked Assertions
     
    281281                size_t                  this_left    ,
    282282                size_t                  other_right  ,
    283                 const vector_pack&      other        )
     283                const sparse_pack&      other        )
    284284        {       CPPAD_ASSERT_UNKNOWN( this_target < n_set_         );
    285285                CPPAD_ASSERT_UNKNOWN( this_left   < n_set_         );
  • trunk/cppad/local/sparse_set.hpp

    • Property svn:mergeinfo set to (toggle deleted branches)
      /branches/optimize/cppad/local/vector_set.hpp1490-1496
      /branches/sweep/cppad/local/vector_set.hpp1405-1446
    r1538 r1539  
    1 # ifndef CPPAD_VECTOR_SET_INCLUDED
    2 # define CPPAD_VECTOR_SET_INCLUDED
     1# ifndef CPPAD_SPARSE_SET_INCLUDED
     2# define CPPAD_SPARSE_SET_INCLUDED
    33
    44/* --------------------------------------------------------------------------
     
    1414
    1515/*!
    16 \file vector_set.hpp
     16\file sparse_set.hpp
    1717Vector of sets of positive integers.
    1818*/
     
    2727
    2828CPPAD_BEGIN_NAMESPACE
    29 class vector_set {
     29class sparse_set {
    3030private:
    3131        /// type used for each set in the vector sets
     
    4949        /*! Default constructor (no sets)
    5050        */
    51         vector_set(void) :
     51        sparse_set(void) :
    5252        n_set_(0)                     ,
    5353        end_(0)                       ,
     
    6060        vector that we are attempting to make a copy of.
    6161        */
    62         vector_set(const vector_set& v)
     62        sparse_set(const sparse_set& v)
    6363        {       // Error:
    64                 // Probably a vector_set argument has been passed by value
     64                // Probably a sparse_set argument has been passed by value
    6565                CPPAD_ASSERT_UNKNOWN(0);
    6666        }
     
    6868        /*! Destructor
    6969        */
    70         ~vector_set(void)
     70        ~sparse_set(void)
    7171        { }
    7272        // -----------------------------------------------------------------
     
    163163
    164164        \param this_target
    165         is the index (in this \c vector_set object) of the set being assinged.
     165        is the index (in this \c sparse_set object) of the set being assinged.
    166166
    167167        \param other_value
    168         is the index (in the other \c vector_set object) of the
     168        is the index (in the other \c sparse_set object) of the
    169169        that we are using as the value to assign to the target set.
    170170
    171171        \param other
    172         is the other \c vector_set object (which may be the same as this
    173         \c vector_set object).
     172        is the other \c sparse_set object (which may be the same as this
     173        \c sparse_set object).
    174174
    175175        \par Checked Assertions
     
    180180                size_t               this_target  ,
    181181                size_t               other_value  ,
    182                 const vector_set&   other        )
     182                const sparse_set&   other        )
    183183        {       CPPAD_ASSERT_UNKNOWN( this_target  <   n_set_        );
    184184                CPPAD_ASSERT_UNKNOWN( other_value  <   other.n_set_  );
     
    191191
    192192        \param this_target
    193         is the index (in this \c vector_set object) of the set being assinged.
     193        is the index (in this \c sparse_set object) of the set being assinged.
    194194
    195195        \param this_left
    196         is the index (in this \c vector_set object) of the
     196        is the index (in this \c sparse_set object) of the
    197197        left operand for the union operation.
    198198        It is OK for \a this_target and \a this_left to be the same value.
    199199
    200200        \param other_right
    201         is the index (in the other \c vector_set object) of the
     201        is the index (in the other \c sparse_set object) of the
    202202        right operand for the union operation.
    203203        It is OK for \a this_target and \a other_right to be the same value.
    204204
    205205        \param other
    206         is the other \c vector_set object (which may be the same as this
    207         \c vector_set object).
     206        is the other \c sparse_set object (which may be the same as this
     207        \c sparse_set object).
    208208
    209209        \par Checked Assertions
     
    216216                size_t                  this_left    ,
    217217                size_t                  other_right  ,
    218                 const vector_set&      other        )
     218                const sparse_set&      other        )
    219219        {       CPPAD_ASSERT_UNKNOWN( this_target < n_set_         );
    220220                CPPAD_ASSERT_UNKNOWN( this_left   < n_set_         );
  • trunk/cppad/local/sparse_unary_op.hpp

    r1529 r1539  
    3535\tparam Vector_set
    3636is the type used for vectors of sets. It can be either
    37 \c vector_pack or \c vector_set.
     37\c sparse_pack or \c sparse_set.
    3838
    3939\param i_z
     
    9797\tparam Vector_set
    9898is the type used for vectors of sets. It can be either
    99 \c vector_pack or \c vector_set.
     99\c sparse_pack or \c sparse_set.
    100100
    101101
  • trunk/makefile.am

    r1529 r1539  
    179179        cppad/local/unary_plus.hpp \
    180180        cppad/local/vec_ad.hpp \
    181         cppad/local/vector_pack.hpp \
    182         cppad/local/vector_set.hpp \
     181        cppad/local/sparse_pack.hpp \
     182        cppad/local/sparse_set.hpp \
    183183        cppad/local/undef.hpp \
    184184        cppad/local/value.hpp \
  • trunk/speed/adolc/makefile.in

    r1537 r1539  
    8787CYGPATH_W = @CYGPATH_W@
    8888
    89 # $Id: makefile.am 1369 2009-05-31 01:31:48Z bradbell $
     89# $Id: makefile.am 1537 2009-10-01 03:52:53Z bradbell $
    9090# -----------------------------------------------------------------------------
    91 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     91# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    9292#
    9393# CppAD is distributed under multiple licenses. This distribution is under
  • trunk/speed/cppad/makefile.in

    r1537 r1539  
    8686CYGPATH_W = @CYGPATH_W@
    8787
    88 # $Id: makefile.am 1369 2009-05-31 01:31:48Z bradbell $
     88# $Id: makefile.am 1537 2009-10-01 03:52:53Z bradbell $
    8989# -----------------------------------------------------------------------------
    90 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     90# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    9191#
    9292# CppAD is distributed under multiple licenses. This distribution is under
  • trunk/speed/double/makefile.in

    r1537 r1539  
    8686CYGPATH_W = @CYGPATH_W@
    8787
    88 # $Id: makefile.am 1369 2009-05-31 01:31:48Z bradbell $
     88# $Id: makefile.am 1537 2009-10-01 03:52:53Z bradbell $
    8989# -----------------------------------------------------------------------------
    90 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     90# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    9191#
    9292# CppAD is distributed under multiple licenses. This distribution is under
  • trunk/speed/fadbad/makefile.in

    r1537 r1539  
    8686CYGPATH_W = @CYGPATH_W@
    8787
    88 # $Id: makefile.am 1369 2009-05-31 01:31:48Z bradbell $
     88# $Id: makefile.am 1537 2009-10-01 03:52:53Z bradbell $
    8989# -----------------------------------------------------------------------------
    90 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     90# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    9191#
    9292# CppAD is distributed under multiple licenses. This distribution is under
  • trunk/speed/profile/makefile.in

    r1537 r1539  
    8686CYGPATH_W = @CYGPATH_W@
    8787
    88 # $Id: makefile.am 1369 2009-05-31 01:31:48Z bradbell $
     88# $Id: makefile.am 1537 2009-10-01 03:52:53Z bradbell $
    8989# -----------------------------------------------------------------------------
    90 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     90# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    9191#
    9292# CppAD is distributed under multiple licenses. This distribution is under
  • trunk/speed/sacado/makefile.in

    r1537 r1539  
    8787CYGPATH_W = @CYGPATH_W@
    8888
    89 # $Id: makefile.am 1369 2009-05-31 01:31:48Z bradbell $
     89# $Id: makefile.am 1537 2009-10-01 03:52:53Z bradbell $
    9090# -----------------------------------------------------------------------------
    91 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
     91# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-09 Bradley M. Bell
    9292#
    9393# CppAD is distributed under multiple licenses. This distribution is under
Note: See TracChangeset for help on using the changeset viewer.