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 HybridValues;

class GTSAM_EXPORT TableFactor : public DiscreteFactor {
 protected:
  std::map<Key, size_t> cardinalities_;
  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 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) {}


  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);

  size_t cardinality(Key j) const { return cardinalities_.at(j); }

  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(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;

  DiscreteKeys discreteKeys() 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;

};

// traits
template <>
struct traits<TableFactor> : public Testable<TableFactor> {};
}  // namespace gtsam