Scheduler.h

/*
 * Scheduler.h
 * @brief an example how inference can be used for scheduling qualifiers
 * @date Mar 26, 2011
 * @author Frank Dellaert
 */
 
#pragma once
 
#include <gtsam_unstable/discrete/CSP.h>
 
namespace gtsam {
 
class GTSAM_UNSTABLE_EXPORT Scheduler : public CSP {
 private:
  struct Student {
    std::string name_;
    DiscreteKey key_;                // key for student
    std::vector<DiscreteKey> keys_;  // key for areas
    std::vector<std::string> areaName_;
    std::vector<double> advisor_;
    Student(size_t nrFaculty, size_t advisorIndex)
        : keys_(3), areaName_(3), advisor_(nrFaculty, 1.0) {
      advisor_[advisorIndex] = 0.0;
    }
    void print() const {
      using std::cout;
      cout << name_ << ": ";
      for (size_t area = 0; area < 3; area++) cout << areaName_[area] << " ";
      cout << std::endl;
    }
  };
 
  size_t maxNrStudents_;
 
  std::vector<Student> students_;
 
  std::map<std::string, size_t> facultyIndex_;
  std::vector<std::string> facultyName_, slotName_, areaName_;
 
  typedef std::map<std::string, std::vector<double> > FacultyInArea;
  FacultyInArea facultyInArea_;
 
  std::string available_;
 
  std::vector<double> slotsAvailable_;
 
 public:
  Scheduler(size_t maxNrStudents) : maxNrStudents_(maxNrStudents) {}
 
  virtual ~Scheduler() {}
 
  void addFaculty(const std::string& facultyName) {
    facultyIndex_[facultyName] = nrFaculty();
    facultyName_.push_back(facultyName);
  }
 
  size_t nrFaculty() const { return facultyName_.size(); }
 
  void setAvailability(const std::string& available) { available_ = available; }
 
  void addSlot(const std::string& slotName) { slotName_.push_back(slotName); }
 
  size_t nrTimeSlots() const { return slotName_.size(); }
 
  const std::string& slotName(size_t s) const { return slotName_[s]; }
 
  void setSlotsAvailable(const std::vector<double>& slotsAvailable) {
    slotsAvailable_ = slotsAvailable;
  }
 
  void addArea(const std::string& facultyName, const std::string& areaName) {
    areaName_.push_back(areaName);
    std::vector<double>& table =
        facultyInArea_[areaName];  // will create if needed
    if (table.empty()) table.resize(nrFaculty(), 0);
    table[facultyIndex_[facultyName]] = 1;
  }
 
  Scheduler(size_t maxNrStudents, const std::string& filename);
 
  const DiscreteKey& key(size_t s,
                         boost::optional<size_t> area = boost::none) const;
 
  void addStudent(const std::string& studentName, const std::string& area1,
                  const std::string& area2, const std::string& area3,
                  const std::string& advisor);
 
  size_t nrStudents() const { return students_.size(); }
 
  const std::string& studentName(size_t i) const;
  const DiscreteKey& studentKey(size_t i) const;
  const std::string& studentArea(size_t i, size_t area) const;
 
  void addStudentSpecificConstraints(
      size_t i, boost::optional<size_t> slot = boost::none);
 
  void buildGraph(size_t mutexBound = 7);
 
  void print(
      const std::string& s = "Scheduler",
      const KeyFormatter& formatter = DefaultKeyFormatter) const override;
 
  void printAssignment(sharedValues assignment) const;
 
  void printSpecial(sharedValues assignment) const;
 
  void accumulateStats(sharedValues assignment,
                       std::vector<size_t>& stats) const;
 
  DiscreteBayesNet::shared_ptr eliminate() const;
 
  sharedValues optimalAssignment() const;
 
  sharedValues bestSchedule() const;
 
  sharedValues bestAssignment(sharedValues bestSchedule) const;
 
};  // Scheduler
 
}  // namespace gtsam