kill operator* method

gtsam/discrete/TableDistribution.cpp

@@ -71,44 +71,6 @@ TableDistribution::TableDistribution(const Signature& signature)
     : BaseConditional(1, DecisionTreeFactor(DiscreteKeys{{1, 1}}, ADT(1))),
       table_(TableFactor(signature.discreteKeys(), signature.cpt())) {}
 
-/* ************************************************************************** */
-TableDistribution TableDistribution::operator*(
-    const TableDistribution& other) const {
-  // Take union of frontal keys
-  std::set<Key> newFrontals;
-  for (auto&& key : this->frontals()) newFrontals.insert(key);
-  for (auto&& key : other.frontals()) newFrontals.insert(key);
-
-  // Check if frontals overlapped
-  if (nrFrontals() + other.nrFrontals() > newFrontals.size())
-    throw std::invalid_argument(
-        "TableDistribution::operator* called with overlapping frontal "
-        "keys.");
-
-  // Now, add cardinalities.
-  DiscreteKeys discreteKeys;
-  for (auto&& key : frontals())
-    discreteKeys.emplace_back(key, cardinality(key));
-  for (auto&& key : other.frontals())
-    discreteKeys.emplace_back(key, other.cardinality(key));
-
-  // Sort
-  std::sort(discreteKeys.begin(), discreteKeys.end());
-
-  // Add parents to set, to make them unique
-  std::set<DiscreteKey> parents;
-  for (auto&& key : this->parents())
-    if (!newFrontals.count(key)) parents.emplace(key, cardinality(key));
-  for (auto&& key : other.parents())
-    if (!newFrontals.count(key)) parents.emplace(key, other.cardinality(key));
-
-  // Finally, add parents to keys, in order
-  for (auto&& dk : parents) discreteKeys.push_back(dk);
-
-  TableFactor product = this->table_ * other.table();
-  return TableDistribution(newFrontals.size(), product);
-}
-
 /* ************************************************************************** */
 void TableDistribution::print(const string& s,
                                      const KeyFormatter& formatter) const {

gtsam/discrete/TableDistribution.h

@@ -124,30 +124,13 @@ class GTSAM_EXPORT TableDistribution : public DiscreteConditional {
   TableDistribution(const TableFactor& joint, const TableFactor& marginal,
                     const Ordering& orderedKeys);
 
-  /**
-   * @brief Combine two conditionals, yielding a new conditional with the union
-   * of the frontal keys, ordered by gtsam::Key.
-   *
-   * The two conditionals must make a valid Bayes net fragment, i.e.,
-   * the frontal variables cannot overlap, and must be acyclic:
-   * Example of correct use:
-   *   P(A,B) = P(A|B) * P(B)
-   *   P(A,B|C) = P(A|B) * P(B|C)
-   *   P(A,B,C) = P(A,B|C) * P(C)
-   * Example of incorrect use:
-   *   P(A|B) * P(A|C) = ?
-   *   P(A|B) * P(B|A) = ?
-   * We check for overlapping frontals, but do *not* check for cyclic.
-   */
-  TableDistribution operator*(const TableDistribution& other) const;
-
   /// @}
   /// @name Testable
   /// @{
 
   /// GTSAM-style print
   void print(
-      const std::string& s = "Discrete Conditional: ",
+      const std::string& s = "Table Distribution: ",
       const KeyFormatter& formatter = DefaultKeyFormatter) const override;
 
   /// GTSAM-style equals