TableDistribution.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/DiscreteConditional.h>
#include <gtsam/discrete/TableFactor.h>
#include <gtsam/inference/Conditional-inst.h>
 
#include <memory>
#include <string>
#include <vector>
 
namespace gtsam {

class GTSAM_EXPORT TableDistribution : public DiscreteConditional {
 private:
  TableFactor table_;
 
  typedef Eigen::SparseVector<double>::InnerIterator SparseIt;
 
 public:
  // typedefs needed to play nice with gtsam
  typedef TableDistribution This;            
  typedef std::shared_ptr<This> shared_ptr;  
  typedef DiscreteConditional
      BaseConditional;  
 
  using Values = DiscreteValues;  


  TableDistribution() {}

  TableDistribution(const TableFactor& f);

  TableDistribution(const DiscreteKeys& keys,
                    const std::vector<double>& potentials);

  TableDistribution(const DiscreteKey& key,
                    const std::vector<double>& potentials)
      : TableDistribution(DiscreteKeys(key), potentials) {}

  TableDistribution(const DiscreteKeys& keys, const std::string& potentials);

  TableDistribution(const DiscreteKey& key, const std::string& potentials)
      : TableDistribution(DiscreteKeys(key), potentials) {}


  void print(
      const std::string& s = "Table Distribution: ",
      const KeyFormatter& formatter = DefaultKeyFormatter) const override;

  bool equals(const DiscreteFactor& other, double tol = 1e-9) const override;


  TableFactor table() const { return table_; }
 
  using BaseConditional::evaluate;  // HybridValues version

  virtual double evaluate(const Assignment<Key>& values) const override {
    return table_.evaluate(values);
  }

  DiscreteFactor::shared_ptr sum(size_t nrFrontals) const override;

  DiscreteFactor::shared_ptr sum(const Ordering& keys) const override;

  double max() const override { return table_.max(); }

  DiscreteFactor::shared_ptr max(size_t nrFrontals) const override;

  DiscreteFactor::shared_ptr max(const Ordering& keys) const override;

  DiscreteFactor::shared_ptr operator*(double s) const override;

  DiscreteFactor::shared_ptr operator/(
      const DiscreteFactor::shared_ptr& f) const override;

  DiscreteValues argmax() const;

  virtual size_t sample(const DiscreteValues& parentsValues,
                        std::mt19937_64* rng = nullptr) const override;


  virtual void prune(size_t maxNrAssignments) override;

  DecisionTreeFactor toDecisionTreeFactor() const override {
    return table_.toDecisionTreeFactor();
  }

  TableFactor toTableFactor() const override { return table_; }

  uint64_t nrValues() const override { return table_.sparseTable().nonZeros(); }

 
 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(BaseConditional);
    ar& BOOST_SERIALIZATION_NVP(table_);
  }
#endif
};
// TableDistribution
 
// traits
template <>
struct traits<TableDistribution> : public Testable<TableDistribution> {};
 
}  // namespace gtsam