Discrete Elimination Refactor

gtsam/discrete/DecisionTreeFactor.cpp

@@ -83,15 +83,26 @@ namespace gtsam {
   }
 
   /* ************************************************************************ */
-  DecisionTreeFactor DecisionTreeFactor::apply(ADT::Unary op) const {
+  DiscreteFactor::shared_ptr DecisionTreeFactor::operator*(
+      const DiscreteFactor::shared_ptr& f) const {
+    if (auto derived = std::dynamic_pointer_cast<DecisionTreeFactor>(f)) {
+      return std::make_shared<DecisionTreeFactor>(this->operator*(*derived));
+    } else {
+      throw std::runtime_error(
+          "Cannot convert DiscreteFactor to DecisionTreeFactor");
+    }
+  }
+
+  /* ************************************************************************ */
+  DecisionTreeFactor DecisionTreeFactor::apply(Unary op) const {
     // apply operand
     ADT result = ADT::apply(op);
     // Make a new factor
     return DecisionTreeFactor(discreteKeys(), result);
   }
 
   /* ************************************************************************ */
-  DecisionTreeFactor DecisionTreeFactor::apply(ADT::UnaryAssignment op) const {
+  DecisionTreeFactor DecisionTreeFactor::apply(UnaryAssignment op) const {
     // apply operand
     ADT result = ADT::apply(op);
     // Make a new factor
@@ -100,7 +111,7 @@ namespace gtsam {
 
   /* ************************************************************************ */
   DecisionTreeFactor DecisionTreeFactor::apply(const DecisionTreeFactor& f,
-                                              ADT::Binary op) const {
+                                               Binary op) const {
     map<Key, size_t> cs;  // new cardinalities
     // make unique key-cardinality map
     for (Key j : keys()) cs[j] = cardinality(j);
@@ -118,8 +129,8 @@ namespace gtsam {
   }
 
   /* ************************************************************************ */
-  DecisionTreeFactor::shared_ptr DecisionTreeFactor::combine(
-      size_t nrFrontals, ADT::Binary op) const {
+  DecisionTreeFactor::shared_ptr DecisionTreeFactor::combine(size_t nrFrontals,
+                                                             Binary op) const {
     if (nrFrontals > size()) {
       throw invalid_argument(
           "DecisionTreeFactor::combine: invalid number of frontal "
@@ -146,7 +157,7 @@ namespace gtsam {
 
   /* ************************************************************************ */
   DecisionTreeFactor::shared_ptr DecisionTreeFactor::combine(
-      const Ordering& frontalKeys, ADT::Binary op) const {
+      const Ordering& frontalKeys, Binary op) const {
     if (frontalKeys.size() > size()) {
       throw invalid_argument(
           "DecisionTreeFactor::combine: invalid number of frontal "

gtsam/discrete/DecisionTreeFactor.h

@@ -51,6 +51,11 @@ namespace gtsam {
     typedef std::shared_ptr<DecisionTreeFactor> shared_ptr;
     typedef AlgebraicDecisionTree<Key> ADT;
 
+    // Needed since we have definitions in both DiscreteFactor and DecisionTree
+    using Base::Binary;
+    using Base::Unary;
+    using Base::UnaryAssignment;
+
     /// @name Standard Constructors
     /// @{
 
@@ -130,52 +135,61 @@ namespace gtsam {
     /// @name Standard Interface
     /// @{
 
-    /// Calculate probability for given values `x`, 
+    /// Calculate probability for given values, 
     /// is just look up in AlgebraicDecisionTree.
-    double evaluate(const Assignment<Key>& values) const  {
-      return ADT::operator()(values);
-    }
-
-    /// Evaluate probability distribution, sugar.
-    double operator()(const DiscreteValues& values) const override {
+    double operator()(const Assignment<Key>& values) const override {
       return ADT::operator()(values);
     }
 
     /// Calculate error for DiscreteValues `x`, is -log(probability).
     double error(const DiscreteValues& values) const override;
 
     /// multiply two factors
-    DecisionTreeFactor operator*(const DecisionTreeFactor& f) const override {
+    DecisionTreeFactor operator*(const DecisionTreeFactor& f) const {
       return apply(f, Ring::mul);
     }
 
+    DiscreteFactor::shared_ptr operator*(
+        const DiscreteFactor::shared_ptr& f) const override;
+
     static double safe_div(const double& a, const double& b);
 
     /// divide by factor f (safely)
     DecisionTreeFactor operator/(const DecisionTreeFactor& f) const {
       return apply(f, safe_div);
     }
 
+    /// divide by factor f (pointer version)
+    DiscreteFactor::shared_ptr operator/(
+        const DiscreteFactor::shared_ptr& f) const override {
+      if (auto derived = std::dynamic_pointer_cast<DecisionTreeFactor>(f)) {
+        return std::make_shared<DecisionTreeFactor>(apply(*derived, safe_div));
+      } else {
+        throw std::runtime_error(
+            "Cannot convert DiscreteFactor to Table Factor");
+      }
+    }
+
     /// Convert into a decision tree
     DecisionTreeFactor toDecisionTreeFactor() const override { return *this; }
 
     /// Create new factor by summing all values with the same separator values
-    shared_ptr sum(size_t nrFrontals) const {
+    DiscreteFactor::shared_ptr sum(size_t nrFrontals) const override {
       return combine(nrFrontals, Ring::add);
     }
 
     /// Create new factor by summing all values with the same separator values
-    shared_ptr sum(const Ordering& keys) const {
+    DiscreteFactor::shared_ptr sum(const Ordering& keys) const override {
       return combine(keys, Ring::add);
     }
 
     /// Create new factor by maximizing over all values with the same separator.
-    shared_ptr max(size_t nrFrontals) const {
+    DiscreteFactor::shared_ptr max(size_t nrFrontals) const override {
       return combine(nrFrontals, Ring::max);
     }
 
     /// Create new factor by maximizing over all values with the same separator.
-    shared_ptr max(const Ordering& keys) const {
+    DiscreteFactor::shared_ptr max(const Ordering& keys) const override {
       return combine(keys, Ring::max);
     }
 
@@ -187,37 +201,37 @@ namespace gtsam {
      * Apply unary operator (*this) "op" f
      * @param op a unary operator that operates on AlgebraicDecisionTree
      */
-    DecisionTreeFactor apply(ADT::Unary op) const;
+    DecisionTreeFactor apply(Unary op) const;
 
     /**
      * Apply unary operator (*this) "op" f
      * @param op a unary operator that operates on AlgebraicDecisionTree. Takes
      * both the assignment and the value.
      */
-    DecisionTreeFactor apply(ADT::UnaryAssignment op) const;
+    DecisionTreeFactor apply(UnaryAssignment op) const;
 
     /**
      * Apply binary operator (*this) "op" f
      * @param f the second argument for op
      * @param op a binary operator that operates on AlgebraicDecisionTree
      */
-    DecisionTreeFactor apply(const DecisionTreeFactor& f, ADT::Binary op) const;
+    DecisionTreeFactor apply(const DecisionTreeFactor& f, Binary op) const;
 
     /**
      * Combine frontal variables using binary operator "op"
      * @param nrFrontals nr. of frontal to combine variables in this factor
      * @param op a binary operator that operates on AlgebraicDecisionTree
      * @return shared pointer to newly created DecisionTreeFactor
      */
-    shared_ptr combine(size_t nrFrontals, ADT::Binary op) const;
+    shared_ptr combine(size_t nrFrontals, Binary op) const;
 
     /**
      * Combine frontal variables in an Ordering using binary operator "op"
      * @param nrFrontals nr. of frontal to combine variables in this factor
      * @param op a binary operator that operates on AlgebraicDecisionTree
      * @return shared pointer to newly created DecisionTreeFactor
      */
-    shared_ptr combine(const Ordering& keys, ADT::Binary op) const;
+    shared_ptr combine(const Ordering& keys, Binary op) const;
 
     /// Enumerate all values into a map from values to double.
     std::vector<std::pair<DiscreteValues, double>> enumerate() const;
@@ -256,6 +270,12 @@ namespace gtsam {
      */
     DecisionTreeFactor prune(size_t maxNrAssignments) const;
 
+    /**
+     * Get the number of non-zero values contained in this factor.
+     * It could be much smaller than `prod_{key}(cardinality(key))`.
+     */
+    uint64_t nrValues() const override { return nrLeaves(); }
+
     /// @}
     /// @name Wrapper support
     /// @{

gtsam/discrete/DiscreteConditional.cpp

@@ -38,13 +38,14 @@ using std::vector;
 namespace gtsam {
 
 // Instantiate base class
-template class GTSAM_EXPORT
-    Conditional<DecisionTreeFactor, DiscreteConditional>;
+template class GTSAM_EXPORT Conditional<DecisionTreeFactor, DiscreteConditional>;
 
 /* ************************************************************************** */
 DiscreteConditional::DiscreteConditional(const size_t nrFrontals,
                                          const DecisionTreeFactor& f)
-    : BaseFactor(f / (*f.sum(nrFrontals))), BaseConditional(nrFrontals) {}
+    : BaseFactor(f / (*std::dynamic_pointer_cast<DecisionTreeFactor>(
+                         f.sum(nrFrontals)))),
+      BaseConditional(nrFrontals) {}
 
 /* ************************************************************************** */
 DiscreteConditional::DiscreteConditional(size_t nrFrontals,
@@ -53,15 +54,17 @@ DiscreteConditional::DiscreteConditional(size_t nrFrontals,
     : BaseFactor(keys, potentials), BaseConditional(nrFrontals) {}
 
 /* ************************************************************************** */
-DiscreteConditional::DiscreteConditional(const DecisionTreeFactor& joint,
-                                         const DecisionTreeFactor& marginal)
-    : BaseFactor(joint / marginal),
-      BaseConditional(joint.size() - marginal.size()) {}
+DiscreteConditional::DiscreteConditional(
+    const DiscreteFactor::shared_ptr& joint,
+    const DiscreteFactor::shared_ptr& marginal)
+    : BaseFactor(*std::dynamic_pointer_cast<DecisionTreeFactor>(
+          joint->operator/(marginal))),
+      BaseConditional(joint->size() - marginal->size()) {}
 
 /* ************************************************************************** */
-DiscreteConditional::DiscreteConditional(const DecisionTreeFactor& joint,
-                                         const DecisionTreeFactor& marginal,
-                                         const Ordering& orderedKeys)
+DiscreteConditional::DiscreteConditional(
+    const DiscreteFactor::shared_ptr& joint,
+    const DiscreteFactor::shared_ptr& marginal, const Ordering& orderedKeys)
     : DiscreteConditional(joint, marginal) {
   keys_.clear();
   keys_.insert(keys_.end(), orderedKeys.begin(), orderedKeys.end());
@@ -199,7 +202,7 @@ DiscreteConditional::shared_ptr DiscreteConditional::choose(
 }
 
 /* ************************************************************************** */
-DecisionTreeFactor::shared_ptr DiscreteConditional::likelihood(
+DiscreteFactor::shared_ptr DiscreteConditional::likelihood(
     const DiscreteValues& frontalValues) const {
   // Get the big decision tree with all the levels, and then go down the
   // branches based on the value of the frontal variables.
@@ -224,7 +227,7 @@ DecisionTreeFactor::shared_ptr DiscreteConditional::likelihood(
 }
 
 /* ****************************************************************************/
-DecisionTreeFactor::shared_ptr DiscreteConditional::likelihood(
+DiscreteFactor::shared_ptr DiscreteConditional::likelihood(
     size_t frontal) const {
   if (nrFrontals() != 1)
     throw std::invalid_argument(
@@ -474,7 +477,7 @@ string DiscreteConditional::html(const KeyFormatter& keyFormatter,
 
 /* ************************************************************************* */
 double DiscreteConditional::evaluate(const HybridValues& x) const {
-  return this->evaluate(x.discrete());
+  return this->operator()(x.discrete());
 }
 
 /* ************************************************************************* */

gtsam/discrete/DiscreteConditional.h

@@ -110,16 +110,16 @@ class GTSAM_EXPORT DiscreteConditional
    * @brief construct P(X|Y) = f(X,Y)/f(Y) from f(X,Y) and f(Y)
    * Assumes but *does not check* that f(Y)=sum_X f(X,Y).
    */
-  DiscreteConditional(const DecisionTreeFactor& joint,
-                      const DecisionTreeFactor& marginal);
+  DiscreteConditional(const DiscreteFactor::shared_ptr& joint,
+                      const DiscreteFactor::shared_ptr& marginal);
 
   /**
    * @brief construct P(X|Y) = f(X,Y)/f(Y) from f(X,Y) and f(Y)
    * Assumes but *does not check* that f(Y)=sum_X f(X,Y).
    * Makes sure the keys are ordered as given. Does not check orderedKeys.
    */
-  DiscreteConditional(const DecisionTreeFactor& joint,
-                      const DecisionTreeFactor& marginal,
+  DiscreteConditional(const DiscreteFactor::shared_ptr& joint,
+                      const DiscreteFactor::shared_ptr& marginal,
                       const Ordering& orderedKeys);
 
   /**
@@ -168,13 +168,8 @@ class GTSAM_EXPORT DiscreteConditional
     static_cast<const BaseConditional*>(this)->print(s, formatter);
   }
 
-  /// Evaluate, just look up in AlgebraicDecisionTree
-  double evaluate(const DiscreteValues& values) const {
-    return ADT::operator()(values);
-  }
-
-  using DecisionTreeFactor::error;       ///< DiscreteValues version
-  using DecisionTreeFactor::operator();  ///< DiscreteValues version
+  using BaseFactor::error;       ///< DiscreteValues version
+  using BaseFactor::operator();  ///< DiscreteValues version
 
   /**
    * @brief restrict to given *parent* values.
@@ -192,11 +187,11 @@ class GTSAM_EXPORT DiscreteConditional
   shared_ptr choose(const DiscreteValues& given) const;
 
   /** Convert to a likelihood factor by providing value before bar. */
-  DecisionTreeFactor::shared_ptr likelihood(
+  DiscreteFactor::shared_ptr likelihood(
       const DiscreteValues& frontalValues) const;
 
   /** Single variable version of likelihood. */
-  DecisionTreeFactor::shared_ptr likelihood(size_t frontal) const;
+  DiscreteFactor::shared_ptr likelihood(size_t frontal) const;
 
   /**
    * sample

gtsam/discrete/DiscreteDistribution.h

@@ -40,7 +40,7 @@ class GTSAM_EXPORT DiscreteDistribution : public DiscreteConditional {
   /// Default constructor needed for serialization.
   DiscreteDistribution() {}
 
-  /// Constructor from factor.
+  /// Constructor from DecisionTreeFactor.
   explicit DiscreteDistribution(const DecisionTreeFactor& f)
       : Base(f.size(), f) {}
 
@@ -86,8 +86,7 @@ class GTSAM_EXPORT DiscreteDistribution : public DiscreteConditional {
   double operator()(size_t value) const;
 
   /// We also want to keep the Base version, taking DiscreteValues:
-  // TODO(dellaert): does not play well with wrapper!
-  // using Base::operator();
+  using Base::operator();
 
   /// Return entire probability mass function.
   std::vector<double> pmf() const;