Changeset 1132

Timestamp:

Feb 23, 2008, 9:16:22 PM (16 years ago)

Author:

Peter

Message:

KernelLookup? is not inherited from DataLookup2D - fixes #234

Location:

trunk

Files:

• test/ncc_test.cc (modified) (1 diff)
• test/vector_test.cc (modified) (1 diff)
• yat/classifier/KernelLookup.cc (modified) (7 diffs)
• yat/classifier/KernelLookup.h (modified) (4 diffs)

trunk/test/ncc_test.cc

@@ -219 +219 @@
   *error << "done\n";
 
-  //////////////////////////////////////////////////////////////////////////
-  // Testing rejection of KernelLookups
-  //////////////////////////////////////////////////////////////////////////
-  classifier::PolynomialKernelFunction kf;
-  classifier::Kernel_MEV kernel(ml,kf);
-  classifier::DataLookup2D* dl_kernel = new classifier::KernelLookup(kernel); 
-  bool catch_error=false;
-  try {
-    catch_error=false; // should catch error here
-    *error << ncc.make_classifier(*dl_kernel,target) << std::endl;
-  }
-  catch (std::runtime_error) {    
-    *error << "caught expected bad cast runtime_error" << std::endl;
-    catch_error=true;
-  }
-  if(!catch_error) {
-    ok=false;
-  }
-  try {
-    catch_error=false; // should catch error here
-    ncc.predict(*dl_kernel,prediction); 
-  }
-  catch (std::runtime_error) {    
-    *error << "caught expected bad cast runtime_error" << std::endl;
-    catch_error=true;
-  }
-  if(!catch_error) {
-    ok=false;
-  }
-  delete dl_kernel;
-  
   if(ok)
     *error << "OK" << std::endl;

trunk/test/vector_test.cc

@@ -314 +314 @@
   }
 
+  /*
+  {
+    utility::Vector vec(10, 2.3);
+    utility::VectorView vv(vec);
+    vec = vv;
+    if (vec.size()!=10){
+      *message << "indirect self-assignment failed - size should be 10\n";
+      ok = false;
+    }
+    if (vec(0)!=2.3){
+      *message << "indirect self-assignment failed - vec(0) should be 2.3\n";
+      ok = false;
+    }
+    utility::VectorView vv2(vec, 0, 5);
+    vec = vv2;
+    if (vec.size()!=5){
+      *message << "indirect self-assignment failed - size should be 5\n";
+      ok = false;
+    }
+    if (vec(0)!=2.3){
+      *message << "indirect self-assignment failed - vec(0) should be 2.3\n";
+      ok = false;
+    }
+  }
+  */
+
   // test for ticket:285
   {

trunk/yat/classifier/KernelLookup.cc

@@ -38 +38 @@
 
   KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
-    : DataLookup2D(own), kernel_(&kernel)
-  {
+    : kernel_(&kernel)
+  {
+    if (own)
+      ref_count_ = new u_int(1);
+    else
+      ref_count_ = NULL;
     column_index_.reserve(kernel.size());
     for(size_t i=0; i<kernel.size(); i++)
@@ -51 +55 @@
                              const std::vector<size_t>& column,
                              const bool owner)
-    : DataLookup2D(row,column,owner), kernel_(&kernel)
+    : column_index_(column), kernel_(&kernel), ref_count_(NULL),
+      row_index_(row)
   {
     // Checking that each row index is less than kernel.rows()
@@ -65 +70 @@
                              const std::vector<size_t>& row, 
                              const std::vector<size_t>& column)
-    : DataLookup2D(other,row,column), kernel_(other.kernel_)
-  {
+    : kernel_(other.kernel_)
+  {
+    assert(row_index_.empty());
+    row_index_.reserve(row.size());
+    for (size_t i=0; i<row.size(); i++) {
+      assert(row[i]<other.row_index_.size());
+      row_index_.push_back(other.row_index_[row[i]]);
+    }
+    assert(column_index_.empty());
+    column_index_.reserve(column.size());
+    for (size_t i=0; i<column.size(); i++) {
+      assert(column[i]<other.column_index_.size());
+      column_index_.push_back(other.column_index_[column[i]]);
+    }
     ref_count_=other.ref_count_;
     if (ref_count_)
@@ -74 +91 @@
 
   KernelLookup::KernelLookup(const KernelLookup& other)
-    : DataLookup2D(other), kernel_(other.kernel_)
+    : column_index_(other.column_index_), kernel_(other.kernel_), 
+      row_index_(other.row_index_)
   {
     // Checking that no index is out of range
@@ -92 +110 @@
                              const std::vector<size_t>& index, 
                              const bool row)
-    : DataLookup2D(other,index,row), kernel_(other.kernel_)
-  {
+    : kernel_(other.kernel_)
+  {
+    if (row){
+      assert(row_index_.empty());
+      row_index_.reserve(index.size());
+      for (size_t i=0; i<index.size(); i++) {
+        assert(index[i]<other.row_index_.size());
+        row_index_.push_back(other.row_index_[index[i]]);
+      }
+      column_index_= other.column_index_;
+    }
+    else{
+      assert(column_index_.empty());
+      column_index_.reserve(index.size());
+      for (size_t i=0; i<index.size(); i++) {
+        column_index_.push_back(other.column_index_[index[i]]);
+      }
+      row_index_= other.row_index_;
+    }
     assert(kernel_->size());
 
@@ -138 +173 @@
 
 
+  size_t KernelLookup::columns(void) const
+  {
+    return column_index_.size();
+  }
+
+
   const DataLookup2D* KernelLookup::data(void) const
   {
@@ -173 +214 @@
   {
     return const_row_iterator(const_row_iterator::iterator_type(*this,i+1,0),1);
+  }
+
+
+  size_t KernelLookup::rows(void) const
+  {
+    return row_index_.size();
   }
 

trunk/yat/classifier/KernelLookup.h

@@ -66 +66 @@
   /// constructors and assignments.
   ///
-  class KernelLookup : public DataLookup2D 
+  class KernelLookup
   {
 
@@ -199 +199 @@
     const_row_iterator begin_row(size_t) const;
 
+    /**
+       \return number of columns
+    */
+    size_t columns(void) const;
+
     ///
     /// Each column in returned DataLookup corresponds to the column
@@ -243 +248 @@
      */
     const_row_iterator end_row(size_t) const;
+
+    /**
+       \return number of rows
+    */
+    size_t rows(void) const;
 
     /**
@@ -326 +336 @@
     const KernelLookup& operator=(const KernelLookup&);
 
+    std::vector<size_t> column_index_;
     const Kernel* kernel_;
+    ///
+    /// poiter telling how many owners to underlying data. NULL if
+    /// this is not an owner.
+    ///
+    u_int* ref_count_;
+    std::vector<size_t> row_index_;
     
   }; // class KernelLookup