timed_word.hh

 
#pragma once
 
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#include <cassert>
 
#include <boost/functional/hash.hpp>
 
#include "common_types.hh"
 
namespace learnta {
  class TimedWord {
  private:
    std::string word;
    std::vector<double> durations;
  public:
    TimedWord() : durations({0}) {}
 
    TimedWord(const std::string& word, const std::vector<double>& durations) {
      assert(word.size() + 1 == durations.size());
      this->word.reserve(word.size());
      this->durations = {durations.front()};
      this->durations.reserve(durations.size());
      for (std::size_t i = 0; i < word.size(); ++i) {
        if (word.at(i) != UNOBSERVABLE) {
          this->word.push_back(word.at(i));
          this->durations.push_back(durations.at(i + 1));
        } else {
          this->durations.back() += durations.at(i + 1);
        }
      }
 
      assert(this->word.size() + 1 == this->durations.size());
    }
 
    TimedWord operator+(const TimedWord &another) const {
      TimedWord result = *this;
      result.word += another.word;
      auto it = another.durations.begin();
      result.durations.back() += *it++;
      result.durations.reserve(this->durations.size() + another.durations.size() - 1);
      for (; it != another.durations.end(); it++) {
        result.durations.push_back(*it);
      }
 
      return result;
    }
 
    TimedWord operator+(const char action) {
      TimedWord result = *this;
      result.word.push_back(action);
      result.durations.push_back(0);
 
      return result;
    }
 
    TimedWord operator+(const double duration) {
      TimedWord result = *this;
      result.durations.back() += duration;
 
      return result;
    }
 
    std::ostream &print(std::ostream &stream) const {
      stream << durations[0];
      for (std::size_t i = 0; i < word.size(); i++) {
        stream << " " << word[i] << " " << durations[i + 1];
      }
      return stream;
    }
 
    [[nodiscard]] const std::string &getWord() const {
      return word;
    }
 
    [[nodiscard]] const std::vector<double> &getDurations() const {
      return durations;
    }
 
    [[nodiscard]] std::vector<double> getAccumulatedDurations() const {
      std::vector<double> accumulatedDurations;
      accumulatedDurations.resize(durations.size());
 
      accumulatedDurations.back() = durations.back();
      for (int i = durations.size() - 2; i >= 0; --i) {
        accumulatedDurations.at(i) = accumulatedDurations.at(i + 1) +durations.at(i);
      }
      return accumulatedDurations;
    }
 
    [[nodiscard]] TimedWord getSuffix(const TimedWord& prefix) const {
      const auto suffixWord = this->word.substr(prefix.wordSize());
      auto suffixDurations = std::vector<double>(this->durations.begin() + prefix.wordSize(), this->durations.end());
      suffixDurations.front() -= prefix.getDurations().back();
 
      return TimedWord{suffixWord, suffixDurations};
    }
 
    [[nodiscard]] std::size_t wordSize() const {
      return this->word.size();
    }
 
    bool operator==(const TimedWord &another) const {
      return this->word == another.word && this->durations == another.durations;
    }
  };
 
  static inline std::ostream &print(std::ostream &os, const learnta::TimedWord &word) {
    os << word.getDurations().front();
    for (std::size_t i = 0; i < word.wordSize(); ++i) {
      os << " " << word.getWord().at(i) << " " << word.getDurations().at(i + 1);
    }
    return os;
  }
 
  static inline std::ostream &operator<<(std::ostream &os, const learnta::TimedWord &word) {
    return learnta::print(os, word);
  }
 
  static inline std::size_t hash_value(const TimedWord &word) {
    return boost::hash_value(std::make_tuple(word.getWord(), word.getDurations()));
  }
}