Changeset 2338

Timestamp:

Oct 16, 2010, 7:00:12 AM (13 years ago)

Author:

Peter

Message:

adding an archetype class for distance concept and use that class in KNN and NCC. Adding CopyConstructible? to requirement for Distance concept

Location:

trunk

Files:

• doc/concepts.doxygen (modified) (1 diff)
• test/Suite.h (modified) (2 diffs)
• test/knn_test.cc (modified) (3 diffs)
• test/ncc_test.cc (modified) (2 diffs)
• yat/utility/concept_check.h (modified) (1 diff)

trunk/doc/concepts.doxygen

@@ -297 +297 @@
 \section Requirements
 
-Classes modelling the concept \ref concept_distance should implement
-the following public function:
+Classes modelling the concept \ref concept_distance should have a copy
+constructor 
+
+\verbatim
+Distance(const Distance& d);
+\endverbatim
+
+and also implement the following public function:
 
 \verbatim

trunk/test/Suite.h

@@ -23 +23 @@
   along with yat. If not, see <http://www.gnu.org/licenses/>.
 */
+
+#include <boost/concept_archetype.hpp>
 
 #include <iosfwd>
@@ -219 +221 @@
     reference operator()(size_t row, size_t column)
     { return this->element_; }
+  };
+
+  /*
+    class to test (at compile time) that a function (or class) works
+    with a Distance. Do not run any test using this class because
+    the class is not really functional at run time.
+
+    \see boost/concept_archetype.hpp
+   */
+  class distance_archetype
+  {
+  public:
+    /// class must be constructible somehow, but we don't wanna assume
+    /// void constructor or any other common constructor so we use the
+    /// signature to allow construction without assuming too much.
+    distance_archetype(const boost::detail::dummy_constructor&) {};
+    distance_archetype(const distance_archetype&) {};
+    template<typename T1, typename T2>
+    double operator()(T1 first1, T1 last1, T2 first2) const { return 0.0; }
+  private:
+    distance_archetype(void);
+    distance_archetype& operator=(const distance_archetype&);
   };
 

trunk/test/knn_test.cc

@@ -43 +43 @@
 using namespace theplu::yat;
 
+void compile_test(test::Suite&);
 utility::Matrix data(void);
 utility::MatrixWeighted data_weighted(void);
@@ -55 +56 @@
 std::vector<std::string> vec_target(void);
 
+
 int main(int argc, char* argv[])
 {  
@@ -66 +68 @@
   test_no_samples(suite);
   test_no_features(suite);
+  compile_test(suite);
   return suite.return_value();
 } 
+
+
+void compile_test(test::Suite& suite)
+{
+  if (false) {
+    boost::detail::dummy_constructor dummy;
+    test::distance_archetype distance(dummy);
+    classifier::KNN<test::distance_archetype> knn(distance);
+    knn.k(3);
+    knn.k();
+    classifier::SupervisedClassifier* knn2 = knn.make_classifier();
+    delete knn2;
+    utility::Matrix result;
+    knn.train(classifier::MatrixLookup(data()), classifier::Target());
+    knn.train(classifier::MatrixLookupWeighted(data_weighted()), 
+              classifier::Target());
+    knn.predict(classifier::MatrixLookup(data()), result);
+    knn.predict(classifier::MatrixLookupWeighted(data_weighted()), result);
+  }
+}
 
 

trunk/test/ncc_test.cc

@@ -47 +47 @@
 
 void predict_nan_data_unweighted_data(test::Suite& suite);
+void compile_test(test::Suite& suite);
 
 int main(int argc,char* argv[])
@@ -259 +260 @@
     suite.err() << "Difference to stored prediction too large\n";
   }
+  compile_test(suite);
 
   return suite.return_value();
 }
+
+
+void compile_test(test::Suite& suite)
+{
+  if (false) {
+    boost::detail::dummy_constructor dummy;
+    test::distance_archetype distance(dummy);
+    classifier::NCC<test::distance_archetype> ncc(distance);
+  }
+}
+
 
 void predict_nan_data_unweighted_data(test::Suite& suite)

trunk/yat/utility/concept_check.h

@@ -261 +261 @@
   */
   template <class T>
-  class DistanceConcept
+  class DistanceConcept : boost::CopyConstructible<T>
   {
   public: