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) {
    }

    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;

    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

} // gtsam