SingleValue.h

/*
 * SingleValue.h
 * @brief domain constraint
 * @date Feb 6, 2012
 * @author Frank Dellaert
 */

#pragma once

#include <gtsam_unstable/discrete/Constraint.h>
#include <gtsam/discrete/DiscreteKey.h>

namespace gtsam {

  class GTSAM_UNSTABLE_EXPORT SingleValue: public Constraint {

    size_t cardinality_;

    size_t value_;

    DiscreteKey discreteKey() const {
      return DiscreteKey(keys_[0],cardinality_);
    }

  public:

    typedef boost::shared_ptr<SingleValue> shared_ptr;

    SingleValue(Key key, size_t n, size_t value) :
      Constraint(key), cardinality_(n), value_(value) {
    }

    SingleValue(const DiscreteKey& dkey, size_t value) :
      Constraint(dkey.first), cardinality_(dkey.second), value_(value) {
    }

    // print
    virtual void print(const std::string& s = "",
        const KeyFormatter& formatter = DefaultKeyFormatter) const;

    bool equals(const DiscreteFactor& other, double tol) const {
      if(!dynamic_cast<const SingleValue*>(&other))
        return false;
      else {
        const SingleValue& f(static_cast<const SingleValue&>(other));
        return (cardinality_==f.cardinality_) && (value_==f.value_);
      }
    }

    virtual double operator()(const Values& values) const;

    virtual DecisionTreeFactor toDecisionTreeFactor() const;

    virtual DecisionTreeFactor operator*(const DecisionTreeFactor& f) const;

    /*
     * Ensure Arc-consistency
     * @param j domain to be checked
     * @param domains all other domains
     */
    bool ensureArcConsistency(size_t j, std::vector<Domain>& domains) const;

    virtual Constraint::shared_ptr partiallyApply(
        const Values& values) const;

    virtual Constraint::shared_ptr partiallyApply(
        const std::vector<Domain>& domains) const;
  };

} // namespace gtsam