- [Frederik Eaton]: Misc smaller changes
authorJoris Mooij <joris.mooij@tuebingen.mpg.de>
Mon, 25 May 2009 06:48:22 +0000 (08:48 +0200)
committerJoris Mooij <joris.mooij@tuebingen.mpg.de>
Mon, 25 May 2009 06:48:22 +0000 (08:48 +0200)
  * include/dai/daialg.h: (InfAlg)
      Add beliefV, beliefF; create sensible default for 'virtual create()'
  * include/dai/properties.h: (PropertySet)
      Add default constructor
      Allow construction from string
      Add method allKeys() to produce list of keys
      In getStringAs(), check for typeid(ValueType) before typeid(std::string)
        (fixes strange bug for empty string property)
  * include/dai/util.h:
      Added comments for macros
      Added function to concatenate two vectors

include/dai/daialg.h
include/dai/properties.h
include/dai/util.h

index 91d36af..0257311 100644 (file)
@@ -55,7 +55,7 @@ class InfAlg {
         virtual InfAlg* clone() const = 0;
 
         /// Returns a pointer to a newly constructed object *this (i.e., virtual default constructor)
-        virtual InfAlg* create() const = 0;
+        virtual InfAlg* create() const { DAI_THROW(NOT_IMPLEMENTED); }
         
         /// Identifies itself for logging purposes
         virtual std::string identify() const = 0;
@@ -66,6 +66,18 @@ class InfAlg {
         /// Returns the "belief" (i.e., approximate marginal probability distribution) of a set of variables
         virtual Factor belief( const VarSet &n ) const = 0;
 
+        /// Returns marginal for a variable.
+        /** Sometimes preferred to belief() for performance reasons.
+          * Faster implementations exist in e.g. BP.
+          */
+        virtual Factor beliefV( size_t i ) const { return belief( fg().var(i) ); }
+
+        /// Returns marginal for a factor.
+        /** Sometimes preferred to belief() for performance reasons.
+          * Faster implementations exist in e.g. BP.
+          */
+        virtual Factor beliefF( size_t I ) const { return belief( fg().factor(I).vars() ); }
+
         /// Returns all "beliefs" (i.e., approximate marginal probability distribution) calculated by the algorithm
         virtual std::vector<Factor> beliefs() const = 0;
 
index 196fcd4..6ad5f2a 100644 (file)
@@ -59,6 +59,16 @@ std::ostream& operator<< (std::ostream & os, const Property & p);
 /// Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue)
 class PropertySet : private std::map<PropertyKey, PropertyValue> {
     public:
+        /// Default constructor
+        PropertySet() {}
+
+        /// Construct PropertySet from a string
+        PropertySet( const std::string &s ) {
+            std::stringstream ss;
+            ss << s;
+            ss >> *this;
+        }
+
         /// Gets a property
         const PropertyValue & Get(const PropertyKey &key) const { 
             PropertySet::const_iterator x = find(key); 
@@ -114,14 +124,14 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
         template<typename ValueType>
         ValueType getStringAs(const PropertyKey &key) const { 
             PropertyValue val = Get(key);
-            if( val.type() == typeid(std::string) ) {
+            if( val.type() == typeid(ValueType) ) {
+                return boost::any_cast<ValueType>(val);
+            } else if( val.type() == typeid(std::string) ) {
                 std::stringstream ss;
                 ss << GetAs<std::string>(key);
                 ValueType result;
                 ss >> result;
                 return result;
-            } else if( val.type() == typeid(ValueType) ) {
-                return boost::any_cast<ValueType>(val);
             } else {
                 DAI_THROW(IMPOSSIBLE_TYPECAST);
                 return ValueType();
@@ -146,6 +156,15 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
         /// Check if a property with the given key exists
         bool hasKey(const PropertyKey &key) const { PropertySet::const_iterator x = find(key); return (x != this->end()); }
 
+        /// Returns a set containing all keys
+        std::set<PropertyKey> allKeys() const {
+            std::set<PropertyKey> res;
+            const_iterator i;
+            for( i = begin(); i != end(); i++ )
+                res.insert( i->first );
+            return res;
+        }
+
         // Friends
         friend std::ostream& operator<< (std::ostream & os, const PropertySet & ps);
         friend std::istream& operator>> (std::istream& is, PropertySet & ps);
index 45900a7..a45d274 100644 (file)
 #define foreach BOOST_FOREACH
 
 #ifdef DAI_DEBUG
-#define DAI_PV(x) do {std::cerr << #x "= " << x << std::endl;} while(0)
+/// \brief "Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined)
+/**
+ *  Useful debugging macro to see what your code is doing. 
+ *  Example: \code DAI_PV(3+4) \endcode
+ */ Output: \code 3+4= 7 \endcode
+#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)
 #else
 #define DAI_PV(x) do {} while(0)
 #define DAI_DMSG(str) do {} while(0)
 #endif
 
+/// Produces accessor and mutator methods according to the common pattern.
+/** Example:
+ *  \code DAI_ACCMUT(size_t& maxIter(), { return props.maxiter; }); \endcode
+ *  \todo At the moment, only the mutator appears in doxygen documentation.
 #define DAI_ACCMUT(x,y)                     \
       x y;                                  \
       const x const y;
 
+/// Macro to give error message \a stmt if props.verbose>=\a n
 #define DAI_IFVERB(n, stmt) if(props.verbose>=n) { cerr << stmt; }
 
 
@@ -157,6 +168,17 @@ std::ostream& operator << (std::ostream& os, const std::pair<T1,T2> & x) {
     return os;
 }
 
+/// Concatenate two vectors
+template<class T>
+std::vector<T> concata (const std::vector<T>& u, const std::vector<T>& v ) {
+    std::vector<T> w;
+    w.reserve( u.size() + v.size() );
+    for( size_t i = 0; i < u.size(); i++ )
+        w.push_back( u[i] );
+    for( size_t i = 0; i < v.size(); i++ )
+        w.push_back( v[i] );
+    return w;
+}
 
 /// Used to keep track of the progress made by iterative algorithms
 class Diffs : public std::vector<double> {