Changeset 1088

Timestamp:

Feb 14, 2008, 3:26:19 PM (16 years ago)

Author:

Peter

Message:

Closes #247. Removed IteratorWeighted? iterators over weighted container instead can use Iterator with a special Policy.

Location:

trunk

Files:

• test/iterator_test.cc (modified) (1 diff)
• yat/classifier/DataLookup2D.cc (modified) (1 diff)
• yat/classifier/DataLookup2D.h (modified) (2 diffs)
• yat/classifier/DataLookupWeighted1D.cc (modified) (2 diffs)
• yat/classifier/DataLookupWeighted1D.h (modified) (2 diffs)
• yat/classifier/EnsembleBuilder.h (modified) (1 diff)
• yat/statistics/AveragerPairWeighted.h (modified) (1 diff)
• yat/statistics/AveragerWeighted.h (modified) (1 diff)
• yat/utility/Iterator.h (modified) (1 diff)
• yat/utility/Makefile.am (modified) (1 diff)
• yat/utility/StrideIterator.h (modified) (1 diff)
• yat/utility/iterator_traits.h (modified) (1 diff)

trunk/test/iterator_test.cc

@@ -79 +79 @@
   classifier::MatrixLookupWeighted mw(m,w);
   classifier::DataLookupWeighted1D aw(mw,0,true);
-  size_t nof1=std::count(aw.begin(),aw.end(),1.0);
+  size_t nof1=std::count(aw.begin(),aw.end(),
+                         std::pair<double, double>(1.0, 1.0));
   if(nof1!=2) {
     *message << "std algoritm with IteratorWeighted failed" << std::endl;

trunk/yat/classifier/DataLookup2D.cc

@@ -123 +123 @@
 
 
+  double DataLookup2D::data(size_t i, size_t j) const
+  {
+    return (*this)(i,j);
+  }
+
+
   size_t DataLookup2D::rows(void) const
   {
     return row_index_.size();
+  }
+
+
+  double DataLookup2D::weight(size_t i, size_t j) const
+  {
+    return 1.0;
   }
 

trunk/yat/classifier/DataLookup2D.h

@@ -110 +110 @@
     size_t columns(void) const;
 
+    
+    /**
+       \return data
+    */
+    virtual double data(size_t i, size_t j) const;
+    
     ///
     /// @return number of rows
@@ -139 +145 @@
                     const std::vector<size_t>& val) const=0; 
 
+    /**
+       \return data
+    */
+    virtual double weight(size_t i, size_t j) const;
+    
     ///
     /// Is lookup weighted?

trunk/yat/classifier/DataLookupWeighted1D.cc

@@ -69 +69 @@
   DataLookupWeighted1D::const_iterator DataLookupWeighted1D::begin(void) const
   {
-    return DataLookupWeighted1D::const_iterator(*this, 0);
+    if (column_vector_)
+      return const_iterator(const_iterator::iterator_type(*matrix_, 0, index_), 
+                            matrix_->columns());
+    return const_iterator(const_iterator::iterator_type(*matrix_, index_, 0),1);
   }
 
@@ -81 +84 @@
   DataLookupWeighted1D::const_iterator DataLookupWeighted1D::end(void) const
   {
-    return DataLookupWeighted1D::const_iterator(*this, size());
+    if (column_vector_)
+      return const_iterator(const_iterator::iterator_type(*matrix_, 
+                                                          matrix_->rows(),
+                                                          index_), 
+                            matrix_->columns());
+    return const_iterator(const_iterator::iterator_type(*matrix_,index_+1,0),1);
   }
 

trunk/yat/classifier/DataLookupWeighted1D.h

@@ -26 +26 @@
 */
 
-#include "yat/utility/IteratorWeighted.h"
+#include "DataLookup2D.h"
+#include "yat/utility/Iterator.h"
+#include "yat/utility/IteratorPolicy.h"
+#include "yat/utility/StrideIterator.h"
 
 #include <iostream>
+#include <utility>
 #include <vector>
 
@@ -46 +50 @@
   
   public:
-    
-    /// 'Read Only' Iterator
-    typedef utility::IteratorWeighted<const double, const classifier::DataLookupWeighted1D> 
+    /// 'Read Only' iterator
+    typedef utility::StrideIterator<
+    utility::Iterator<const DataLookup2D, const std::pair<double, double>, 
+                      void, const std::pair<double, double>,
+                      utility::IteratorPolicyWeighted<const DataLookup2D,
+                                                      const double,
+                                                      const double> > >
     const_iterator;
 

trunk/yat/classifier/EnsembleBuilder.h

@@ -27 +27 @@
 */
 
-#include "FeatureSelector.h";
+#include "FeatureSelector.h"
 #include "Sampler.h"
 #include "SubsetGenerator.h"

trunk/yat/statistics/AveragerPairWeighted.h

@@ -149 +149 @@
   {
     for ( ; first1 != last1; ++first1, ++first2) {
-      ap.add(utility::iterator_traits_data(first1), 
-             utility::iterator_traits_data(first2),
-             utility::iterator_traits_weight(first1), 
-             utility::iterator_traits_weight(first2));
+      ap.add(utility::iterator_traits<Iter1>().data(first1), 
+             utility::iterator_traits<Iter2>().data(first2),
+             utility::iterator_traits<Iter1>().weight(first1), 
+             utility::iterator_traits<Iter2>().weight(first2));
     }
   }

trunk/yat/statistics/AveragerWeighted.h

@@ -218 +218 @@
   {
     for ( ; first != last; ++first)
-      a.add(utility::iterator_traits_data(first),
-            utility::iterator_traits_weight(first));
+      a.add(utility::iterator_traits<Iter>().data(first),
+            utility::iterator_traits<Iter>().weight(first));
   }
 

trunk/yat/utility/Iterator.h

@@ -261 +261 @@
     //Iterator& operator=(const Iterator&);
   };
+
+  /**
+     Whether Iterator is weighted is desiced by Policy.
+   */
+  template<typename A, typename B, typename C, typename D, typename Policy> 
+  struct weighted_iterator_traits<Iterator<A, B, C, D, Policy> > {
+    typedef typename Policy::weighted_iterator_type type;
+  };
+
+  template<typename A, typename B, typename C, typename D, typename E> 
+  struct iterator_traits<Iterator<A, B, C, D, E> > {
+    /**
+       \return data
+    */
+    double data(Iterator<A, B, C, D, E> iter) const 
+    { return iter.data(); }
+
+    /**
+       \return weight
+    */
+    double weight(Iterator<A, B, C, D, E> iter) const 
+    { return iter.weight(); }
+
+  };
+
+
 }}} // of namespace utility, yat, and theplu
 

trunk/yat/utility/Makefile.am

@@ -37 +37 @@
   Alignment.h ColumnStream.h CommandLine.h \
   Exception.h FileUtil.h Iterator.h IteratorPolicy.h iterator_traits.h \
-  IteratorWeighted.h kNNI.h matrix.h NNI.h \
+  kNNI.h matrix.h NNI.h \
   Option.h OptionArg.h OptionFile.h OptionInFile.h OptionOutFile.h \
   OptionHelp.h OptionSwitch.h \

trunk/yat/utility/StrideIterator.h

@@ -44 +44 @@
   struct weighted_iterator_traits<StrideIterator<Iter> > {
     typedef typename weighted_iterator_traits<Iter>::type type;
+  };
+
+  template <class Iter>
+  struct iterator_traits<StrideIterator<Iter> > {
+    /**
+       \return data that is *iter
+    */
+    double data(StrideIterator<Iter> iter) const 
+    { iterator_traits<Iter> jojo;
+      return jojo.data(iter.base()); }
+
+    /**
+       \return 1.0
+    */
+    double weight(StrideIterator<Iter> iter) const 
+    { return iterator_traits<Iter>().weight(iter.base()); }
+
   };
 

trunk/yat/utility/iterator_traits.h

@@ -120 +120 @@
 
   /**
-    Function to be used to make compile-time decision how to return
-    data from an iterator separating two cases: weighted and
-    unweighted.
+     \brief traits to make unweighted iterator work in as a weighted
 
-    In this way unweighted iterators can be used in a weighted context.
+     This class must be implemented for every iterator that can be weighted.
+
+     \see StrideIterator and Iterator
    */ 
-  // Peter, perhaps these should be templatized, but for now return
-  // type double is hard coded.
   template <class Iter>
-  double iterator_traits_data(Iter iter)
-  { return iterator_traits_data(iter, typename 
-                                weighted_iterator_traits<Iter>::type()); } 
+  struct iterator_traits {
+    // Peter, perhaps these should be templatized, but for now return
+    // type double is hard coded.
+    /**
+       \return data that is *iter
+    */
+    double data(Iter iter) const 
+    { check_iterator_is_unweighted(iter); return *iter; }
 
-  /**
-     \return data for weighted iterator
-   */
-  template <class Iter>
-  double iterator_traits_data(Iter i, weighted_type)
-  { return i.data(); } 
+    /**
+       \return 1.0
+    */
+    double weight(Iter iter) const 
+    { check_iterator_is_unweighted(iter); return 1.0; }
 
-  /**
-     \return data for unweighted data
-   */
-  template <class Iter>
-  double iterator_traits_data(Iter i, unweighted_type)
-  { return *i; } 
-
-  /**
-    Function to be used to make compile-time decision how to return
-    data from an iterator separating two cases: weighted and
-    unweighted.
-
-    In this way unweighted iterators can be used in a weighted context
-    and weight will be set to unity.
-   */ 
-  // Peter, perhaps these should be templatized, but for now return
-  // type double is hard coded.
-  template <class Iter>
-  double iterator_traits_weight(Iter iter)
-  { return iterator_traits_weight(iter, typename 
-                                  weighted_iterator_traits<Iter>::type()); } 
-
-  /**
-     \return weight for weighted iterator
-   */
-  template <class Iter>
-  double iterator_traits_weight(Iter i, weighted_type)
-  { return i.weight(); } 
-
-  /**
-     \return weight for unweighted iterator
-   */
-  template <class Iter>
-  double iterator_traits_weight(Iter i, unweighted_type)
-  { return 1.0; } 
-
+  };
 
 }}} // of namespace utility, yat, and theplu