DiscreteSearch.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
 
 * -------------------------------------------------------------------------- */

 
#include <gtsam/discrete/DiscreteBayesNet.h>
#include <gtsam/discrete/DiscreteBayesTree.h>
 
#include <queue>
 
namespace gtsam {

class GTSAM_EXPORT DiscreteSearch {
 public:
  struct Slot {
    DiscreteFactor::shared_ptr factor;
    std::vector<DiscreteValues> assignments;
    double heuristic;
 
    friend std::ostream& operator<<(std::ostream& os, const Slot& slot) {
      os << "Slot with " << slot.assignments.size()
         << " assignments, heuristic=" << slot.heuristic;
      os << ", factor:\n" << slot.factor->markdown() << std::endl;
      return os;
    }
  };

  struct Solution {
    double error;
    DiscreteValues assignment;
    Solution(double err, const DiscreteValues& assign)
        : error(err), assignment(assign) {}
    friend std::ostream& operator<<(std::ostream& os, const Solution& sn) {
      os << "[ error=" << sn.error << " assignment={" << sn.assignment << "}]";
      return os;
    }
  };
 
 public:

  static DiscreteSearch FromFactorGraph(const DiscreteFactorGraph& factorGraph,
                                        const Ordering& ordering,
                                        bool buildJunctionTree = false);

  DiscreteSearch(const DiscreteEliminationTree& etree);

  DiscreteSearch(const DiscreteJunctionTree& junctionTree);

  DiscreteSearch(const DiscreteBayesNet& bayesNet);

  DiscreteSearch(const DiscreteBayesTree& bayesTree);


  void print(const std::string& name = "DiscreteSearch: ",
             const KeyFormatter& formatter = DefaultKeyFormatter) const;


  double lowerBound() const { return lowerBound_; }

  const std::vector<Slot>& slots() const { return slots_; }

  std::vector<Solution> run(size_t K = 1) const;

 
 private:
  double computeHeuristic();
 
  double lowerBound_;  
  std::vector<Slot> slots_;  
};
 
using DiscreteSearchSolution = DiscreteSearch::Solution;  // for wrapping
}  // namespace gtsam