Changeset 1241 for trunk

Timestamp:

Mar 16, 2008, 6:47:42 AM (15 years ago)

Author:

Peter

Message:

working on #223

Location:

trunk/test

Files:

• nbc_test.cc (modified) (3 diffs)
• ncc_test.cc (modified) (15 diffs)

trunk/test/nbc_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/classifier/MatrixLookup.h"
 #include "yat/classifier/MatrixLookupWeighted.h"
@@ -35 +37 @@
 using namespace theplu::yat;
 
-int main(const int argc,const char* argv[])
+int main(int argc, char* argv[])
 {  
-
-  std::ostream* error;
-  if (argc>1 && argv[1]==std::string("-v"))
-    error = &std::cerr;
-  else {
-    error = new std::ofstream("/dev/null");
-    if (argc>1)
-      *error << "nbc_test -v : for printing extra information\n";
-  }
-  *error << "testing ncc" << std::endl;
-  bool ok = true;
+  test::Suite suite(argc, argv);
+  suite.err() << "testing ncc" << std::endl;
 
   std::ifstream is("data/nm_data_centralized.txt");
@@ -58 +51 @@
   is.close();
 
-  *error << "Constructing NBC" << std::endl;
+  suite.err() << "Constructing NBC" << std::endl;
   classifier::NBC nbc;
-  *error << "Training NBC" << std::endl;
+  suite.err() << "Training NBC" << std::endl;
   nbc.train(data,target);
   utility::Matrix res;
-  *error << "Predicting" << std::endl;
+  suite.err() << "Predicting" << std::endl;
   nbc.predict(data, res);
 
-
-  if(ok)
-    *error << "OK" << std::endl;
-  else
-    *error << "test failed" << std::endl;
-
-  if (error!=&std::cerr)
-    delete error;
-
-  if(ok) 
-    return 0;
-  return -1;
-  
+  return suite.return_value();
 }

trunk/test/ncc_test.cc

@@ -22 +22 @@
 */
 
-#include "yat/classifier/Kernel_MEV.h"
-#include "yat/classifier/KernelLookup.h"
+#include "Suite.h"
+
 #include "yat/classifier/MatrixLookup.h"
 #include "yat/classifier/MatrixLookupWeighted.h"
 #include "yat/classifier/NCC.h"
-#include "yat/classifier/PolynomialKernelFunction.h"
 #include "yat/classifier/Target.h"
 #include "yat/utility/Matrix.h"
@@ -45 +44 @@
 using namespace theplu::yat;
 
-double deviation(const utility::Matrix& a, const utility::Matrix& b) {
-  double sl=0;
-  for (size_t i=0; i<a.rows(); i++){
-    for (size_t j=0; j<a.columns(); j++){
-      sl += std::abs(a(i,j)-b(i,j));
-    }
-  }
-  sl /= (a.columns()*a.rows());
-  return sl;
-}
-
-int main(const int argc,const char* argv[])
+int main(int argc,char* argv[])
 {  
-
-  std::ostream* error;
-  if (argc>1 && argv[1]==std::string("-v"))
-    error = &std::cerr;
-  else {
-    error = new std::ofstream("/dev/null");
-    if (argc>1)
-      std::cout << "ncc_test -v : for printing extra information\n";
-  }
-  *error << "testing ncc" << std::endl;
-  bool ok = true;
+  test::Suite suite(argc, argv);
+  suite.err() << "testing ncc" << std::endl;
 
   /////////////////////////////////////////////
@@ -78 +57 @@
   classifier::Target target(vec);
   classifier::NCC<statistics::EuclideanDistance> ncctmp;
-  *error << "training...\n";
+  suite.err() << "training...\n";
   ncctmp.train(ml,target);
-  *error << "done\n";
+  suite.err() << "done\n";
 
   /////////////////////////////////////////////
   // A test of predictions using unweighted data
   /////////////////////////////////////////////
-  *error << "test of predictions using unweighted test data\n";
+  suite.err() << "test of predictions using unweighted test data\n";
   utility::Matrix data1(3,4);
   for(size_t i=0;i<3;i++) {
@@ -104 +83 @@
   utility::Matrix prediction1;
   ncc1.predict(ml1,prediction1);
-  double slack_bound=2e-7;
   utility::Matrix result1(2,4);
   result1(0,0)=result1(0,1)=result1(1,2)=result1(1,3)=sqrt(3.0);
   result1(0,2)=result1(0,3)=result1(1,0)=result1(1,1)=sqrt(11.0);
-  double slack = deviation(prediction1,result1); 
-  if (slack > slack_bound || std::isnan(slack)){
-    *error << "Difference to expected prediction too large\n";
-    *error << "slack: " << slack << std::endl;
-    *error << "expected less than " << slack_bound << std::endl;
-    ok = false;
+  if (!suite.equal_range(prediction1.begin(), prediction1.end(),
+                         result1.begin())) {
+    suite.add(false);
+    suite.err() << "Difference to expected prediction too large\n";
   }
 
@@ -119 +95 @@
   // A test of predictions using unweighted training and weighted test data
   //////////////////////////////////////////////////////////////////////////
-  *error << "test of predictions using unweighted training and weighted test data\n";
+  suite.err() << "test of predictions using unweighted training and weighted test data\n";
   utility::Matrix weights1(3,4,1.0);
   weights1(0,0)=weights1(1,1)=weights1(2,2)=weights1(1,3)=0.0;
@@ -125 +101 @@
   ncc1.predict(mlw1,prediction1); 
   result1(0,2)=result1(0,3)=result1(1,0)=result1(1,1)=sqrt(15.0);
-  slack = deviation(prediction1,result1);
-  if (slack > slack_bound || std::isnan(slack)){
-    *error << "Difference to expected prediction too large\n";
-    *error << "slack: " << slack << std::endl;
-    *error << "expected less than " << slack_bound << std::endl;
-    ok = false;
+  if (!suite.equal_range(prediction1.begin(), prediction1.end(),
+                         result1.begin())) {
+    suite.add(false);
+    suite.err() << "Difference to expected prediction too large\n";
   }
 
@@ -137 +111 @@
   // in centroids and unweighted test data
   //////////////////////////////////////////////////////////////////////////
-  *error << "test of predictions using nan centroids and unweighted test data\n";
+  suite.err() << "test of predictions using nan centroids and unweighted test data\n";
   utility::Matrix weights2(3,4,1.0);
   weights2(1,0)=weights2(1,1)=0.0;
@@ -147 +121 @@
   result1(1,0)=result1(1,1)=sqrt(11.0);
   result1(0,2)=result1(0,3)=sqrt(15.0);
-  slack = deviation(prediction1,result1);
   if(!std::isnan(ncc2.centroids()(1,0))) 
-    ok=false;
-  if (slack > slack_bound || std::isnan(slack)){
-    *error << "Difference to expected prediction too large\n";
-    *error << "slack: " << slack << std::endl;
-    *error << "expected less than " << slack_bound << std::endl;
-    ok = false;
+    suite.add(false);
+  if (!suite.equal_range(prediction1.begin(), prediction1.end(),
+                         result1.begin())) {
+    suite.add(false);
+    suite.err() << "Difference to expected prediction too large\n";
   }
 
@@ -161 +133 @@
   // test sample has non-zero weights for.
   //////////////////////////////////////////////////////////////////////////
-  *error << "test of predictions using nan centroids and weighted test data\n";
-  *error << "... using EuclideanDistance" << std::endl;
+  suite.err() << "test of predictions using nan centroids and weighted test data\n";
+  suite.err() << "... using EuclideanDistance" << std::endl;
   weights1(0,0)=weights1(2,0)=0;
   classifier::NCC<statistics::EuclideanDistance> ncc3;
@@ -168 +140 @@
   ncc3.predict(mlw1,prediction1); 
   if(!std::isnan(ncc3.centroids()(1,0))) {
-    ok=false;
-    *error << "Training failed: expected nan in centroid" << std::endl;
+    suite.add(false);
+    suite.err() << "Training failed: expected nan in centroid" << std::endl;
   }
   if(!(std::isnan(prediction1(0,0)) &&
-       std::abs(prediction1(1,0)-sqrt(3.0))<slack_bound &&
-       std::abs(prediction1(0,1)-sqrt(3.0))<slack_bound &&
-       std::abs(prediction1(1,1)-sqrt(15.0))<slack_bound &&
-       std::abs(prediction1(0,2)-sqrt(27.0))<slack_bound)) {  
-    ok=false; 
-    *error << "Test failed: predictions incorrect" << std::endl;
-  }
-  *error << "... using PearsonDistance" << std::endl;;
+       suite.equal(prediction1(1,0),sqrt(3.0)) &&
+       suite.equal(prediction1(0,1),sqrt(3.0)) &&
+       suite.equal(prediction1(1,1),sqrt(15.0)) &&
+       suite.equal(prediction1(0,2),sqrt(27.0)) )) {  
+    suite.add(false);
+    suite.err() << "Test failed: predictions incorrect" << std::endl;
+  }
+  suite.err() << "... using PearsonDistance" << std::endl;;
   classifier::NCC<statistics::PearsonDistance> ncc4;
   ncc4.train(mlw2,target1);
   ncc4.predict(mlw1,prediction1); 
   if(!std::isnan(ncc4.centroids()(1,0))) {
-    ok=false;
-    *error << "Training failed: expected nan in centroid" << std::endl;
+    suite.add(false);
+    suite.err() << "Training failed: expected nan in centroid" << std::endl;
   }
   if(!(std::isnan(prediction1(0,0)) &&
        std::isnan(prediction1(0,2)) &&
        std::isnan(prediction1(1,0)) &&
-       std::abs(prediction1(0,1))<slack_bound &&
-       std::abs(prediction1(1,2))<slack_bound &&
-       std::abs(prediction1(1,3))<slack_bound &&  
-       std::abs(prediction1(0,3)-2.0)<slack_bound &&
-       std::abs(prediction1(1,1)-2.0)<slack_bound)) {
-    ok=false; 
-    *error << "Test failed: predictions incorrect" << std::endl;
+       suite.equal(prediction1(0,1), 0) &&
+       suite.equal(prediction1(1,2), 0) &&
+       suite.equal(prediction1(1,3), 0) &&  
+       suite.equal(prediction1(0,3), 2.0) &&
+       suite.equal(prediction1(1,1), 2.0) )) {
+    suite.add(false); 
+    suite.err() << "Test failed: predictions incorrect" << std::endl;
   }
 
@@ -214 +186 @@
         std::isnan(prediction1(0,2)) && std::isnan(prediction1(0,3)) &&
         std::isnan(prediction1(1,0)) &&
-        std::abs(prediction1(1,1)-2.0)<slack_bound &&
-        std::abs(prediction1(1,2))<slack_bound &&
-        std::abs(prediction1(1,3))<slack_bound)) {
-    *error << "Difference to expected prediction too large\n";
-    ok = false;
+        suite.equal(prediction1(1,1), 2.0) &&
+        suite.equal(prediction1(1,2),0) &&
+        suite.equal(prediction1(1,3),0) )) {
+    suite.err() << "Difference to expected prediction too large\n";
+    suite.add(false);
   }
 
@@ -224 +196 @@
   // A test of predictions using Sorlie data
   //////////////////////////////////////////////////////////////////////////
-  *error << "test with Sorlie data\n";
+  suite.err() << "test with Sorlie data\n";
   std::ifstream is("data/sorlie_centroid_data.txt");
   utility::Matrix data(is,'\t');
@@ -239 +211 @@
   classifier::MatrixLookupWeighted dataviewweighted(data,weights);
   classifier::NCC<statistics::PearsonDistance> ncc;
-  *error << "training...\n";
+  suite.err() << "training...\n";
   ncc.train(dataviewweighted,targets);
 
@@ -249 +221 @@
   if(centroids.rows() != ncc.centroids().rows() ||
      centroids.columns() != ncc.centroids().columns()) {
-    *error << "Error in the dimensionality of centroids\n";
-    *error << "Nof rows: " << centroids.rows() << " expected: " 
+    suite.err() << "Error in the dimensionality of centroids\n";
+    suite.err() << "Nof rows: " << centroids.rows() << " expected: " 
            << ncc.centroids().rows() << std::endl;
-    *error << "Nof columns: " << centroids.columns() << " expected: " 
+    suite.err() << "Nof columns: " << centroids.columns() << " expected: " 
            << ncc.centroids().columns() << std::endl;
   }
 
-  slack = deviation(centroids,ncc.centroids());
-  if (slack > slack_bound || std::isnan(slack)){
-    *error << "Difference to stored centroids too large\n";
-    *error << "slack: " << slack << std::endl;
-    *error << "expected less than " << slack_bound << std::endl;
-    ok = false;
-  }
-
-  *error << "...predicting...\n";
+  if (!suite.equal_range(centroids.begin(), centroids.end(),
+                         ncc.centroids().begin(), 100000)) {
+    suite.add(false);
+    suite.err() << "Difference to stored centroids too large\n";
+  }
+
+  suite.err() << "...predicting...\n";
   utility::Matrix prediction;
   ncc.predict(dataviewweighted,prediction);
@@ -273 +243 @@
   is.close();
 
-  slack = deviation(result,prediction);
-  if (slack > slack_bound || std::isnan(slack)){
-    *error << "Difference to stored prediction too large\n";
-    *error << "slack: " << slack << std::endl;
-    *error << "expected less than " << slack_bound << std::endl;
-    ok = false;
-  }
-  *error << "done\n";
-
-  if(ok)
-    *error << "OK" << std::endl;
-  else
-    *error << "FAILED" << std::endl;
-
-  if (error!=&std::cerr)
-    delete error;
-
-  if(ok) 
-    return 0;
-  return -1;  
+  if (!suite.equal_range(result.begin(), result.end(),
+                         prediction.begin(), 100000)) {
+    suite.add(false);
+    suite.err() << "Difference to stored prediction too large\n";
+  }
+
+  return suite.return_value();
 }