DecisionTree refactor

gtsam/discrete/AlgebraicDecisionTree.h

@@ -28,11 +28,22 @@ namespace gtsam {
    * TODO: consider eliminating this class altogether?
    */
   template<typename L>
-  class AlgebraicDecisionTree: public DecisionTree<L, double> {
+  class GTSAM_EXPORT AlgebraicDecisionTree: public DecisionTree<L, double> {
+    /**
+     * @brief Default method used by `labelFormatter` or `valueFormatter` when printing.
+     * 
+     * @param x The value passed to format.
+     * @return std::string 
+     */
+    static std::string DefaultFormatter(const L& x) {
+      std::stringstream ss;
+      ss << x;
+      return ss.str();
+    }
 
-  public:
+   public:
 
-    typedef DecisionTree<L, double> Super;
+    using Base = DecisionTree<L, double>;
 
     /** The Real ring with addition and multiplication */
     struct Ring {
@@ -60,57 +71,66 @@ namespace gtsam {
     };
 
     AlgebraicDecisionTree() :
-        Super(1.0) {
+        Base(1.0) {
     }
 
-    AlgebraicDecisionTree(const Super& add) :
-        Super(add) {
+    AlgebraicDecisionTree(const Base& add) :
+        Base(add) {
     }
 
     /** Create a new leaf function splitting on a variable */
     AlgebraicDecisionTree(const L& label, double y1, double y2) :
-        Super(label, y1, y2) {
+        Base(label, y1, y2) {
     }
 
     /** Create a new leaf function splitting on a variable */
-    AlgebraicDecisionTree(const typename Super::LabelC& labelC, double y1, double y2) :
-        Super(labelC, y1, y2) {
+    AlgebraicDecisionTree(const typename Base::LabelC& labelC, double y1, double y2) :
+        Base(labelC, y1, y2) {
     }
 
     /** Create from keys and vector table */
     AlgebraicDecisionTree //
-    (const std::vector<typename Super::LabelC>& labelCs, const std::vector<double>& ys) {
-      this->root_ = Super::create(labelCs.begin(), labelCs.end(), ys.begin(),
+    (const std::vector<typename Base::LabelC>& labelCs, const std::vector<double>& ys) {
+      this->root_ = Base::create(labelCs.begin(), labelCs.end(), ys.begin(),
           ys.end());
     }
 
     /** Create from keys and string table */
     AlgebraicDecisionTree //
-    (const std::vector<typename Super::LabelC>& labelCs, const std::string& table) {
+    (const std::vector<typename Base::LabelC>& labelCs, const std::string& table) {
       // Convert string to doubles
       std::vector<double> ys;
       std::istringstream iss(table);
       std::copy(std::istream_iterator<double>(iss),
           std::istream_iterator<double>(), std::back_inserter(ys));
 
       // now call recursive Create
-      this->root_ = Super::create(labelCs.begin(), labelCs.end(), ys.begin(),
+      this->root_ = Base::create(labelCs.begin(), labelCs.end(), ys.begin(),
           ys.end());
     }
 
     /** Create a new function splitting on a variable */
     template<typename Iterator>
     AlgebraicDecisionTree(Iterator begin, Iterator end, const L& label) :
-        Super(nullptr) {
+        Base(nullptr) {
       this->root_ = compose(begin, end, label);
     }
 
-    /** Convert */
+    /**
+     * Convert labels from type M to type L.
+     *
+     * @param other: The AlgebraicDecisionTree with label type M to convert.
+     * @param map: Map from label type M to label type L.
+     */
     template<typename M>
     AlgebraicDecisionTree(const AlgebraicDecisionTree<M>& other,
-        const std::map<M, L>& map) {
-      this->root_ = this->template convert<M, double>(other.root_, map,
-          Ring::id);
+                          const std::map<M, L>& map) {
+      // Functor for label conversion so we can use `convertFrom`.
+      std::function<L(const M&)> L_of_M = [&map](const M& label) -> L {
+        return map.at(label);
+      };
+      std::function<double(const double&)> op = Ring::id;
+      this->root_ = this->template convertFrom(other.root_, L_of_M, op);
     }
 
     /** sum */
@@ -134,10 +154,28 @@ namespace gtsam {
     }
 
     /** sum out variable */
-    AlgebraicDecisionTree sum(const typename Super::LabelC& labelC) const {
+    AlgebraicDecisionTree sum(const typename Base::LabelC& labelC) const {
       return this->combine(labelC, &Ring::add);
     }
 
+    /// print method customized to value type `double`.
+    void print(const std::string& s,
+               const typename Base::LabelFormatter& labelFormatter =
+                   &DefaultFormatter) const {
+      auto valueFormatter = [](const double& v) {
+        return (boost::format("%4.2g") % v).str();
+      };
+      Base::print(s, labelFormatter, valueFormatter);
+    }
+
+    /// Equality method customized to value type `double`.
+    bool equals(const AlgebraicDecisionTree& other, double tol = 1e-9) const {
+      // lambda for comparison of two doubles upto some tolerance.
+      auto compare = [tol](double a, double b) {
+        return std::abs(a - b) < tol;
+      };
+      return Base::equals(other, compare);
+    }
   };
 // AlgebraicDecisionTree