Changeset 1170

Timestamp:

Feb 27, 2008, 1:06:55 AM (16 years ago)

Author:

Peter

Message:

removing DataLookup2D closes ticket:243

Location:

trunk

Files:

• test/matrix_lookup_test.cc (modified) (1 diff)
• test/subset_generator_test.cc (modified) (1 diff)
• yat/classifier/DataLookup1D.h (modified) (2 diffs)
• yat/classifier/DataLookup2D.cc (deleted)
• yat/classifier/DataLookup2D.h (deleted)
• yat/classifier/InputRanker.h (modified) (1 diff)
• yat/classifier/KernelLookup.h (modified) (1 diff)
• yat/classifier/Makefile.am (modified) (2 diffs)
• yat/classifier/MatrixLookup.cc (modified) (13 diffs)
• yat/classifier/MatrixLookup.h (modified) (5 diffs)
• yat/classifier/MatrixLookupWeighted.cc (modified) (13 diffs)
• yat/classifier/MatrixLookupWeighted.h (modified) (5 diffs)
• yat/classifier/SVM.h (modified) (1 diff)

trunk/test/matrix_lookup_test.cc

@@ -79 +79 @@
     ok =false;
     *error <<   "ERROR:" << std::endl;
+    *error << "rows: " << m2.rows() << " expected 2\n"
+           << "columns: " << m2.columns() << " expected 2\n"
+           << "(0,0): " << m2(0,0) << " expected " << gsl_m2(1,2) << "\n"
+           << "(0,1): " << m2(1,0) << " expected " << gsl_m2(1,0) << "\n"
+           << "(1,0): " << m2(0,1) << " expected " << gsl_m2(3,2) << "\n"
+           << "(0,0): " << m2(0,0) << " expected " << gsl_m2(3,0) << "\n";
   }
   else

trunk/test/subset_generator_test.cc

@@ -171 +171 @@
     std::vector<size_t> t_class_count2(3,0);
     for(u_long l=0;l<cv_training.size();l++) {
-      const classifier::DataLookup2D& t_view=cv_training.training_data(l);
+      const classifier::MatrixLookup& t_view=cv_training.training_data(l);
       const classifier::Target& t_target=cv_training.training_target(l);
       const utility::Index& t_index=cv_training.training_index(l);
-      const classifier::DataLookup2D& v_view=cv_training.validation_data(l);
+      const classifier::MatrixLookup& v_view=cv_training.validation_data(l);
       const classifier::Target& v_target=cv_training.validation_target(l);
       const utility::Index& v_index=cv_training.validation_index(l);

trunk/yat/classifier/DataLookup1D.h

@@ -59 +59 @@
     ///
     /// @param row_vector if true DataLookup1D is looking into a
-    /// row of DataLookup2D, otherwise looking into a
+    /// row of MatrixLookup, otherwise looking into a
     /// column. @param index which row/column to look into.
     ///
@@ -96 +96 @@
 
     ///
-    /// @brief Destructor deletes underlying DataLookup2D if object is owner 
+    /// @brief Destructor deletes underlying MatrixLookup if object is owner 
     ///
     virtual ~DataLookup1D();

trunk/yat/classifier/InputRanker.h

@@ -36 +36 @@
 namespace classifier {  
 
-  class DataLookup2D;
   class MatrixLookup;
   class MatrixLookupWeighted;

trunk/yat/classifier/KernelLookup.h

@@ -298 +298 @@
        this was built from.
     
-       @note Returns a dynamically allocated DataLookup2D, which has
+       @note Returns a dynamically allocated KernelLookup, which has
        to be deleted by the caller to avoid memory leaks.
     */

trunk/yat/classifier/Makefile.am

@@ -32 +32 @@
   DataLookup1D.cc \
   DataLookupWeighted1D.cc \
-  DataLookup2D.cc \
   FeatureSelector.cc \
   FeatureSelectorIR.cc \
@@ -63 +62 @@
   CrossValidationSampler.h \
   DataLookup1D.h \
-  DataLookup2D.h \
   DataLookupWeighted1D.h \
   EnsembleBuilder.h \

trunk/yat/classifier/MatrixLookup.cc

@@ -30 +30 @@
 #include <cassert>
 #include <fstream>
+#include <vector>
 
 namespace theplu {
@@ -36 +37 @@
 
   MatrixLookup::MatrixLookup(const utility::Matrix& data, const bool own)
-    : DataLookup2D(own), data_(MatrixP(&data, own))
+    : data_(MatrixP(&data, own))
   {
     column_index_ = utility::Index(data.columns());
     row_index_ = utility::Index(data.rows());
+    assert(rows()==data.rows());
+    assert(columns()==data.columns());
+    assert(validate());
   }
   
@@ -47 +51 @@
                              const utility::Index& row, 
                              const utility::Index& col)
-    : DataLookup2D(row,col), data_(MatrixP(&data, false))
-  {
+    : column_index_(col),
+      data_(MatrixP(&data, false)), 
+      row_index_(row)
+
+  {
+    assert(rows()==row.size());
+    assert(columns()==col.size());
+    assert(validate());
   }
   
@@ -56 +66 @@
                              const utility::Index& index, 
                              const bool row)
-    : DataLookup2D(), data_(MatrixP(&data, false))
+    : data_(MatrixP(&data, false))
   {
     if (row){
@@ -66 +76 @@
       row_index_ = utility::Index(data.rows());
     }
+    assert(row || rows()==data.rows());
+    assert(row || columns()==index.size());
+    assert(!row || rows()==index.size());
+    assert(!row || columns()==data.columns());
+    assert(validate());
   }
   
@@ -71 +86 @@
 
   MatrixLookup::MatrixLookup(const MatrixLookup& other)
-    : DataLookup2D(other), data_(other.data_)
-  {
+    : column_index_(other.column_index_), 
+      data_(other.data_),
+      row_index_(other.row_index_)
+  {
+    assert(validate());
   }
 
@@ -80 +98 @@
                              const utility::Index& row, 
                              const utility::Index& col)
-    : DataLookup2D(other,row,col), data_(other.data_)
-  {
+    : column_index_(utility::Index(other.column_index_, col)), 
+      data_(other.data_), row_index_(utility::Index(other.row_index_, row)) 
+  {
+    assert(rows()==row.size());
+    assert(columns()==col.size());
+    assert(validate());
   }
   
@@ -88 +110 @@
   MatrixLookup::MatrixLookup(const MatrixLookup& other, 
                              const utility::Index& index, bool row)
-    : DataLookup2D(other,index,row), data_(other.data_)
-  {
+    : data_(other.data_)
+  {
+    if (row){
+      row_index_ = utility::Index(other.row_index_, index);
+      column_index_= other.column_index_;
+    }
+    else{
+      column_index_ = utility::Index(other.column_index_, index);
+      row_index_= other.row_index_;
+    }
+    assert(validate());
   }
   
@@ -96 +127 @@
   MatrixLookup::MatrixLookup(const size_t rows, const size_t columns, 
                              const double value)
-    : DataLookup2D(rows,columns) 
-  {
-    data_ = MatrixP(new utility::Matrix(1,1,value));
+    : data_(MatrixP(new utility::Matrix(1,1,value)))
+  {   
+    column_index_ = utility::Index(std::vector<size_t>(columns, 0));
+    row_index_ = utility::Index(std::vector<size_t>(rows,0));
+    assert(validate());
   }
 
 
   MatrixLookup::MatrixLookup(std::istream& is, char sep)
-    : DataLookup2D()
-  {
-    data_ = MatrixP(new utility::Matrix(is,sep));
+    : data_(MatrixP(new utility::Matrix(is,sep)))
+  {
+    column_index_ = utility::Index(data_->columns());
     row_index_ = utility::Index(data_->rows());
-    column_index_ = utility::Index(data_->columns());
+    assert(validate());
   }
 
@@ -133 +166 @@
   {
     return const_row_iterator(const_row_iterator::iterator_type(*this,i,0), 1);
+  }
+
+
+  size_t MatrixLookup::columns(void) const
+  {
+    return column_index_.size();
   }
 
@@ -157 +196 @@
 
 
+  size_t MatrixLookup::rows(void) const
+  {
+    return row_index_.size();
+  }
+
+
+  bool MatrixLookup::validate(void) const
+  {
+    for (size_t i=0; i<row_index_.size(); ++i)
+      if (row_index_[i]>=data_->rows())
+        return false;
+    for (size_t i=0; i<column_index_.size(); ++i)
+      if (column_index_[i]>=data_->columns())
+        return false;
+    return true;
+  }
+
+
   bool MatrixLookup::weighted(void) const 
   {
@@ -168 +225 @@
     assert(row<rows());
     assert(column<columns());
+    assert(row_index_[row]<data_->rows());
+    assert(column_index_[column]<data_->columns());
     return (*data_)(row_index_[row], column_index_[column]);
   }
@@ -176 +235 @@
   {
     if (this!=&other){
-      DataLookup2D::operator=(other);
+      row_index_ = other.row_index_;
+      column_index_ = other.column_index_;
       data_ = other.data_;
     }
+    assert(validate());
     return *this;
   }

trunk/yat/classifier/MatrixLookup.h

@@ -27 +27 @@
 */
 
-#include "DataLookup2D.h"
 #include "yat/utility/Container2DIterator.h"
 #include "yat/utility/Index.h"
@@ -72 +71 @@
   /// constructors and assignments.
   ///
-  class MatrixLookup : public DataLookup2D
+  class MatrixLookup
   {
   public:
@@ -257 +256 @@
 
     /**
+       \return number of columns
+    */
+    size_t columns(void) const;
+
+    /**
        \return const_iterator pointing to end of matrix
      */
@@ -270 +274 @@
      */
     const_row_iterator end_row(size_t) const;
+
+    /**
+       \return number of rows
+    */
+    size_t rows(void) const;
 
     ///
@@ -296 +305 @@
     friend class MatrixLookupWeighted;
 
+    utility::Index column_index_;
     typedef utility::SmartPtr<const utility::Matrix> MatrixP;
     MatrixP data_;
+    utility::Index row_index_;
+
+    // for assertions
+    bool validate(void) const;
   };  
   
   ///
-  /// The output operator DataLookup2D
+  /// The output operator MatrixLookup
   ///
   std::ostream& operator<< (std::ostream& s, const MatrixLookup&);

trunk/yat/classifier/MatrixLookupWeighted.cc

@@ -27 +27 @@
 #include "yat/utility/Matrix.h"
 
-#include <algorithm>
 #include <cassert>
 #include <fstream>
+#include <vector>
 
 namespace theplu {
@@ -44 +44 @@
     row_index_ = utility::Index(data.rows());
     column_index_ = utility::Index(data.columns());
+    assert(validate());
   }
 
 
   MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data)
-    : DataLookup2D(), data_(MatrixP(&data, false))
+    : data_(MatrixP(&data, false))
   {
     utility::Matrix weights;
@@ -55 +56 @@
     row_index_ = utility::Index(data.rows());
     column_index_ = utility::Index(data.columns());
+    assert(validate());
   }
 
 
   MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& ml)
-    : DataLookup2D(ml), data_(ml.data_)
-  {
-    weights_= MatrixP(new utility::Matrix(data_->rows(), data_->columns(),1.0));
+    : column_index_(ml.column_index_), data_(ml.data_),
+      row_index_(ml.row_index_), 
+      weights_(MatrixP(new utility::Matrix(data_->rows(),data_->columns(),1.0)))
+  { 
+    assert(validate());
   }
   
@@ -69 +73 @@
                                              const utility::Index& row, 
                                              const utility::Index& col)
-    : DataLookup2D(row,col), data_(MatrixP(new utility::Matrix(data), false)), 
-      weights_(MatrixP(new utility::Matrix(weights), false))
-  {
+    : column_index_(col), data_(MatrixP(new utility::Matrix(data), false)), 
+      row_index_(row), weights_(MatrixP(new utility::Matrix(weights), false))
+  {
+    assert(validate());
   }
   
@@ -80 +85 @@
                                              const utility::Index& index, 
                                              const bool row)
-    : DataLookup2D(), data_(MatrixP(new utility::Matrix(data), false)), 
+    : data_(MatrixP(new utility::Matrix(data), false)), 
       weights_(MatrixP(new utility::Matrix(weights), false))
   {
@@ -93 +98 @@
       row_index_ = utility::Index(data.rows());
     }
+    assert(validate());
   }
   
@@ -106 +112 @@
 
   MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other)
-    : DataLookup2D(other), data_(other.data_), weights_(other.weights_)
-  {
+    : column_index_(other.column_index_), data_(other.data_), 
+      row_index_(other.row_index_), weights_(other.weights_)
+  {
+    assert(validate());
   }
 
@@ -115 +123 @@
                                              const utility::Index& row, 
                                              const utility::Index& col)
-    : DataLookup2D(other,row,col), data_(other.data_), weights_(other.weights_)
-  {
+    : column_index_(utility::Index(other.column_index_, col)), 
+      data_(other.data_), row_index_(utility::Index(other.row_index_, row)), 
+      weights_(other.weights_)
+  {
+    assert(validate());
   }
   
@@ -124 +135 @@
                                              const utility::Index& index, 
                                              bool row)
-    : DataLookup2D(other,index,row), data_(other.data_), 
+    : data_(other.data_), 
       weights_(other.weights_)
   {
+    if (row){
+      row_index_ = utility::Index(other.row_index_, index);
+      column_index_= other.column_index_;
+    }
+    else{
+      column_index_ = utility::Index(other.column_index_, index);
+      row_index_= other.row_index_;
+    }
+    assert(validate());
   }
   
@@ -135 +155 @@
                                              const double value,
                                              const double weight)
-    : DataLookup2D(rows,columns),
+    : column_index_(utility::Index(std::vector<size_t>(rows, 0))),
       data_(MatrixP(new utility::Matrix(1,1,value))),
+      row_index_(utility::Index(std::vector<size_t>(columns, 0))), 
       weights_(MatrixP(new utility::Matrix(1,1,weight)))
   {
+    assert(validate());
   }
 
   
   MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
-    : DataLookup2D()
-  {
-    data_ = MatrixP(new utility::Matrix(is,sep));
+    : data_(MatrixP(new utility::Matrix(is,sep)))
+  {
+    column_index_ = utility::Index(data_->columns());
     row_index_ = utility::Index(data_->rows());
-    column_index_ = utility::Index(data_->columns());
     utility::Matrix weights;
     utility::nan(*data_,weights);
     // Peter, should be possible to avoid this copying
     weights_= MatrixP(new utility::Matrix(weights));
+    assert(validate());
   }
   
@@ -183 +205 @@
 
 
+  size_t MatrixLookupWeighted::columns(void) const
+  {
+    return column_index_.size();
+  }
+
+
   double MatrixLookupWeighted::data(size_t row, size_t column) const
   {
+    assert(row<rows());
+    assert(column<columns());
+    assert(row_index_[row]<data_->rows());
+    assert(column_index_[column]<data_->columns());
     return (*data_)(row_index_[row], column_index_[column]);
   }
@@ -212 +244 @@
 
 
+  size_t MatrixLookupWeighted::rows(void) const
+  {
+    return row_index_.size();
+  }
+
+
+  bool MatrixLookupWeighted::validate(void) const
+  {
+    for (size_t i=0; i<row_index_.size(); ++i)
+      if (row_index_[i]>=data_->rows())
+        return false;
+    for (size_t i=0; i<column_index_.size(); ++i)
+      if (column_index_[i]>=data_->columns())
+        return false;
+    for (size_t i=0; i<row_index_.size(); ++i)
+      if (row_index_[i]>=weights_->rows())
+        return false;
+    for (size_t i=0; i<column_index_.size(); ++i)
+      if (column_index_[i]>=weights_->columns())
+        return false;
+    return true;
+  }
+
+
   double MatrixLookupWeighted::weight(size_t row, size_t column) const
   {
+    assert(row<rows());
+    assert(column<columns());
+    assert(row_index_[row]<weights_->rows());
+    assert(column_index_[column]<weights_->columns());
     return (*weights_)(row_index_[row], column_index_[column]);
   }
@@ -238 +298 @@
   {
     if (this!=&other){
-      DataLookup2D::operator=(other);
+      column_index_=other.column_index_;
+      row_index_=other.row_index_;
       data_ = other.data_;
       weights_ = other.weights_;
     }
+    assert(validate());
     return *this;
   }

trunk/yat/classifier/MatrixLookupWeighted.h

@@ -26 +26 @@
 */
 
-#include "DataLookup2D.h"
 #include "yat/utility/Container2DIterator.h"
+#include "yat/utility/Index.h"
 #include "yat/utility/IteratorPolicy.h"
 #include "yat/utility/SmartPtr.h"
@@ -67 +67 @@
   /// constructors and assignments.
   ///
-  class MatrixLookupWeighted : public DataLookup2D
+  class MatrixLookupWeighted
   {
   
@@ -284 +284 @@
     const_row_iterator begin_row(size_t) const;
 
+    /**
+       \return number of columns
+    */
+    size_t columns(void) const;
+
     ///
     /// @return data value of element (@a row, @a column)
@@ -303 +308 @@
      */
     const_row_iterator end_row(size_t) const;
+
+    /**
+       \return number of rows
+    */
+    size_t rows(void) const;
 
     ///
@@ -333 +343 @@
   private:
     typedef utility::SmartPtr<const utility::Matrix> MatrixP;
+    utility::Index column_index_;
     MatrixP data_;
+    utility::Index row_index_;
     MatrixP weights_;
+
+    // for assertions
+    bool validate(void) const;
   };  
   

trunk/yat/classifier/SVM.h

@@ -74 +74 @@
     ///
     virtual ~SVM();
-
-    //const DataLookup2D& data(void) const;
 
     ///