Changeset 3103

Timestamp:

Nov 2, 2013, 3:21:04 AM (10 years ago)

Author:

Peter

Message:

avoid compiler warning (-Wall) with gcc 4.8

Location:

trunk

Files:

• test/Suite.h (modified) (2 diffs)
• test/data_lookup_1d.cc (modified) (8 diffs)
• test/data_weight_proxy.cc (modified) (1 diff)
• test/regression.cc (modified) (1 diff)
• test/statistics.cc (modified) (5 diffs)
• test/utility.cc (modified) (1 diff)
• yat/utility/concept_check.h (modified) (3 diffs)

trunk/test/Suite.h

@@ -323 +323 @@
   bool run_as_root(void);
 
+  // function that can be used to avoid warning: '-Wunused-but-set-variable'
+  template<typename T>
+  void dummie_function(T) {}
+
   template<class T>
   bool Suite::test_stream(const T& t) const
@@ -466 +470 @@
     size_t cols = c.columns();
     size_t rows = c.rows();
-    cols = rows; // just to avoid compiler warning
+    // just to avoid compiler warning
+    dummie_function(cols);
+    dummie_function(rows);
     const_reference x = c(0,0);
     value_type y;
     y = x;
+    dummie_function(y);
   }
 

trunk/test/data_lookup_1d.cc

@@ -49 +49 @@
 
   suite.err() << "Testing Lookup Classes" << std::endl;
-  bool ok = true;
-
   suite.err() << "Testing DataLookup1D" << std::endl;
   utility::Matrix gsl_m1(matrix(5));
@@ -69 +67 @@
   if (v1.size()!=m1.columns() || v1(0)!=m1(1,0) || 
       v1(1)!=m1(1,1) ) {
-    ok =false;
+    suite.add(false);
     suite.err() << "\nERROR" << std::endl;
     suite.err() << "size: " << v1.size() << " expected " << m1.columns() << "\n" 
@@ -83 +81 @@
   classifier::DataLookup1D v2(m1,1,false);
   if (v2.size()!=m1.rows() || v2(0)!=m1(0,1) || v2(1)!=m1(1,1) ) {
-    ok =false;
+    suite.add(false);
     suite.err() << "\nERROR\n"
            << "size: " << v2.size() << " expected " << m1.rows() << "\n" 
@@ -96 +94 @@
   classifier::DataLookup1D v3(v2);
   if (v3.size()!=v2.size() || v3(0)!=v2(0) || v3(1)!=v2(1) ) {
-    ok =false;
+    suite.add(false);
     suite.err() << "\nERROR\n"
            << "size: " << v3.size() << " expected " << v2.size() << "\n" 
@@ -109 +107 @@
   classifier::DataLookup1D v4(12,3);
   if (v4.size()!=12 || v4(10)!=3 ) {
-    ok =false;
+    suite.add(false);
     suite.err() << "\nERROR\n"
            << "size: " << v4.size() << " expected " << 12 << "\n" 
@@ -130 +128 @@
   if (v5.size()!=v1.size() || v5(0)!=v1(0) || v5(1)!=v1(1) ||
       v5(2)!=v1(2)) {
-    ok=false;
+    suite.add(false);
     suite.err() << "\nERROR\n" << std::endl;
   }
@@ -147 +145 @@
   is.close();
   if (v7.size()!=v6.size() || !std::isnan(v7(1))) {
-    ok=false;
+    suite.add(false);
     suite.err() << "\nERROR\n"
            << "size: " << v7.size() << " expected " << v6.size() << "\n" 
@@ -160 +158 @@
   classifier::convert(dl, v8);
   if (!v5.equal(v8,0.0)) {
-    ok = false;
+    suite.add(false);
     suite.err() << "Error: Creating a DataLookup1D(utility::vector)\n"
            << "and classifier::convert(DataLookup, utility::vector)\n"

trunk/test/data_weight_proxy.cc

@@ -121 +121 @@
     x = proxy.weight();
     proxy.data() = proxy.weight() = 0.0;
+    test::dummie_function(x);
   }
 

trunk/test/regression.cc

@@ -122 +122 @@
   linear_w.fit(x,y,w);
   double y_predicted = linear_w.predict(1990);
-  double y_predicted_err = linear_w.prediction_error2(1990);
   if (!suite.equal(y_predicted,12.8) ){
     suite.err() << "error: cannot reproduce fit." << std::endl;
     suite.err() << "predicted value: " << y_predicted << " expected 12.8" 
            << std::endl;
+    suite.add(false);
+  }
+  double y_predicted_err = linear_w.prediction_error2(1990);
+  if (!suite.equal_sqrt(y_predicted_err,1.2) ){
+    suite.err() << "error: cannot reproduce fit." << std::endl;
+    suite.err() << "predicted error: " << y_predicted_err << " expected 1.2\n";
     suite.add(false);
   }

trunk/test/statistics.cc

@@ -84 +84 @@
     double x = median(boost::random_access_iterator_archetype<double>(),
                       boost::random_access_iterator_archetype<double>());
+    test::dummie_function(x);
     x = median(boost::random_access_iterator_archetype<utility::DataWeight>(),
                boost::random_access_iterator_archetype<utility::DataWeight>());
+    test::dummie_function(x);
   }
   statistics::percentile2(data.begin(), data.end(), 100);
@@ -111 +113 @@
     double x = average(boost::input_iterator_archetype<double>(),
                        boost::input_iterator_archetype<double>());
-    x = average(boost::input_iterator_archetype_no_proxy<utility::DataWeight>(),
-                boost::input_iterator_archetype_no_proxy<utility::DataWeight>());
-            
-  }
-  
+    test::dummie_function(x);
+    using utility::DataWeight;
+    x = average(boost::input_iterator_archetype_no_proxy<DataWeight>(),
+                boost::input_iterator_archetype_no_proxy<DataWeight>());
+    test::dummie_function(x);
+  }
+
   test_mad(suite);
 
@@ -179 +183 @@
     double x = mad(boost::random_access_iterator_archetype<double>(),
                    boost::random_access_iterator_archetype<double>());
+    test::dummie_function(x);
     x = mad(boost::random_access_iterator_archetype<utility::DataWeight>(),
             boost::random_access_iterator_archetype<utility::DataWeight>());
+    test::dummie_function(x);
   }
 }
@@ -191 +197 @@
   double m = 0;
   m = statistics::median(x.begin(), x.end(), true);
+  test::dummie_function(m);
 }
 
@@ -255 +262 @@
     typedef random_access_iterator_archetype<double> Iterator;
     double x = percentiler(Iterator(), Iterator()); 
+    test::dummie_function(x);
     using utility::DataWeight;
     typedef random_access_iterator_archetype<DataWeight> WeigtedItererator;
     x = percentiler(WeigtedItererator(), WeigtedItererator());
+    test::dummie_function(x);
   }
 }

trunk/test/utility.cc

@@ -293 +293 @@
   const std::map<std::string, int> m2(m);
   int i = utility::get(m2, static_cast<std::string>("one"));
-  i = 0; // avoid compiler warning
+  test::dummie_function(i); // avoid compiler warning
   try {
     utility::get(m2, static_cast<std::string>("three"));

trunk/yat/utility/concept_check.h

@@ -88 +88 @@
       size_t n = t_.rows();
       n = t_.columns();
+      some_func(n);
       BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<const_iterator>));
       BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<const_row_iterator>));
@@ -94 +95 @@
 
   private:
+    void some_func(size_t x) const {}
     T t_;
     value_type value_;
@@ -279 +281 @@
       boost::random_access_iterator_archetype<double> unweighted;
       boost::random_access_iterator_archetype<DataWeight> weighted;
-      double d;
-      d = distance_(unweighted, unweighted, unweighted);
-      d = distance_(unweighted, unweighted, weighted);
-      d = distance_(weighted, weighted, unweighted);
-      d = distance_(weighted, weighted, weighted);
-    }
-  private:
+      double d=0;
+      d += distance_(unweighted, unweighted, unweighted);
+      d += distance_(unweighted, unweighted, weighted);
+      d += distance_(weighted, weighted, unweighted);
+      d += distance_(weighted, weighted, weighted);
+      // avoid compiler warning
+      func(d);
+    }
+  private:
+    void func(double x) {}
     T distance_;
   };