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>
#include <gtsam/discrete/DiscreteBayesNet.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,
                         std::optional<size_t> area = {}) 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, std::optional<size_t> slot = {});

  void buildGraph(size_t mutexBound = 7);

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

  void printAssignment(const DiscreteValues& assignment) const;

  void printSpecial(const DiscreteValues& assignment) const;

  void accumulateStats(const DiscreteValues& assignment,
                       std::vector<size_t>& stats) const;

  DiscreteBayesNet::shared_ptr eliminate() const;

  DiscreteValues bestSchedule() const;

  DiscreteValues bestAssignment(const DiscreteValues& bestSchedule) const;

};  // Scheduler

}  // namespace gtsam