fractional_order.hh

 
#pragma once
 
#include <deque>
#include <unordered_set>
 
#include <boost/functional/hash.hpp>
#include <boost/log/trivial.hpp>
#include <boost/log/core.hpp>
#include <boost/log/expressions.hpp>
 
#include "common_types.hh"
 
namespace learnta {
  class FractionalOrder {
  private:
    std::deque<std::deque<ClockVariables>> order;
    // The number of the variables
    std::size_t size;
  public:
    FractionalOrder() {
      order.push_front({0});
      size = 1;
    }
 
    FractionalOrder(const FractionalOrder &order) = default;
    FractionalOrder(FractionalOrder &&order) = default;
    FractionalOrder& operator=(const FractionalOrder& order) = default;
    FractionalOrder& operator=(FractionalOrder&& order) = default;
    explicit FractionalOrder(const std::vector<double> &fractionalParts) {
      std::vector<std::pair<double, ClockVariables>> fractionalPartsWithIndices;
      fractionalPartsWithIndices.resize(fractionalParts.size());
      for (std::size_t i = 0; i < fractionalParts.size(); ++i) {
        fractionalPartsWithIndices.at(i) = std::make_pair(fractionalParts.at(i), i);
      }
      std::sort(fractionalPartsWithIndices.begin(), fractionalPartsWithIndices.end());
      double currentFractionalPart = 0;
      order.emplace_back();
      for (const auto&[fractionalPart, index]: fractionalPartsWithIndices) {
        if (currentFractionalPart == fractionalPart) {
          order.back().push_back(index);
        } else {
          order.emplace_back(std::deque<ClockVariables>{index});
          currentFractionalPart = fractionalPart;
        }
      }
 
      size = fractionalParts.size();
    }
 
    [[nodiscard]] const std::deque<ClockVariables>& successorVariables() const {
      if (order.front().empty()) {
        return order.back();
      } else {
        return order.front();
      }
    }
 
    [[nodiscard]] FractionalOrder successor() const {
      FractionalOrder result = *this;
      if (order.front().empty()) {
        // If there is no variables equal to 0.
        std::swap(result.order.front(), result.order.back());
        result.order.pop_back();
      } else {
        // If there are some variables equal to 0.
        result.order.emplace_front();
      }
 
      return result;
    }
 
    void successorAssign() {
      if (order.front().empty()) {
        // If there is no variables equal to 0.
        std::swap(order.front(), order.back());
        order.pop_back();
      } else {
        // If there are some variables equal to 0.
        order.emplace_front();
      }
    }
 
    [[nodiscard]] std::deque<ClockVariables> predecessorVariables() const {
      if (order.empty()) {
        BOOST_LOG_TRIVIAL(error) << "Something wrong happened in the predecessorVariables. order is empty";
      }
      if (order.front().empty()) {
        if (order.size() <= 1) {
          BOOST_LOG_TRIVIAL(error) << "Something wrong happened in the predecessorVariables. No variable exists";
        }
        return *(std::next(order.begin()));
      } else {
        return order.front();
      }
    }
 
    [[nodiscard]] FractionalOrder predecessor() const {
      FractionalOrder result = *this;
      if (order.front().empty()) {
        // If there is no variables equal to 0.
        result.order.pop_front();
      } else {
        // If there are some variables equal to 0.
        result.order.emplace_back();
        std::swap(result.order.front(), result.order.back());
      }
 
      return result;
    }
 
    [[nodiscard]] FractionalOrder extendN() const {
      FractionalOrder result = *this;
      result.order.front().push_back(result.size++);
      return result;
    }
 
    [[nodiscard]] FractionalOrder removeN() const {
      FractionalOrder result = *this;
      assert(static_cast<std::size_t>(result.order.front().back() + 1) == this->size);
      assert(result.size > 0);
      result.order.front().pop_back();
      result.size--;
      return result;
    }
 
    [[nodiscard]] FractionalOrder extendZero() const {
      FractionalOrder result = *this;
 
      for (auto &variables: result.order) {
        std::transform(variables.begin(), variables.end(), variables.begin(), [](auto variable) {
          return variable + 1;
        });
      }
      result.order.front().push_front(0);
      result.size++;
      return result;
    }
 
    [[nodiscard]] size_t getSize() const {
      return size;
    }
 
    bool operator==(const FractionalOrder &another) const {
      return this->size == another.size && this->order == another.order;
    }
 
    std::ostream &print(std::ostream &os) const {
      auto it = order.begin();
      if (it->empty()) {
        os << "0 < ";
        it++;
      } else {
        os << "0 <= ";
      }
      for (; it != order.end(); it++) {
        os << "{";
        for (const auto var: *it) {
          os << "x" << int(var) << ", ";
        }
        os << "}";
      }
 
      return os;
    }
 
    [[nodiscard]] std::size_t hash_value() const {
      return boost::hash_value(std::make_pair(this->order, this->size));
    }
  };
 
  static inline std::ostream &operator<<(std::ostream &os, const learnta::FractionalOrder &order) {
    return order.print(os);
  }
 
  inline std::size_t hash_value(learnta::FractionalOrder const &order) {
    return order.hash_value();
  }
}