DiscreteFactor.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/base/Testable.h>
#include <gtsam/discrete/AlgebraicDecisionTree.h>
#include <gtsam/discrete/DiscreteValues.h>
#include <gtsam/inference/Factor.h>
 
#include <string>
namespace gtsam {
 
class DecisionTreeFactor;
class DiscreteConditional;
class HybridValues;
class Ordering;
class TableFactor;

class GTSAM_EXPORT DiscreteFactor : public Factor {
 public:
  // typedefs needed to play nice with gtsam
  typedef DiscreteFactor This;  
  typedef std::shared_ptr<DiscreteFactor>
      shared_ptr;       
  typedef Factor Base;  
 
  using Values = DiscreteValues;  
 
  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)>;
 
 protected:
  std::map<Key, size_t> cardinalities_;
 
 public:

  DiscreteFactor() {}

  template <typename CONTAINER>
  DiscreteFactor(const CONTAINER& keys,
                 const std::map<Key, size_t> cardinalities = {})
      : Base(keys), cardinalities_(cardinalities) {}


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

  void print(
      const std::string& s = "DiscreteFactor\n",
      const KeyFormatter& formatter = DefaultKeyFormatter) const override {
    Base::print(s, formatter);
  }


  DiscreteKeys discreteKeys() const;
 
  std::map<Key, size_t> cardinalities() const { return cardinalities_; }
 
  size_t cardinality(Key j) const { return cardinalities_.at(j); }

  virtual double evaluate(const Assignment<Key>& values) const = 0;

  double operator()(const DiscreteValues& values) const {
    return evaluate(values);
  }

  virtual double error(const DiscreteValues& values) const;

  double error(const HybridValues& c) const override;

  virtual AlgebraicDecisionTree<Key> errorTree() const;

  virtual DiscreteFactor::shared_ptr operator*(double s) const = 0;

  virtual DecisionTreeFactor operator*(const DecisionTreeFactor&) const = 0;

   * @param df DiscreteFactor shared_ptr
   * @return DiscreteFactor::shared_ptr
   */
  virtual DiscreteFactor::shared_ptr multiply(
      const DiscreteFactor::shared_ptr& df) const;

  virtual DiscreteFactor::shared_ptr operator/(
      const DiscreteFactor::shared_ptr& df) const = 0;
 
  virtual DecisionTreeFactor toDecisionTreeFactor() const = 0;

  virtual TableFactor toTableFactor() const;

  virtual DiscreteFactor::shared_ptr sum(size_t nrFrontals) const = 0;

  virtual DiscreteFactor::shared_ptr sum(const Ordering& keys) const = 0;

  virtual double max() const = 0;

  virtual DiscreteFactor::shared_ptr max(size_t nrFrontals) const = 0;

  virtual DiscreteFactor::shared_ptr max(const Ordering& keys) const = 0;

  DiscreteFactor::shared_ptr scale() const;

  virtual uint64_t nrValues() const = 0;

  virtual DiscreteFactor::shared_ptr restrict(
      const DiscreteValues& assignment) const = 0;


  using Names = DiscreteValues::Names;

  virtual std::string markdown(
      const KeyFormatter& keyFormatter = DefaultKeyFormatter,
      const Names& names = {}) const = 0;

  virtual std::string html(
      const KeyFormatter& keyFormatter = DefaultKeyFormatter,
      const Names& names = {}) const = 0;

 
 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(cardinalities_);
  }
#endif
};
// DiscreteFactor
 
// traits
template <>
struct traits<DiscreteFactor> : public Testable<DiscreteFactor> {};
 
}  // namespace gtsam