Changeset 1385 for trunk

Timestamp:

Jul 22, 2008, 7:32:53 PM (13 years ago)

Author:

Peter

Message:

adding functions inverse

Location:

trunk

Files:

• test/utility_test.cc (modified) (2 diffs)
• yat/utility/stl_utility.h (modified) (2 diffs)

trunk/test/utility_test.cc

@@ -32 +32 @@
 #include <fstream>
 #include <iostream>
+#include <map>
 #include <string>
+#include <vector>
 
 using namespace theplu::yat;
 void test_quantile_normalize(test::Suite&);
+void test_inverse(test::Suite&);
+
+template<typename InputIterator, typename Key>
+void test_inverse_validate(InputIterator first, InputIterator last,
+                           const std::map<Key, std::vector<size_t> >& m,
+                           test::Suite& suite);
+template<typename InputIterator, typename Key>
+void test_inverse_validate(InputIterator first,
+                           const std::multimap<Key, size_t>& m,
+                           test::Suite& suite);
 
 int main(int argc, char* argv[])
@@ -140 +152 @@
 
   test_quantile_normalize(suite);
+  test_inverse(suite);
 
   return suite.return_value();
 }
+
+
+void test_inverse(test::Suite& suite)
+{
+  suite.err() << "Testing inverse\n";
+  std::vector<std::string> vec;
+  vec.push_back("No");
+  vec.push_back("one");
+  vec.push_back("shall");
+  vec.push_back("be");
+  vec.push_back("subjected");
+  std::map<std::string, std::vector<size_t> > map;
+  utility::inverse(vec.begin(), vec.end(), map);
+  test_inverse_validate(vec.begin(), vec.end(), map, suite);
+  utility::inverse(vec.begin()+1, vec.end(), map);
+  test_inverse_validate(vec.begin()+1, vec.end(), map, suite);
+  const std::vector<std::string> vec2(vec);
+  utility::inverse(vec2.begin(), vec2.end(), map);
+  test_inverse_validate(vec2.begin(), vec2.end(), map, suite);
+  std::multimap<std::string, size_t> mmap;
+  utility::inverse(vec.begin(), vec.end(), mmap);
+  test_inverse_validate(vec.begin(), mmap, suite);
+  utility::inverse(vec.begin()+1, vec.end(), mmap);
+  test_inverse_validate(vec.begin()+1, mmap, suite);
+}
+
+
+template<typename InputIterator, typename Key>
+void test_inverse_validate(InputIterator first, InputIterator last,
+                           const std::map<Key, std::vector<size_t> >& m,
+                           test::Suite& suite)
+{
+  typedef typename std::map<Key, std::vector<size_t> >::const_iterator Iter;
+  for ( InputIterator iter=first; iter != last; ++iter) {
+    Iter map_iter = m.find(*iter);
+    if (!suite.add(map_iter!=m.end())) {
+      suite.err() << "test_inverse_validate() failed\n";
+      suite.err() << "  could not find: " << *first << " in map m\n";
+    }
+    for (size_t i=0; i<map_iter->second.size(); ++i)
+      if (!suite.add(map_iter->second[i] ==
+                     static_cast<size_t>(distance(first, iter))) ) {
+        suite.err() << "test_inverse_validate() failed\n";
+        suite.err() << "  comparing: " << map_iter->second[i] 
+                    << " and " << distance(first, iter) 
+                    << " expected them to be equal\n";
+      }
+  }
+}
+
+
+template<typename InputIterator, typename Key>
+void test_inverse_validate(InputIterator first,
+                           const std::multimap<Key, size_t>& m,
+                           test::Suite& suite)
+{
+  for (typename std::multimap<Key, size_t>::const_iterator iter=m.begin();
+       iter!=m.end(); ++iter) {
+    suite.add(*(first + iter->second) == iter->first);
+  }
+  
+}
+
 
 void test_quantile_normalize(test::Suite& suite)

trunk/yat/utility/stl_utility.h

@@ -39 +39 @@
 #include <cmath>
 #include <functional>
+#include <map>
 #include <ostream>
 #include <string>
 #include <utility>
+#include <vector>
+
+// debug
+#include <iostream>
 
 namespace std {
@@ -133 +138 @@
     { return std::exp(x); }
   };
+
+  /**
+     Creating a map from a range [first, last) such that m[key]
+     returns a vector with indices of which element in [first, last)
+     that is equal to \a key, or more technically: m[element].size()
+     returns number of elements equal to \a element, and
+     m[*element][i] = distance(first, element) for every \a element in
+     [first, last) and \a i smaller than m[element].size().
+
+     Requirement: InputIterator's value type is assignable to Key
+
+     \since New in yat 0.5
+   */
+  template<typename InputIterator, typename Key>
+  void inverse(InputIterator first, InputIterator last,
+               std::map<Key, std::vector<size_t> >& m)
+  {
+    m.clear();
+    for (size_t i=0; first!=last; ++i, ++first)
+      m[*first].push_back(i);
+  }
+
+  /**
+     In the created multimap each element e will fulfill: \f$ *(first
+     + e->second) == e->first \f$
+
+     Requirement: InputIterator's value type is assignable to Key
+
+     \since New in yat 0.5
+   */
+  template<typename Key, typename InputIterator>
+  void inverse(InputIterator first, InputIterator last, 
+               std::multimap<Key, size_t>& m)
+  {
+    m.clear();
+    for (size_t i=0; first!=last; ++i, ++first)
+      m.insert(std::make_pair(*first, i));
+  }
+
 
   /**