Changeset 1163

Timestamp:

Feb 26, 2008, 6:15:43 PM (16 years ago)

Author:

Peter

Message:

replacing DataLookup2D* data_ in Kernel with a MatrixLookup?*. The weighted case was already covered by a MatrixLookup2D*

Location:

trunk/yat/classifier

Files:

• Kernel.cc (modified) (10 diffs)
• Kernel.h (modified) (1 diff)
• Kernel_MEV.cc (modified) (1 diff)
• Kernel_SEV.cc (modified) (2 diffs)

trunk/yat/classifier/Kernel.cc

@@ -30 +30 @@
 #include "MatrixLookupWeighted.h"
 
+#include <cassert>
 #include <vector>
 
@@ -38 +39 @@
   Kernel::Kernel(const MatrixLookup& data, const KernelFunction& kf, 
                  const bool own) 
-    : data_(&data), data_w_(0), kf_(&kf), ref_count_w_(NULL)
+    : ml_(&data), mlw_(0), kf_(&kf), ref_count_w_(NULL)
   {
     if (own)
@@ -49 +50 @@
   Kernel::Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf,
                  const bool own) 
-    : data_(&data), data_w_(&data), kf_(&kf)
+    : ml_(NULL), mlw_(&data), kf_(&kf)
   {
     if (own){
-      ref_count_ = new u_int(1);
       ref_count_w_ = new u_int(1);
     }
     else {
-      ref_count_ = NULL;
       ref_count_w_ = NULL;
     }
+    ref_count_ = NULL;
   }
 
@@ -65 +65 @@
     : kf_(other.kf_)
   {
-    data_ = other.data_->selected(utility::Index(index));
-    ref_count_ = new u_int(1);
     
-    if (other.data_w_){
-      data_w_ = other.data_w_->selected(utility::Index(index));
+    if (other.weighted()){
+      mlw_ = other.mlw_->selected(utility::Index(index));
       ref_count_w_ = new u_int(1);
+      ml_=NULL;
+      ref_count_ = NULL;
     }
     else{
-      data_w_=NULL;
+      ml_ = other.ml_->selected(utility::Index(index));
+      ref_count_ = new u_int(1);
+      mlw_=NULL;
       ref_count_w_ = NULL;
     }
@@ -84 +86 @@
     if (ref_count_)
       if (!--(*ref_count_))
-        delete data_;
+        delete ml_;
 
     if (ref_count_w_)
       if (!--(*ref_count_w_))
-        delete data_w_;
+        delete mlw_;
 
   }
@@ -95 +97 @@
   const DataLookup2D& Kernel::data(void) const
   {
-    return *data_;
+    if (weighted())
+      return *mlw_;
+    return *ml_;
   }
 
@@ -101 +105 @@
   double Kernel::element(const DataLookup1D& vec, const size_t i) const
   {
-    if (data_w_)
-      return kf_->operator()(vec, DataLookupWeighted1D(*data_w_,i, false)); 
+    if (weighted())
+      return kf_->operator()(vec, DataLookupWeighted1D(*mlw_,i, false)); 
     else
-      return kf_->operator()(vec,DataLookup1D(dynamic_cast<const MatrixLookup&>
-                                              (*data_),i, false)); 
+      return kf_->operator()(vec,DataLookup1D(*ml_,i, false)); 
   }
 
@@ -111 +114 @@
   double Kernel::element(const DataLookupWeighted1D& vec, const size_t i) const
   {
-    if (data_w_)
-      return kf_->operator()(vec, DataLookupWeighted1D(*data_w_,i, false)); 
+    if (weighted())
+      return kf_->operator()(vec, DataLookupWeighted1D(*mlw_,i, false)); 
     else
-      return kf_->operator()(vec, DataLookup1D(dynamic_cast<const MatrixLookup&>
-                                              (*data_),i, false)); 
+      return kf_->operator()(vec, DataLookup1D(*ml_,i, false)); 
   }
 
@@ -121 +123 @@
   size_t Kernel::size(void) const
   {
-    return data_->columns();
+    if (weighted())
+      return mlw_->columns();
+    assert(ml_);
+    return ml_->columns();
   }
 
@@ -127 +132 @@
   bool Kernel::weighted(void) const
   {
-    return data_w_;
+    return mlw_;
   }
 

trunk/yat/classifier/Kernel.h

@@ -162 +162 @@
   protected:
     /// underlying data
-    const DataLookup2D* data_;
+    const MatrixLookup* ml_;
     /// same as data_ if weifghted otherwise a NULL pointer
-    const MatrixLookupWeighted* data_w_;
+    const MatrixLookupWeighted* mlw_;
     /// type of Kernel Function e.g. Gaussian (aka RBF)
     const KernelFunction* kf_;

trunk/yat/classifier/Kernel_MEV.cc

@@ -68 +68 @@
   double Kernel_MEV::operator()(const size_t row, const size_t column) const
   { 
-    if (data_w_)
-      return (*kf_)(DataLookupWeighted1D(*data_w_,row,false),
-                    DataLookupWeighted1D(*data_w_,column,false)); 
+    if (weighted())
+      return (*kf_)(DataLookupWeighted1D(*mlw_,row,false),
+                    DataLookupWeighted1D(*mlw_,column,false)); 
     else
-      return (*kf_)(DataLookup1D(dynamic_cast<const MatrixLookup&>
-                                 (*data_),row,false),
-                    DataLookup1D(dynamic_cast<const MatrixLookup&>
-                                 (*data_),column,false)); 
+      return (*kf_)(DataLookup1D(*ml_,row,false),
+                    DataLookup1D(*ml_,column,false)); 
   }
 

trunk/yat/classifier/Kernel_SEV.cc

@@ -47 +47 @@
     : Kernel(data,kf, own)
   {
-    kernel_matrix_.resize(data_->columns(),data_->columns());
+    kernel_matrix_.resize(data.columns(),data.columns());
     for (size_t i=0; i<kernel_matrix_.rows(); i++) 
       for (size_t j=i; j<kernel_matrix_.columns(); j++)
@@ -66 +66 @@
   void Kernel_SEV::build_kernel(void)
   {
-    kernel_matrix_.resize(data_->columns(),data_->columns());
+    kernel_matrix_.resize(size(),size());
     for (size_t i=0; i<kernel_matrix_.rows(); i++) 
       for (size_t j=i; j<kernel_matrix_.columns(); j++)
         kernel_matrix_(i,j) = kernel_matrix_(j,i) =
-          (*kf_)(DataLookup1D(dynamic_cast<const MatrixLookup&>(*data_),i,false),
-                 DataLookup1D(dynamic_cast<const MatrixLookup&>(*data_),j,false));
+          (*kf_)(DataLookup1D(*ml_,i,false),
+                 DataLookup1D(*ml_,j,false));
   }