Domain.h

/*
 * Domain.h
 * @brief Domain restriction constraint
 * @date Feb 13, 2012
 * @author Frank Dellaert
 */
 
#pragma once
 
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam_unstable/discrete/Constraint.h>
 
namespace gtsam {
 
class GTSAM_UNSTABLE_EXPORT Domain : public Constraint {
  size_t cardinality_;       
  std::set<size_t> values_;  
 
 public:
  typedef boost::shared_ptr<Domain> shared_ptr;
 
  // Constructor on Discrete Key initializes an "all-allowed" domain
  Domain(const DiscreteKey& dkey)
      : Constraint(dkey.first), cardinality_(dkey.second) {
    for (size_t v = 0; v < cardinality_; v++) values_.insert(v);
  }
 
  // Constructor on Discrete Key with single allowed value
  // Consider SingleValue constraint
  Domain(const DiscreteKey& dkey, size_t v)
      : Constraint(dkey.first), cardinality_(dkey.second) {
    values_.insert(v);
  }
 
  Domain(const Domain& other)
      : Constraint(other.keys_[0]), values_(other.values_) {}
 
  void insert(size_t value) { values_.insert(value); }
 
  void erase(size_t value) { values_.erase(value); }
 
  size_t nrValues() const { return values_.size(); }
 
  bool isSingleton() const { return nrValues() == 1; }
 
  size_t firstValue() const { return *values_.begin(); }
 
  // print
  void print(const std::string& s = "", const KeyFormatter& formatter =
                                            DefaultKeyFormatter) const override;
 
  bool equals(const DiscreteFactor& other, double tol) const override {
    if (!dynamic_cast<const Domain*>(&other))
      return false;
    else {
      const Domain& f(static_cast<const Domain&>(other));
      return (cardinality_ == f.cardinality_) && (values_ == f.values_);
    }
  }
 
  bool contains(size_t value) const { return values_.count(value) > 0; }
 
  double operator()(const Values& values) const override;
 
  DecisionTreeFactor toDecisionTreeFactor() const override;
 
  DecisionTreeFactor operator*(const DecisionTreeFactor& f) const override;
 
  /*
   * Ensure Arc-consistency
   * @param j domain to be checked
   * @param domains all other domains
   */
  bool ensureArcConsistency(size_t j,
                            std::vector<Domain>& domains) const override;
 
  bool checkAllDiff(const KeyVector keys, std::vector<Domain>& domains);
 
  Constraint::shared_ptr partiallyApply(const Values& values) const override;
 
  Constraint::shared_ptr partiallyApply(
      const std::vector<Domain>& domains) const override;
};
 
}  // namespace gtsam