Introduced DAI_DEBASSERT macro to abbreviate a common pattern
authorJoris Mooij <joris.mooij@tuebingen.mpg.de>
Fri, 4 Sep 2009 15:08:21 +0000 (17:08 +0200)
committerJoris Mooij <joris.mooij@tuebingen.mpg.de>
Fri, 4 Sep 2009 15:08:21 +0000 (17:08 +0200)
doxygen.conf
include/dai/bipgraph.h
include/dai/clustergraph.h
include/dai/factor.h
include/dai/prob.h
include/dai/util.h

index c26af9d..59bd5a2 100644 (file)
@@ -1258,7 +1258,8 @@ PREDEFINED             = DAI_WITH_BP \
                          DAI_WITH_MR \
                          DAI_WITH_CBP \
                          DAI_ACCMUT \
-                         DAI_DEBUG
+                         DAI_DEBUG \
+                         DAI_DEBASSERT
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
 # this tag can be used to specify a list of macro names that should be expanded. 
index 3d5479b..83053d4 100644 (file)
@@ -185,65 +185,49 @@ class BipartiteGraph {
 
         /// Returns constant reference to the _i2'th neighbor of node i1 of type 1
         const Neighbor & nb1( size_t i1, size_t _i2 ) const { 
-#ifdef DAI_DEBUG
-            assert( i1 < _nb1.size() );
-            assert( _i2 < _nb1[i1].size() );
-#endif
+            DAI_DEBASSERT( i1 < _nb1.size() );
+            DAI_DEBASSERT( _i2 < _nb1[i1].size() );
             return _nb1[i1][_i2]; 
         }
         /// Returns reference to the _i2'th neighbor of node i1 of type 1
         Neighbor & nb1( size_t i1, size_t _i2 ) {
-#ifdef DAI_DEBUG
-            assert( i1 < _nb1.size() );
-            assert( _i2 < _nb1[i1].size() );
-#endif
+            DAI_DEBASSERT( i1 < _nb1.size() );
+            DAI_DEBASSERT( _i2 < _nb1[i1].size() );
             return _nb1[i1][_i2]; 
         }
 
         /// Returns constant reference to the _i1'th neighbor of node i2 of type 2
         const Neighbor & nb2( size_t i2, size_t _i1 ) const { 
-#ifdef DAI_DEBUG
-            assert( i2 < _nb2.size() );
-            assert( _i1 < _nb2[i2].size() );
-#endif
+            DAI_DEBASSERT( i2 < _nb2.size() );
+            DAI_DEBASSERT( _i1 < _nb2[i2].size() );
             return _nb2[i2][_i1]; 
         }
         /// Returns reference to the _i1'th neighbor of node i2 of type 2
         Neighbor & nb2( size_t i2, size_t _i1 ) { 
-#ifdef DAI_DEBUG
-            assert( i2 < _nb2.size() );
-            assert( _i1 < _nb2[i2].size() );
-#endif
+            DAI_DEBASSERT( i2 < _nb2.size() );
+            DAI_DEBASSERT( _i1 < _nb2[i2].size() );
             return _nb2[i2][_i1]; 
         }
 
         /// Returns constant reference to all neighbors of node i1 of type 1
         const Neighbors & nb1( size_t i1 ) const { 
-#ifdef DAI_DEBUG
-            assert( i1 < _nb1.size() );
-#endif
+            DAI_DEBASSERT( i1 < _nb1.size() );
             return _nb1[i1]; 
         }
         /// Returns reference to all neighbors of node of i1 type 1
         Neighbors & nb1( size_t i1 ) { 
-#ifdef DAI_DEBUG
-            assert( i1 < _nb1.size() );
-#endif
+            DAI_DEBASSERT( i1 < _nb1.size() );
             return _nb1[i1]; 
         }
 
         /// Returns constant reference to all neighbors of node i2 of type 2
         const Neighbors & nb2( size_t i2 ) const { 
-#ifdef DAI_DEBUG
-            assert( i2 < _nb2.size() );
-#endif
+            DAI_DEBASSERT( i2 < _nb2.size() );
             return _nb2[i2]; 
         }
         /// Returns reference to all neighbors of node i2 of type 2
         Neighbors & nb2( size_t i2 ) { 
-#ifdef DAI_DEBUG
-            assert( i2 < _nb2.size() );
-#endif
+            DAI_DEBASSERT( i2 < _nb2.size() );
             return _nb2[i2]; 
         }
 
index 654fbbc..cbea8ca 100644 (file)
@@ -68,9 +68,7 @@ namespace dai {
             
             /// Returns true if cluster I is not contained in a larger cluster
             bool isMaximal( size_t I ) const {
-#ifdef DAI_DEBUG
-                assert( I < G.nr2() );
-#endif
+                DAI_DEBASSERT( I < G.nr2() );
                 const VarSet & clI = clusters[I];
                 bool maximal = true;
                 // The following may not be optimal, since it may repeatedly test the same cluster *J
index 42df4ce..c116f4c 100644 (file)
@@ -37,6 +37,7 @@
 #include <dai/prob.h>
 #include <dai/varset.h>
 #include <dai/index.h>
+#include <dai/util.h>
 
 
 namespace dai {
@@ -109,9 +110,7 @@ template <typename T> class TFactor {
 
         /// Constructs TFactor depending on variables in ns, with values set to the TProb p
         TFactor( const VarSet& ns, const TProb<T>& p ) : _vs(ns), _p(p) {
-#ifdef DAI_DEBUG
-            assert( _vs.nrStates() == _p.size() );
-#endif
+            DAI_DEBASSERT( _vs.nrStates() == _p.size() );
         }
         
         /// Constructs TFactor depending on the variable n, with uniform distribution
@@ -454,6 +453,7 @@ template<typename T> TFactor<T> TFactor<T>::maxMarginal(const VarSet & ns, bool
 }
 
 
+/// Apply binary operator pointwise on two factors
 template<typename T, typename binaryOp> TFactor<T> pointwiseOp( const TFactor<T> &f, const TFactor<T> &g, binaryOp op ) {
     if( f.vars() == g.vars() ) { // optimizate special case
         TFactor<T> result(f); 
@@ -475,11 +475,9 @@ template<typename T, typename binaryOp> TFactor<T> pointwiseOp( const TFactor<T>
 
 
 template<typename T> T TFactor<T>::strength( const Var &i, const Var &j ) const {
-#ifdef DAI_DEBUG
-    assert( _vs.contains( i ) );
-    assert( _vs.contains( j ) );
-    assert( i != j );
-#endif
+    DAI_DEBASSERT( _vs.contains( i ) );
+    DAI_DEBASSERT( _vs.contains( j ) );
+    DAI_DEBASSERT( i != j );
     VarSet ij(i, j);
 
     T max = 0.0;
@@ -525,9 +523,7 @@ template<typename T> Real dist( const TFactor<T> &f, const TFactor<T> &g, Prob::
     if( f.vars().empty() || g.vars().empty() )
         return -1;
     else {
-#ifdef DAI_DEBUG
-        assert( f.vars() == g.vars() );
-#endif
+        DAI_DEBASSERT( f.vars() == g.vars() );
         return dist( f.p(), g.p(), dt );
     }
 }
index 4b85374..ed3a932 100644 (file)
@@ -180,9 +180,7 @@ template <typename T> class TProb {
 
         /// Divides each entry by scalar x
         TProb<T>& operator/= (T x) {
-#ifdef DAI_DEBUG
-            assert( x != 0.0 );
-#endif
+            DAI_DEBASSERT( x != 0.0 );
             std::transform( _p.begin(), _p.end(), _p.begin(), std::bind2nd( std::divides<T>(), x ) );
             return *this;
         }
@@ -222,9 +220,7 @@ template <typename T> class TProb {
 
         /// Lexicographical comparison (sizes should be identical)
         bool operator<= (const TProb<T> & q) const {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             for( size_t i = 0; i < size(); i++ )
                 if( !(_p[i] <= q[i]) )
                     return false;
@@ -233,18 +229,14 @@ template <typename T> class TProb {
 
         /// Pointwise multiplication with q (sizes should be identical)
         TProb<T>& operator*= (const TProb<T> & q) {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::multiplies<T>() );
             return *this;
         }
         
         /// Return product of *this with q (sizes should be identical)
         TProb<T> operator* (const TProb<T> & q) const {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             TProb<T> prod( *this );
             prod *= q;
             return prod;
@@ -252,18 +244,14 @@ template <typename T> class TProb {
 
         /// Pointwise addition with q (sizes should be identical)
         TProb<T>& operator+= (const TProb<T> & q) {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::plus<T>() );
             return *this;
         }
         
         /// Returns sum of *this and q (sizes should be identical)
         TProb<T> operator+ (const TProb<T> & q) const {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             TProb<T> sum( *this );
             sum += q;
             return sum;
@@ -271,18 +259,9 @@ template <typename T> class TProb {
         
         /// Pointwise subtraction of q (sizes should be identical)
         TProb<T>& operator-= (const TProb<T> & q) {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::minus<T>() );
-            return *this;
-        }
-        
-        /// Return *this minus q (sizes should be identical)
-        TProb<T> operator- (const TProb<T> & q) const {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             TProb<T> diff( *this );
             diff -= q;
             return diff;
@@ -290,9 +269,7 @@ template <typename T> class TProb {
 
         /// Pointwise division by q, where division by 0 yields 0 (sizes should be identical)
         TProb<T>& operator/= (const TProb<T> & q) {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             for( size_t i = 0; i < size(); i++ ) {
                 if( q[i] == 0.0 )
                     _p[i] = 0.0;
@@ -304,18 +281,14 @@ template <typename T> class TProb {
         
         /// Pointwise division by q, where division by 0 yields +Inf (sizes should be identical)
         TProb<T>& divide (const TProb<T> & q) {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::divides<T>() );
             return *this;
         }
         
         /// Returns quotient of *this with q (sizes should be identical)
         TProb<T> operator/ (const TProb<T> & q) const {
-#ifdef DAI_DEBUG
-            assert( size() == q.size() );
-#endif
+            DAI_DEBASSERT( size() == q.size() );
             TProb<T> quot( *this );
             quot /= q;
             return quot;
@@ -521,9 +494,7 @@ template <typename T> class TProb {
 /** \relates TProb
  */
 template<typename T> Real dist( const TProb<T> &p, const TProb<T> &q, typename TProb<T>::DistType dt ) {
-#ifdef DAI_DEBUG
-    assert( p.size() == q.size() );
-#endif
+    DAI_DEBASSERT( p.size() == q.size() );
     Real result = 0.0;
     switch( dt ) {
         case TProb<T>::DISTL1:
index 89c1dee..d697586 100644 (file)
 #define DAI_PV(x) do {std::cerr << #x "= " << (x) << std::endl;} while(0)
 /// "Debugging message": Prints a message (only if DAI_DEBUG is defined)
 #define DAI_DMSG(str) do {std::cerr << str << std::endl;} while(0)
+/// Assertion if DAI_DEBUG is defined
+#define DAI_DEBASSERT(x) do {assert(x);} while(0)
 #else
 #define DAI_PV(x) do {} while(0)
 #define DAI_DMSG(str) do {} while(0)
+#define DAI_DEBASSERT(X) do {} while(0)
 #endif
 
 /// Produces accessor and mutator methods according to the common pattern.