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/DiscreteFactor.h>
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam/inference/Ordering.h>
 
#include <Eigen/Sparse>
#include <algorithm>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
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]));
  }
 
  static Eigen::SparseVector<double> Convert(const std::vector<double>& table);
 
  static Eigen::SparseVector<double> Convert(const std::string& table);
 
 public:
  // 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;
  using Unary = std::function<double(const double&)>;
  using UnaryAssignment =
      std::function<double(const Assignment<Key>&, const double&)>;
  using Binary = std::function<double(const double, const double)>;
 
 public:
  struct Ring {
    static inline double zero() { return 0.0; }
    static inline double one() { return 1.0; }
    static inline double add(const double& a, const double& b) { return a + b; }
    static inline double max(const double& a, const double& b) {
      return std::max(a, b);
    }
    static inline double mul(const double& a, const double& b) { return a * b; }
    static inline double div(const double& a, const double& b) {
      return (a == 0 || b == 0) ? 0 : (a / b);
    }
    static inline double id(const double& x) { return x; }
  };
 
 
  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(table)) {}
 
  TableFactor(const DiscreteKeys& keys, const std::string& table)
      : TableFactor(keys, Convert(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 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
  // /// @{
 
  double evaluate(const DiscreteValues& values) const {
    return operator()(values);
  }
 
  double operator()(const DiscreteValues& values) const override;
 
  double error(const DiscreteValues& values) const;
 
  TableFactor operator*(const TableFactor& f) const {
    return apply(f, Ring::mul);
  };
 
  DecisionTreeFactor operator*(const DecisionTreeFactor& f) const override;
 
  static double safe_div(const double& a, const double& b);
 
  TableFactor operator/(const TableFactor& f) const {
    return apply(f, safe_div);
  }
 
  DecisionTreeFactor toDecisionTreeFactor() const override;
 
  TableFactor choose(const DiscreteValues assignments,
                     DiscreteKeys parent_keys) const;
 
  shared_ptr sum(size_t nrFrontals) const {
    return combine(nrFrontals, Ring::add);
  }
 
  shared_ptr sum(const Ordering& keys) const {
    return combine(keys, Ring::add);
  }
 
  shared_ptr max(size_t nrFrontals) const {
    return combine(nrFrontals, Ring::max);
  }
 
  shared_ptr max(const Ordering& keys) const {
    return combine(keys, Ring::max);
  }
 
 
  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;
 
 
  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;
 
  AlgebraicDecisionTree<Key> errorTree() const override;
 
};
 
// traits
template <>
struct traits<TableFactor> : public Testable<TableFactor> {};
}  // namespace gtsam