TableFactor.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 
 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
 
 * See LICENSE for the license information
 
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <gtsam/discrete/DecisionTreeFactor.h>
#include <gtsam/discrete/DiscreteFactor.h>
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam/discrete/Ring.h>
#include <gtsam/inference/Ordering.h>
 
#include <Eigen/Sparse>
#include <algorithm>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
#if GTSAM_ENABLE_BOOST_SERIALIZATION
#include <gtsam/base/MatrixSerialization.h>
 
#include <boost/serialization/nvp.hpp>
#endif
 
namespace gtsam {
 
class DiscreteConditional;
class HybridValues;
 
class GTSAM_EXPORT TableFactor : public DiscreteFactor {
 protected:
  Eigen::SparseVector<double> sparse_table_;
 
 private:
  std::map<Key, size_t> denominators_;
  DiscreteKeys sorted_dkeys_;
 
  size_t keyValueForIndex(Key target_key, uint64_t index) const;
 
  DiscreteKey discreteKey(size_t i) const {
    return DiscreteKey(keys_[i], cardinalities_.at(keys_[i]));
  }
 
 public:
  static Eigen::SparseVector<double> Convert(const DiscreteKeys& keys,
                                             const std::vector<double>& table);
 
  static Eigen::SparseVector<double> Convert(const DiscreteKeys& keys,
                                             const std::string& table);
 
  // typedefs needed to play nice with gtsam
  typedef TableFactor This;
  typedef DiscreteFactor Base;  
  typedef std::shared_ptr<TableFactor> shared_ptr;
  typedef Eigen::SparseVector<double>::InnerIterator SparseIt;
  typedef std::vector<std::pair<DiscreteValues, double>> AssignValList;
 
 
  TableFactor();
 
  TableFactor(const DiscreteKeys& keys, const TableFactor& potentials);
 
  TableFactor(const DiscreteKeys& keys,
              const Eigen::SparseVector<double>& table);
 
  TableFactor(const DiscreteKeys& keys, const std::vector<double>& table)
      : TableFactor(keys, Convert(keys, table)) {}
 
  TableFactor(const DiscreteKeys& keys, const std::string& table)
      : TableFactor(keys, Convert(keys, table)) {}
 
  template <class SOURCE>
  TableFactor(const DiscreteKey& key, SOURCE table)
      : TableFactor(DiscreteKeys{key}, table) {}
 
  TableFactor(const DiscreteKey& key, const std::vector<double>& row)
      : TableFactor(DiscreteKeys{key}, row) {}
 
  TableFactor(const DiscreteKeys& keys, const DecisionTreeFactor& dtf);
  TableFactor(const DecisionTreeFactor& dtf);
 
  TableFactor(const DiscreteKeys& keys, const DecisionTree<Key, double>& dtree);
 
  explicit TableFactor(const DiscreteConditional& c);
 
 
  bool equals(const DiscreteFactor& other, double tol = 1e-9) const override;
 
  // print
  void print(
      const std::string& s = "TableFactor:\n",
      const KeyFormatter& formatter = DefaultKeyFormatter) const override;
 
  // /// @}
  // /// @name Standard Interface
  // /// @{
 
  Eigen::SparseVector<double> sparseTable() const { return sparse_table_; }
 
  double evaluate(const Assignment<Key>& values) const override;
 
  double error(const DiscreteValues& values) const override;
 
  DiscreteFactor::shared_ptr operator*(double s) const override {
    return std::make_shared<TableFactor>(
        apply([s](const double& a) { return Ring::mul(a, s); }));
  }
 
  TableFactor operator*(const TableFactor& f) const {
    return apply(f, Ring::mul);
  };
 
  DecisionTreeFactor operator*(const DecisionTreeFactor& f) const override;
 
  virtual DiscreteFactor::shared_ptr multiply(
      const DiscreteFactor::shared_ptr& f) const override;
 
  static double safe_div(const double& a, const double& b);
 
  TableFactor operator/(const TableFactor& f) const {
    return apply(f, safe_div);
  }
 
  DiscreteFactor::shared_ptr operator/(
      const DiscreteFactor::shared_ptr& f) const override;
 
  DecisionTreeFactor toDecisionTreeFactor() const override;
 
  TableFactor choose(const DiscreteValues parentAssignments,
                     DiscreteKeys parent_keys) const;
 
  DiscreteFactor::shared_ptr sum(size_t nrFrontals) const override;
 
  DiscreteFactor::shared_ptr sum(const Ordering& keys) const override;
 
  double max() const override;
 
  DiscreteFactor::shared_ptr max(size_t nrFrontals) const override;
 
  DiscreteFactor::shared_ptr max(const Ordering& keys) const override;
 
 
  TableFactor apply(Unary op) const;
  TableFactor apply(UnaryAssignment op) const;
 
  TableFactor apply(const TableFactor& f, Binary op) const;
 
  DiscreteKeys contractDkeys(const TableFactor& f) const;
 
  DiscreteKeys freeDkeys(const TableFactor& f) const;
 
  DiscreteKeys unionDkeys(const TableFactor& f) const;
 
  uint64_t unionRep(const DiscreteKeys& keys, const DiscreteValues& assign,
                    const uint64_t idx) const;
 
  std::unordered_map<uint64_t, AssignValList> createMap(
      const DiscreteKeys& contract, const DiscreteKeys& free) const;
 
  uint64_t uniqueRep(const DiscreteKeys& keys, const uint64_t idx) const;
 
  uint64_t uniqueRep(const DiscreteValues& assignments) const;
 
  DiscreteValues findAssignments(const uint64_t idx) const;
 
  double findValue(const DiscreteValues& values) const;
 
  shared_ptr combine(size_t nrFrontals, Binary op) const;
 
  shared_ptr combine(const Ordering& keys, Binary op) const;
 
  std::vector<std::pair<DiscreteValues, double>> enumerate() const;
 
  TableFactor prune(size_t maxNrAssignments) const;
 
  uint64_t nrValues() const override { return sparse_table_.nonZeros(); }
 
  DiscreteFactor::shared_ptr restrict(
      const DiscreteValues& assignment) const override;
 
 
  std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                       const Names& names = {}) const override;
 
  std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                   const Names& names = {}) const override;
 
 
  double error(const HybridValues& values) const override;
 
 
 private:
#if GTSAM_ENABLE_BOOST_SERIALIZATION
 
  friend class boost::serialization::access;
  template <class ARCHIVE>
  void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
    ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
    ar& BOOST_SERIALIZATION_NVP(sparse_table_);
    ar& BOOST_SERIALIZATION_NVP(denominators_);
    ar& BOOST_SERIALIZATION_NVP(sorted_dkeys_);
  }
#endif
};
 
// traits
template <>
struct traits<TableFactor> : public Testable<TableFactor> {};
}  // namespace gtsam