Merge pull request #1024 from borglab/release/4.2a2

CMakeLists.txt

@@ -11,7 +11,7 @@ endif()
 set (GTSAM_VERSION_MAJOR 4)
 set (GTSAM_VERSION_MINOR 2)
 set (GTSAM_VERSION_PATCH 0)
-set (GTSAM_PRERELEASE_VERSION "a1")
+set (GTSAM_PRERELEASE_VERSION "a2")
 math (EXPR GTSAM_VERSION_NUMERIC "10000 * ${GTSAM_VERSION_MAJOR} + 100 * ${GTSAM_VERSION_MINOR} + ${GTSAM_VERSION_PATCH}")
 
 if (${GTSAM_VERSION_PATCH} EQUAL 0)

examples/UGM_small.cpp

@@ -50,7 +50,8 @@ int main(int argc, char** argv) {
 
   // Print the UGM distribution
   cout << "\nUGM distribution:" << endl;
-  auto allPosbValues = cartesianProduct(Cathy & Heather & Mark & Allison);
+  auto allPosbValues =
+      DiscreteValues::CartesianProduct(Cathy & Heather & Mark & Allison);
   for (size_t i = 0; i < allPosbValues.size(); ++i) {
     DiscreteFactor::Values values = allPosbValues[i];
     double prodPot = graph(values);

gtsam/discrete/AlgebraicDecisionTree.h

@@ -179,5 +179,6 @@ namespace gtsam {
   };
 // AlgebraicDecisionTree
 
+template<typename T> struct traits<AlgebraicDecisionTree<T>> : public Testable<AlgebraicDecisionTree<T>> {};
 }
 // namespace gtsam

gtsam/discrete/Assignment.h

@@ -19,32 +19,30 @@
 #pragma once
 
 #include <iostream>
-#include <vector>
 #include <map>
-
+#include <utility>
+#include <vector>
 
 namespace gtsam {
 
-  /**
-   * An assignment from labels to value index (size_t).
-   * Assigns to each label a value. Implemented as a simple map.
-   * A discrete factor takes an Assignment and returns a value.
-   */
-  template<class L>
-  class Assignment: public std::map<L, size_t> {
-  public:
-    void print(const std::string& s = "Assignment: ") const {
-      std::cout << s << ": ";
-      for(const typename Assignment::value_type& keyValue: *this)
-        std::cout << "(" << keyValue.first << ", " << keyValue.second << ")";
-      std::cout << std::endl;
-    }
-
-    bool equals(const Assignment& other, double tol = 1e-9) const {
-      return (*this == other);
-    }
-  };  //Assignment
+/**
+ * An assignment from labels to value index (size_t).
+ * Assigns to each label a value. Implemented as a simple map.
+ * A discrete factor takes an Assignment and returns a value.
+ */
+template <class L>
+class Assignment : public std::map<L, size_t> {
+ public:
+  void print(const std::string& s = "Assignment: ") const {
+    std::cout << s << ": ";
+    for (const typename Assignment::value_type& keyValue : *this)
+      std::cout << "(" << keyValue.first << ", " << keyValue.second << ")";
+    std::cout << std::endl;
+  }
 
+  bool equals(const Assignment& other, double tol = 1e-9) const {
+    return (*this == other);
+  }
 
   /**
    * @brief Get Cartesian product consisting all possible configurations
@@ -58,29 +56,28 @@ namespace gtsam {
    * variables with each having cardinalities 4, we get 4096 possible
    * configurations!!
    */
-  template<typename L>
-  std::vector<Assignment<L> > cartesianProduct(
-      const std::vector<std::pair<L, size_t> >& keys) {
-    std::vector<Assignment<L> > allPossValues;
-    Assignment<L> values;
+  template <typename Derived = Assignment<L>>
+  static std::vector<Derived> CartesianProduct(
+      const std::vector<std::pair<L, size_t>>& keys) {
+    std::vector<Derived> allPossValues;
+    Derived values;
     typedef std::pair<L, size_t> DiscreteKey;
-    for(const DiscreteKey& key: keys)
-      values[key.first] = 0;  //Initialize from 0
+    for (const DiscreteKey& key : keys)
+      values[key.first] = 0;  // Initialize from 0
     while (1) {
       allPossValues.push_back(values);
       size_t j = 0;
       for (j = 0; j < keys.size(); j++) {
         L idx = keys[j].first;
         values[idx]++;
-        if (values[idx] < keys[j].second)
-          break;
-        //Wrap condition
+        if (values[idx] < keys[j].second) break;
+        // Wrap condition
         values[idx] = 0;
       }
-      if (j == keys.size())
-        break;
+      if (j == keys.size()) break;
     }
     return allPossValues;
   }
+};  // Assignment
 
-} // namespace gtsam
+}  // namespace gtsam

gtsam/discrete/DecisionTreeFactor.cpp

@@ -22,6 +22,7 @@
 #include <gtsam/base/FastSet.h>
 
 #include <boost/make_shared.hpp>
+#include <utility>
 
 using namespace std;
 
@@ -34,12 +35,13 @@ namespace gtsam {
   /* ******************************************************************************** */
   DecisionTreeFactor::DecisionTreeFactor(const DiscreteKeys& keys,
       const ADT& potentials) :
-      DiscreteFactor(keys.indices()), Potentials(keys, potentials) {
+      DiscreteFactor(keys.indices()), ADT(potentials),
+      cardinalities_(keys.cardinalities()) {
   }
 
   /* *************************************************************************/
   DecisionTreeFactor::DecisionTreeFactor(const DiscreteConditional& c) :
-      DiscreteFactor(c.keys()), Potentials(c) {
+      DiscreteFactor(c.keys()), AlgebraicDecisionTree<Key>(c), cardinalities_(c.cardinalities_) {
   }
 
   /* ************************************************************************* */
@@ -48,16 +50,24 @@ namespace gtsam {
       return false;
     }
     else {
-      const DecisionTreeFactor& f(static_cast<const DecisionTreeFactor&>(other));
-      return Potentials::equals(f, tol);
+      const auto& f(static_cast<const DecisionTreeFactor&>(other));
+      return ADT::equals(f, tol);
     }
   }
 
+  /* ************************************************************************* */
+  double DecisionTreeFactor::safe_div(const double &a, const double &b)  {
+    // The use for safe_div is when we divide the product factor by the sum
+    // factor. If the product or sum is zero, we accord zero probability to the
+    // event.
+    return (a == 0 || b == 0) ? 0 : (a / b);
+  }
+
   /* ************************************************************************* */
   void DecisionTreeFactor::print(const string& s,
       const KeyFormatter& formatter) const {
     cout << s;
-    Potentials::print("Potentials:",formatter);
+    ADT::print("Potentials:",formatter);
   }
 
   /* ************************************************************************* */
@@ -141,9 +151,9 @@ namespace gtsam {
     for (auto& key : keys()) {
       pairs.emplace_back(key, cardinalities_.at(key));
     }
-    // Reverse to make cartesianProduct output a more natural ordering.
+    // Reverse to make cartesian product output a more natural ordering.
     std::vector<std::pair<Key, size_t>> rpairs(pairs.rbegin(), pairs.rend());
-    const auto assignments = cartesianProduct(rpairs);
+    const auto assignments = DiscreteValues::CartesianProduct(rpairs);
 
     // Construct unordered_map with values
     std::vector<std::pair<DiscreteValues, double>> result;
@@ -162,28 +172,29 @@ namespace gtsam {
   void DecisionTreeFactor::dot(std::ostream& os,
                                const KeyFormatter& keyFormatter,
                                bool showZero) const {
-    Potentials::dot(os, keyFormatter, valueFormatter, showZero);
+    ADT::dot(os, keyFormatter, valueFormatter, showZero);
   }
 
   /** output to graphviz format, open a file */
   void DecisionTreeFactor::dot(const std::string& name,
                                const KeyFormatter& keyFormatter,
                                bool showZero) const {
-    Potentials::dot(name, keyFormatter, valueFormatter, showZero);
+    ADT::dot(name, keyFormatter, valueFormatter, showZero);
   }
 
   /** output to graphviz format string */
   std::string DecisionTreeFactor::dot(const KeyFormatter& keyFormatter,
                                       bool showZero) const {
-    return Potentials::dot(keyFormatter, valueFormatter, showZero);
+    return ADT::dot(keyFormatter, valueFormatter, showZero);
   }
 
+    // Print out header.
   /* ************************************************************************* */
   string DecisionTreeFactor::markdown(const KeyFormatter& keyFormatter,
                                       const Names& names) const {
     stringstream ss;
 
-    // Print out header and construct argument for `cartesianProduct`.
+    // Print out header.
     ss << "|";
     for (auto& key : keys()) {
       ss << keyFormatter(key) << "|";
@@ -202,12 +213,58 @@ namespace gtsam {
       auto assignment = kv.first;
       for (auto& key : keys()) {
         size_t index = assignment.at(key);
-        ss << Translate(names, key, index) << "|";
+        ss << DiscreteValues::Translate(names, key, index) << "|";
       }
       ss << kv.second << "|\n";
     }
     return ss.str();
   }
 
+  /* ************************************************************************ */
+  string DecisionTreeFactor::html(const KeyFormatter& keyFormatter,
+                                  const Names& names) const {
+    stringstream ss;
+
+    // Print out preamble.
+    ss << "<div>\n<table class='DecisionTreeFactor'>\n  <thead>\n";
+
+    // Print out header row.
+    ss << "    <tr>";
+    for (auto& key : keys()) {
+      ss << "<th>" << keyFormatter(key) << "</th>";
+    }
+    ss << "<th>value</th></tr>\n";
+
+    // Finish header and start body.
+    ss << "  </thead>\n  <tbody>\n";
+
+    // Print out all rows.
+    auto rows = enumerate();
+    for (const auto& kv : rows) {
+      ss << "    <tr>";
+      auto assignment = kv.first;
+      for (auto& key : keys()) {
+        size_t index = assignment.at(key);
+        ss << "<th>" << DiscreteValues::Translate(names, key, index) << "</th>";
+      }
+      ss << "<td>" << kv.second << "</td>";  // value
+      ss << "</tr>\n";
+    }
+    ss << "  </tbody>\n</table>\n</div>";
+    return ss.str();
+  }
+
+  /* ************************************************************************* */
+  DecisionTreeFactor::DecisionTreeFactor(const DiscreteKeys &keys, const vector<double> &table) :
+          DiscreteFactor(keys.indices()), AlgebraicDecisionTree<Key>(keys, table),
+          cardinalities_(keys.cardinalities()) {
+  }
+
+  /* ************************************************************************* */
+  DecisionTreeFactor::DecisionTreeFactor(const DiscreteKeys &keys, const string &table) :
+          DiscreteFactor(keys.indices()), AlgebraicDecisionTree<Key>(keys, table),
+          cardinalities_(keys.cardinalities()) {
+  }
+
   /* ************************************************************************* */
 } // namespace gtsam

gtsam/discrete/DecisionTreeFactor.h

@@ -19,7 +19,8 @@
 #pragma once
 
 #include <gtsam/discrete/DiscreteFactor.h>
-#include <gtsam/discrete/Potentials.h>
+#include <gtsam/discrete/DiscreteKey.h>
+#include <gtsam/discrete/AlgebraicDecisionTree.h>
 #include <gtsam/inference/Ordering.h>
 
 #include <boost/shared_ptr.hpp>
@@ -35,14 +36,18 @@ namespace gtsam {
   /**
    * A discrete probabilistic factor
    */
-  class GTSAM_EXPORT DecisionTreeFactor: public DiscreteFactor, public Potentials {
+  class GTSAM_EXPORT DecisionTreeFactor: public DiscreteFactor, public AlgebraicDecisionTree<Key> {
 
   public:
 
     // typedefs needed to play nice with gtsam
     typedef DecisionTreeFactor This;
     typedef DiscreteFactor Base; ///< Typedef to base class
     typedef boost::shared_ptr<DecisionTreeFactor> shared_ptr;
+    typedef AlgebraicDecisionTree<Key> ADT;
+
+  protected:
+    std::map<Key,size_t> cardinalities_;
 
   public:
 
@@ -55,11 +60,11 @@ namespace gtsam {
     /** Constructor from Indices, Ordering, and AlgebraicDecisionDiagram */
     DecisionTreeFactor(const DiscreteKeys& keys, const ADT& potentials);
 
-    /** Constructor from Indices and (string or doubles) */
-    template<class SOURCE>
-    DecisionTreeFactor(const DiscreteKeys& keys, SOURCE table) :
-        DiscreteFactor(keys.indices()), Potentials(keys, table) {
-    }
+    /** Constructor from doubles */
+    DecisionTreeFactor(const DiscreteKeys& keys, const std::vector<double>& table);
+
+    /** Constructor from string */
+    DecisionTreeFactor(const DiscreteKeys& keys, const std::string& table);
 
     /// Single-key specialization
     template <class SOURCE>
@@ -71,7 +76,7 @@ namespace gtsam {
         : DecisionTreeFactor(DiscreteKeys{key}, row) {}
 
     /** Construct from a DiscreteConditional type */
-    DecisionTreeFactor(const DiscreteConditional& c);
+    explicit DecisionTreeFactor(const DiscreteConditional& c);
 
     /// @}
     /// @name Testable
@@ -90,14 +95,18 @@ namespace gtsam {
 
     /// Value is just look up in AlgebraicDecisonTree
     double operator()(const DiscreteValues& values) const override {
-      return Potentials::operator()(values);
+      return ADT::operator()(values);
     }
 
     /// multiply two factors
     DecisionTreeFactor operator*(const DecisionTreeFactor& f) const override {
       return apply(f, ADT::Ring::mul);
     }
 
+    static double safe_div(const double& a, const double& b);
+
+    size_t cardinality(Key j) const { return cardinalities_.at(j);}
+
     /// divide by factor f (safely)
     DecisionTreeFactor operator/(const DecisionTreeFactor& f) const {
       return apply(f, safe_div);
@@ -202,6 +211,16 @@ namespace gtsam {
     std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                          const Names& names = {}) const override;
 
+    /**
+     * @brief Render as html table
+     *
+     * @param keyFormatter GTSAM-style Key formatter.
+     * @param names optional, category names corresponding to choices.
+     * @return std::string a html string.
+     */
+    std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
+                     const Names& names = {}) const override;
+
     /// @}
 
 };