Changeset 640


Ignore:
Timestamp:
Sep 7, 2006, 7:11:18 AM (15 years ago)
Author:
Peter
Message:

fixes #132 and #95, and refs #135 replaced bool owner in DataLookup2D with ref_count u_int*. When the DataLookup2D does not own underlying data ref_count=NULL otherwise it points to a u_int telling how many owner there are of the data. When the counter reaches zero the data is deleted.

Location:
trunk
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/c++_tools/classifier/DataLookup2D.cc

    r608 r640  
    1515
    1616
     17  DataLookup2D::DataLookup2D()
     18    : ref_count_(NULL)
     19  {
     20  }
     21
     22
    1723  DataLookup2D::DataLookup2D(const DataLookup2D& m,
    1824                             const std::vector<size_t>& row,
    1925                             const std::vector<size_t>& col)
    20     : owner_(false)
     26    : ref_count_(NULL)
    2127  {
    2228    assert(row_index_.empty());
     
    3945                             const std::vector<size_t>& index,
    4046                             const bool row)
    41     : owner_(false)
     47    : ref_count_(NULL)
    4248  {
    4349    if (row){
     
    6268
    6369  DataLookup2D::DataLookup2D(const std::vector<size_t>& row,
    64                              const std::vector<size_t>& col,
    65                              const bool owner)
    66     : row_index_(row),column_index_(col), owner_(owner)
     70                             const std::vector<size_t>& col)
     71    : row_index_(row),column_index_(col), ref_count_(NULL)
    6772  {
    6873  }
     
    7176
    7277  DataLookup2D::DataLookup2D(const DataLookup2D& mv)
    73     : row_index_(mv.row_index_),column_index_(mv.column_index_), owner_(false)
     78    : row_index_(mv.row_index_),column_index_(mv.column_index_),
     79      ref_count_(NULL)
    7480  {
    7581  }
    7682
    7783
    78   DataLookup2D::DataLookup2D(const size_t rows, const size_t columns,
    79                              const bool owner)
     84  DataLookup2D::DataLookup2D(const size_t rows, const size_t columns)
    8085    : row_index_(std::vector<size_t>(rows,0)),
    81       column_index_(std::vector<size_t>(columns,0)),
    82       owner_(owner)
     86      column_index_(std::vector<size_t>(columns,0)), ref_count_(NULL)
     87
    8388  {
    8489  }
     
    9095      row_index_ = other.row_index_;
    9196      column_index_ = other.column_index_;
    92       owner_=false;
    9397    }
    9498    return *this;
  • trunk/c++_tools/classifier/DataLookup2D.h

    r631 r640  
    3131    /// Default constructor.
    3232    ///
    33     inline DataLookup2D(const bool owner=false) : owner_(owner){};
     33    DataLookup2D(void);
    3434
    3535
    3636    ///
    3737    /// Constructor taking the @a row index vector and @a column index
    38     /// vector as input. If @a owner is set true, the object is
    39     /// consider as owner of the underlying data (and the data is
    40     /// deleted at destruction).
     38    /// vector as input.
    4139    ///
    4240    DataLookup2D(const std::vector<size_t>& row,
    43                  const std::vector<size_t>& column,
    44                  const bool owner = false);
     41                 const std::vector<size_t>& column);
    4542
    4643    ///
     
    6865    /// created in daughter classes.
    6966    ///
    70     DataLookup2D(const size_t, const size_t, const bool owner);
     67    DataLookup2D(const size_t, const size_t);
    7168
    7269
     
    148145    std::vector<size_t> row_index_;
    149146    std::vector<size_t> column_index_;
    150     bool owner_;
     147    u_int* ref_count_;
     148   
    151149  }; 
    152150 
  • trunk/c++_tools/classifier/FeatureSelectorIR.cc

    r624 r640  
    44
    55#include "FeatureSelector.h"
     6#include "MatrixLookup.h"
    67#include "InputRanker.h"
    78
     
    3637  void FeatureSelectorIR::update(const MatrixLookup& data, const Target& target)
    3738  {
     39    assert(data.columns()==target.size());
    3840    InputRanker ir = InputRanker(data, target, score_);
    3941    features_.resize(N_);
    4042    std::copy(ir.rank().begin()+first_, ir.rank().begin()+first_+N_,
    4143              features_.begin());
    42    
    4344  }
    4445
  • trunk/c++_tools/classifier/InputRanker.h

    r630 r640  
    5252    /// id (column) \a i
    5353    ///
    54     inline const std::vector<size_t> rank(void) const {return rank_;}
     54    inline const std::vector<size_t>& rank(void) const {return rank_;}
    5555
    5656
  • trunk/c++_tools/classifier/Kernel.cc

    r628 r640  
    3030    : kf_(other.kf_), data_owner_(true)
    3131  {
    32     // Peter go through this code; look fishy!
    3332    data_ = other.data_->selected(index);
    34     if (data_w_){
     33    if (other.data_w_){
    3534      data_w_ = other.data_w_->selected(index);
    3635      weight_owner_=true;
  • trunk/c++_tools/classifier/Kernel.h

    r629 r640  
    119119    /// @return true if kernel is calculated using weights
    120120    ///
    121     // Peter make non-virtual?
    122121    inline bool weighted(void) const { return data_w_; }
    123122
  • trunk/c++_tools/classifier/KernelLookup.cc

    r628 r640  
    1414
    1515  KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
    16     : DataLookup2D(own), kernel_(&kernel)
     16    : DataLookup2D(), kernel_(&kernel)
    1717  {
     18    if (own)
     19      ref_count_ = new u_int(1);
     20
    1821    column_index_.reserve(kernel.size());
    1922    for(size_t i=0; i<kernel.size(); i++)
     
    2629                             const std::vector<size_t>& column,
    2730                             const bool owner)
    28     : DataLookup2D(row,column,owner), kernel_(&kernel)
     31    : DataLookup2D(row,column), kernel_(&kernel)
    2932  {
     33    if (owner)
     34      ref_count_ = new u_int(1);
     35
    3036    // Checking that each row index is less than kernel.rows()
    3137    assert(row.empty() ||
     
    3844
    3945
    40   KernelLookup::KernelLookup(const KernelLookup& kernel,
     46  KernelLookup::KernelLookup(const KernelLookup& other,
    4147                             const std::vector<size_t>& row,
    4248                             const std::vector<size_t>& column)
    43     : DataLookup2D(kernel,row,column), kernel_(kernel.kernel_)
     49    : DataLookup2D(other,row,column), kernel_(other.kernel_)
    4450  {
     51    ref_count_=other.ref_count_;
     52    if (ref_count_)
     53      ++(*ref_count_);
    4554  }
    4655 
    4756
    48   KernelLookup::KernelLookup(const KernelLookup& kernel)
    49     : DataLookup2D(kernel), kernel_(kernel.kernel_)
     57  KernelLookup::KernelLookup(const KernelLookup& other)
     58    : DataLookup2D(other), kernel_(other.kernel_)
    5059  {
    5160    // Checking that no index is out of range
    5261    assert(row_index_.empty() ||
    53            *(max_element(row_index_.begin(), row_index_.end()))<kernel_->size());
     62           *(max_element(row_index_.begin(), row_index_.end()))<
     63           kernel_->size());
    5464    assert(column_index_.empty() ||
    5565           *(max_element(column_index_.begin(), column_index_.end()))<
    5666           kernel_->size());
     67    ref_count_=other.ref_count_;
     68    if (ref_count_)
     69      ++(*ref_count_);
    5770
    5871  }
    5972 
    6073
    61   KernelLookup::KernelLookup(const KernelLookup& kl,
     74  KernelLookup::KernelLookup(const KernelLookup& other,
    6275                             const std::vector<size_t>& index,
    6376                             const bool row)
    64     : DataLookup2D(kl,index,row), kernel_(kl.kernel_)
     77    : DataLookup2D(other,index,row), kernel_(other.kernel_)
    6578  {
    6679    // Checking that no index is out of range
    6780    assert(row_index_.empty() ||
    68            *(max_element(row_index_.begin(), row_index_.end()))<kernel_->size());
     81           *(max_element(row_index_.begin(), row_index_.end()))<
     82           kernel_->size());
    6983    assert(column_index_.empty() ||
    7084           *(max_element(column_index_.begin(), column_index_.end()))<
    7185           kernel_->size());
    72 
     86    ref_count_=other.ref_count_;
     87    if (ref_count_)
     88      ++(*ref_count_);
    7389  }
    7490 
     
    7692  KernelLookup::~KernelLookup(void)
    7793  {
    78     if (owner_)
    79       delete kernel_;
     94    if (ref_count_)
     95      if (!--(*ref_count_))
     96        delete kernel_;
    8097  }
    8198
  • trunk/c++_tools/classifier/KernelLookup.h

    r628 r640  
    4747    /// kernel. By default @a owner is set to false, which means
    4848    /// KernelLookup does not own the underlying Kernel. If
    49     /// KernelLookup owns the Kernel then the Kernel will be deleted
     49    /// KernelLookup owns the Kernel the Kernel will be deleted
    5050    /// in the destructor.
    5151    ///
     
    5353    /// KernelLookup becomes invalid and the result of further use is
    5454    /// undefined.
     55    ///
     56    /// @note Do not construct two KernelLookups from the same @a
     57    /// kernel with @a owner set to true because that will cause
     58    /// multiple deletion of @a kernel.
    5559    ///
    5660    KernelLookup(const Kernel& kernel, const bool owner=false);
  • trunk/c++_tools/classifier/Kernel_SEV.h

    r629 r640  
    5757
    5858    ///
    59     /// @todo remove this function
     59    /// @todo doc
    6060    ///
    6161    const Kernel* selected(const std::vector<size_t>& index) const;
  • trunk/c++_tools/classifier/MatrixLookup.cc

    r631 r640  
    4141
    4242  MatrixLookup::MatrixLookup(const utility::matrix& data,
    43                     const std::vector<size_t>& index,
    44                     const bool row)
     43                            const std::vector<size_t>& index,
     44                            const bool row)
    4545    : DataLookup2D(), data_(&data)
    4646  {
     
    6969
    7070
    71   MatrixLookup::MatrixLookup(const MatrixLookup& dv)
    72     : DataLookup2D(dv), data_(dv.data_)
    73   {
    74   }
    75 
    76 
    77 
    78   MatrixLookup::MatrixLookup(const MatrixLookup& ml,
     71  MatrixLookup::MatrixLookup(const MatrixLookup& other)
     72    : DataLookup2D(other), data_(other.data_)
     73  {
     74    ref_count_=other.ref_count_;
     75    if (ref_count_)
     76      ++(*ref_count_);
     77  }
     78
     79
     80
     81  MatrixLookup::MatrixLookup(const MatrixLookup& other,
    7982                             const std::vector<size_t>& row,
    8083                             const std::vector<size_t>& col)
    81     : DataLookup2D(ml,row,col), data_(ml.data_)
    82   {
    83   }
    84  
    85 
    86 
    87   MatrixLookup::MatrixLookup(const MatrixLookup& ml,
     84    : DataLookup2D(other,row,col), data_(other.data_)
     85  {
     86    ref_count_=other.ref_count_;
     87    if (ref_count_)
     88      ++(*ref_count_);
     89  }
     90 
     91
     92
     93  MatrixLookup::MatrixLookup(const MatrixLookup& other,
    8894                             const std::vector<size_t>& index, bool row)
    89     : DataLookup2D(ml,index,row), data_(ml.data_)
    90   {
     95    : DataLookup2D(other,index,row), data_(other.data_)
     96  {
     97    ref_count_=other.ref_count_;
     98    if (ref_count_)
     99      ++(*ref_count_);
     100
    91101    // Checking that no index is out of range
    92102    assert(row_index_.empty() ||
     
    101111  MatrixLookup::MatrixLookup(const size_t rows, const size_t columns,
    102112                             const double value)
    103     : DataLookup2D(rows,columns, true)
     113    : DataLookup2D(rows,columns)
    104114  {
    105115    data_ = new utility::matrix(1,1,value);
     116    ref_count_= new u_int(1);
    106117  }
    107118
    108119
    109120  MatrixLookup::MatrixLookup(std::istream& is, char sep)
    110     : DataLookup2D(true)
     121    : DataLookup2D()
    111122  {
    112123    data_ = new utility::matrix(is,sep);
     124    ref_count_= new u_int(1);
    113125    for(size_t i=0;i<(*data_).rows();i++)
    114126      row_index_.push_back(i);
     
    120132  MatrixLookup::~MatrixLookup(void)
    121133  {
    122     if (owner_)
    123       delete data_;
     134    if (ref_count_)
     135      if (!--(*ref_count_))
     136        delete data_;
    124137  }
    125138
     
    179192  {
    180193    if (this!=&other){
    181       if (owner_){
     194      if (ref_count_ && !--(*ref_count_))
    182195        delete data_;
    183         owner_=false;
    184       }
    185196      DataLookup2D::operator=(other);
    186197      data_ = other.data_;
     198      ref_count_=other.ref_count_;
     199      if (ref_count_)
     200        ++(*ref_count_);
    187201    }
    188202    return *this;
  • trunk/c++_tools/classifier/MatrixLookupWeighted.cc

    r638 r640  
    1616  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data,
    1717                                             const utility::matrix& weights)
    18     : DataLookup2D(), data_(&data), weights_(&weights),weights_owner_(false)
     18    : DataLookup2D(), data_(&data), weights_(&weights), ref_count_weights_(NULL)
    1919  {
    2020    assert(data.rows()==weights.rows());
     
    2727
    2828  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data)
    29     : DataLookup2D(), data_(&data), weights_owner_(true)
     29    : DataLookup2D(), data_(&data)
    3030  {
    3131    utility::matrix weights;
    3232    data_->nan(weights);   
    3333    weights_= new utility::matrix(weights);
     34    ref_count_weights_=new u_int(1);
    3435    for(size_t i=0;i<(*data_).rows();i++)
    3536      row_index_.push_back(i);
     
    4546                                             const std::vector<size_t>& col)
    4647    : DataLookup2D(row,col), data_(&data), weights_(&weights),
    47       weights_owner_(false)
     48      ref_count_weights_(NULL)
    4849  {
    4950    // Checking that each row index is less than data.rows()
     
    6768                                             const std::vector<size_t>& index,
    6869                                             const bool row)
    69     : DataLookup2D(), data_(&data), weights_(&weights),weights_owner_(false)
     70    : DataLookup2D(), data_(&data), weights_(&weights),
     71      ref_count_weights_(NULL)
    7072  {
    7173    if (row){
     
    107109
    108110
    109   MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& dv)
    110     : DataLookup2D(dv), data_(dv.data_), weights_(dv.weights_),
    111       weights_owner_(false)
    112   {
    113   }
    114 
    115 
    116 
    117   MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& ml,
     111  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other)
     112    : DataLookup2D(other), data_(other.data_), weights_(other.weights_)
     113  {
     114    ref_count_ = other.ref_count_;
     115    if (ref_count_)
     116      ++(*ref_count_);
     117    ref_count_weights_ = other.ref_count_weights_;
     118    if (ref_count_weights_)
     119      ++(*ref_count_weights_);
     120
     121  }
     122
     123
     124
     125  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other,
    118126                                             const std::vector<size_t>& row,
    119127                                             const std::vector<size_t>& col)
    120     : DataLookup2D(ml,row,col), data_(ml.data_), weights_(ml.weights_),
    121       weights_owner_(false)
    122   {
    123   }
    124  
    125 
    126 
    127   MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& ml,
     128    : DataLookup2D(other,row,col), data_(other.data_), weights_(other.weights_)
     129  {
     130    ref_count_ = other.ref_count_;
     131    if (ref_count_)
     132      ++(*ref_count_);
     133    ref_count_weights_ = other.ref_count_weights_;
     134    if (ref_count_weights_)
     135      ++(*ref_count_weights_);
     136  }
     137 
     138
     139
     140  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other,
    128141                                             const std::vector<size_t>& index,
    129142                                             bool row)
    130     : DataLookup2D(ml,index,row), data_(ml.data_), weights_(ml.weights_),
    131       weights_owner_(false)
    132   {
     143    : DataLookup2D(other,index,row), data_(other.data_),
     144      weights_(other.weights_)
     145  {
     146    ref_count_ = other.ref_count_;
     147    if (ref_count_)
     148      ++(*ref_count_);
     149    ref_count_weights_ = other.ref_count_weights_;
     150    if (ref_count_weights_)
     151      ++(*ref_count_weights_);
     152
    133153    // Checking that no index is out of range
    134154    assert(row_index_.empty() ||
     
    152172                                             const double value,
    153173                                             const double weight)
    154     : DataLookup2D(rows,columns, true),weights_owner_(true)
     174    : DataLookup2D(rows,columns)
    155175  {
    156176    data_ = new utility::matrix(1,1,value);
     177    ref_count_=new u_int(1);
    157178    weights_ = new utility::matrix(1,1,weight);
     179    ref_count_weights_=new u_int(1);
    158180  }
    159181
    160182 
    161183  MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
    162     : DataLookup2D(true), weights_owner_(true)
     184    : DataLookup2D()
    163185  {
    164186    data_ = new utility::matrix(is,sep);
     187    ref_count_=new u_int(1);
    165188    for(size_t i=0;i<(*data_).rows();i++)
    166189      row_index_.push_back(i);
     
    170193    data_->nan(weights);   
    171194    weights_= new utility::matrix(weights);
     195    ref_count_weights_=new u_int(1);
    172196  }
    173197 
     
    175199  MatrixLookupWeighted::~MatrixLookupWeighted(void)
    176200  {
    177     if (owner_)
    178       delete data_;
    179     if (weights_owner_)
    180       delete weights_;
     201    if (ref_count_)
     202      if (!--(*ref_count_))
     203        delete data_;
     204    if (ref_count_weights_)
     205      if (!--(*ref_count_weights_))
     206        delete weights_;
    181207  }
    182208
     
    237263  {
    238264    if (this!=&other){
    239       if (owner_){
     265      if (ref_count_ && !--(*ref_count_))
    240266        delete data_;
     267      if (ref_count_weights_ && !--(*ref_count_weights_))
    241268        delete weights_;
    242         owner_=false;
    243       }
    244269      DataLookup2D::operator=(other);
    245270      data_ = other.data_;
     271      ref_count_=other.ref_count_;
     272      if (ref_count_)
     273        ++(*ref_count_);
    246274      weights_ = other.weights_;
     275      ref_count_weights_ = other.ref_count_weights_;
     276      if (ref_count_weights_)
     277        ++(*ref_count_weights_);
    247278    }
    248279    return *this;
  • trunk/c++_tools/classifier/MatrixLookupWeighted.h

    r638 r640  
    294294    const utility::matrix* data_;
    295295    const utility::matrix* weights_;
    296     bool weights_owner_;
     296    u_int* ref_count_weights_;
    297297  }; 
    298298 
  • trunk/c++_tools/classifier/SVM.cc

    r635 r640  
    3636  {
    3737#ifndef NDEBUG
     38    assert(kernel.columns()==kernel.rows());
     39    assert(kernel.columns()==alpha_.size());
    3840    for (size_t i=0; i<alpha_.size(); i++)
    39       for (size_t j=0; j<alpha_.size(); j++) 
     41      for (size_t j=0; j<alpha_.size(); j++)
    4042        assert(kernel(i,j)==kernel(j,i));
    4143    for (size_t i=0; i<alpha_.size(); i++)
     
    4850                    << j << std::endl;
    4951#endif       
    50 
    5152  }
    5253
     
    7273                                             const Target& target) const
    7374  {
    74     const KernelLookup& kernel =
    75       dynamic_cast<const KernelLookup&>(data);
    76 
    77     assert(data.rows()==data.columns());
    78     assert(data.columns()==target.size());
    79     SVM* sc;
    80     sc = new SVM(kernel,target);
    81 
     75    SVM* sc=0;
     76    try {
     77      const KernelLookup& kernel = dynamic_cast<const KernelLookup&>(data);
     78      assert(data.rows()==data.columns());
     79      assert(data.columns()==target.size());
     80      sc = new SVM(kernel,target);
    8281
    8382    //Copy those variables possible to modify from outside
    8483    // Peter, in particular C
     84    }
     85    catch (std::bad_cast) {
     86      std::cerr << "Warning: SVM::make_classifier only takes KernelLookup"
     87                << std::endl;
     88    }
    8589    return sc;
    8690  }
     
    8993  {
    9094    // Peter, should check success of dynamic_cast
    91     const KernelLookup input_kernel = dynamic_cast<const KernelLookup&>(input);
     95    const KernelLookup& input_kernel = dynamic_cast<const KernelLookup&>(input);
    9296
    9397    const KernelLookup* kernel_pointer;
  • trunk/c++_tools/classifier/SubsetGenerator.cc

    r637 r640  
    7373      for (reset(); more(); next()){
    7474     
     75        training_target_.push_back(Target(target(),training_index()));
     76        validation_target_.push_back(Target(target(),validation_index()));
    7577        // training data with no feature selection
    7678        const MatrixLookup* train_data_all_feat =
    7779          ml->training_data(training_index());
    7880        // use these data to create feature selection
     81        assert(train_data_all_feat);
    7982        f_selector_->update(*train_data_all_feat, training_target());
    8083        // get features
    8184        features_.push_back(f_selector_->features());
     85        assert(train_data_all_feat);
    8286        delete train_data_all_feat;
    8387       
     
    8892                                                        training_index(),
    8993                                                        validation_index()));
    90 
    91         training_target_.push_back(Target(target(),training_index()));
    92         validation_target_.push_back(Target(target(),validation_index()));
    9394      }
    9495    }
     
    100101        for (reset(); more(); next()){
    101102     
     103          training_target_.push_back(Target(target(),training_index()));
     104          validation_target_.push_back(Target(target(),validation_index()));
    102105          // training data with no feature selection
    103106          const MatrixLookupWeighted* train_data_all_feat =
     
    116119                                                         validation_index()));
    117120         
    118           training_target_.push_back(Target(target(),training_index()));
    119           validation_target_.push_back(Target(target(),validation_index()));
    120121        }
    121122      }
     
    125126        if (kernel){
    126127          for (reset(); more(); next()){
     128            training_target_.push_back(Target(target(),training_index()));
     129            validation_target_.push_back(Target(target(),validation_index()));
    127130            const DataLookup2D* matrix = kernel->data();
    128131            // dynamically allocated must be deleted
    129132            const DataLookup2D* training_matrix =
    130133              matrix->training_data(training_index());
    131            
    132134            if (matrix->weighted()){
    133135              const MatrixLookupWeighted& ml =
    134136                dynamic_cast<const MatrixLookupWeighted&>(*matrix);
    135               f_selector_->update(MatrixLookupWeighted(ml,training_index(),
    136                                                        false),
     137              f_selector_->update(MatrixLookupWeighted(ml,training_index(),false),
    137138                                  training_target());
    138139            }
     
    143144                                  training_target());
    144145            }
    145            
    146             features_.push_back(f_selector_->features());
     146            std::vector<size_t> dummie=f_selector_->features();
     147            features_.push_back(dummie);
     148            //features_.push_back(f_selector_->features());
     149            assert(kernel);
    147150            const KernelLookup* kl = kernel->selected(features_.back());
    148151            assert(training_matrix);
     
    150153                     
    151154            // Dynamically allocated. Must be deleted in destructor.
    152             training_data_.push_back(kl->training_data(features_.back(),
    153                                                        training_index()));
    154             validation_data_.push_back(kl->validation_data(features_.back(),
    155                                                            training_index(),
     155            training_data_.push_back(kl->training_data(training_index()));
     156            validation_data_.push_back(kl->validation_data(training_index(),
    156157                                                           validation_index()));
    157            
    158             training_target_.push_back(Target(target(),training_index()));
    159             validation_target_.push_back(Target(target(),validation_index()));
    160158            assert(kl);
    161159            delete kl;
  • trunk/test/Makefile.am

    r615 r640  
    3232  kernel_test kernel_lookup_test matrix_test matrix_lookup_test \
    3333  ncc_test nni_test pca_test regression_test rnd_test score_test \
    34   statistics_test stl_utility_test svd_test svm_test target_test \
     34  statistics_test stl_utility_test \
     35  subset_generator_test \
     36  svd_test svm_test target_test \
    3537  utility_test vector_test
    3638
     
    6466statistics_test_SOURCES = statistics_test.cc
    6567stl_utility_test_SOURCES = stl_utility_test.cc
     68subset_generator_test_SOURCES = subset_generator_test.cc
    6669svd_test_SOURCES = svd_test.cc
    6770svm_test_SOURCES = svm_test.cc
Note: See TracChangeset for help on using the changeset viewer.