FactorOracle2.hpp

#pragma once
#include <ossia/detail/hash_map.hpp>
#include <ossia/detail/math.hpp>
#include <ossia/detail/ssize.hpp>
 
#include <halp/controls.hpp>
#include <halp/meta.hpp>
#include <halp/midi.hpp>
 
#include <random>
//#if !defined(NDEBUG) && !defined(_MSC_VER) && !defined(__clang__)
//#include <debug/vector>
//#define debug_vector_t __gnu_debug::vector
//#else
#define debug_vector_t std::vector
//#endif
 
namespace Factor
{
template <class T>
class SingleTransition
{
public:
  int first_state_; 
  int last_state_;  
  T symbol_;        
};
 
template <class T>
class State
{
public:
  int state_;                                   
  std::vector<SingleTransition<T>> transition_; 
  int suffix_transition_;
  int lrs_ = 0;
  void singleTransitionResize() { transition_.resize(10); }
};
 
template <class T>
class FactorOracle
{
public:
  int phi = 0, k = 0, fo_iter = 0, current_state = 1;
  std::vector<T> input_values;
  std::vector<State<T>> states_;           
  std::vector<std::vector<int>> RevSuffix; 
  FactorOracle()
  {
    this->states_.resize(2);
    this->states_[0].state_ = 0;
    this->states_[0].lrs_ = 0;
    this->states_[0].suffix_transition_ = -1; 
    this->RevSuffix.resize(2);
  }
  void AddLetter(int i, const std::vector<T> word)
  {
 
    if(i != 0)
    {
      this->states_.resize(i + 1);
      this->RevSuffix.resize(i + 1);
      T alpha = word[i - 1];
      this->AddState(i - 1);
      int state_m_plus_one = i;
      this->AddTransition(i - 1, i, alpha);
      k = this->states_[i - 1].suffix_transition_; 
      phi = i - 1;                                 
      int flag = 0, iter = 0;
      while(k > -1 && flag == 0)
      {
        while(iter < std::ssize(this->states_[k].transition_))
        {
          if(this->states_[k].transition_[iter].symbol_ == alpha)
          {
            flag = 1;
          }
          iter++;
        }
        if(flag == 0)
        {
          this->AddTransition(k, state_m_plus_one, alpha);
          phi = k;
          k = this->states_[k].suffix_transition_;
          iter = 0;
        }
      }
      if(k == -1)
      {
        this->states_[state_m_plus_one].suffix_transition_ = 0;
        this->states_[state_m_plus_one].lrs_ = 0;
      }
      else
      {
        flag = 0, iter = 0;
        if(this->states_[k].transition_[iter].symbol_ == alpha)
        {
          flag = 1;
          this->states_[state_m_plus_one].suffix_transition_ = this->states_[k].transition_[iter].last_state_;
          this->states_[state_m_plus_one].lrs_ = this->LengthCommonSuffix(phi, this->states_[state_m_plus_one].suffix_transition_ - 1) + 1;
        }
        while(iter < this->states_[k].transition_.size() && flag == 0)
        {
          if(this->states_[k].transition_[iter].symbol_ == alpha)
          {
 
            this->states_[state_m_plus_one].suffix_transition_ = this->states_[k].transition_[iter].last_state_;
            this->states_[state_m_plus_one].lrs_ = this->LengthCommonSuffix(phi, this->states_[state_m_plus_one].suffix_transition_ - 1) + 1;
            flag = 1;
          }
 
          iter++;
        }
      }
      T temp_word = word[state_m_plus_one - this->states_[state_m_plus_one].lrs_ - 1];
      k = this->FindBetter(state_m_plus_one, temp_word, word);
      if(k != 0)
      {
        this->states_[state_m_plus_one].lrs_ = this->states_[state_m_plus_one].lrs_ + 1;
        this->states_[state_m_plus_one].suffix_transition_ = k;
      }
      RevSuffix[this->states_[state_m_plus_one].suffix_transition_].push_back(std::move(state_m_plus_one));
    }
  };
  int LengthCommonSuffix(int phi_one, int phi_two)
  {
    if(phi_two == this->states_[phi_one].suffix_transition_)
      return this->states_[phi_one].lrs_;
    else
    {
      while(this->states_[phi_one].suffix_transition_ != this->states_[phi_two].suffix_transition_)
        phi_two = this->states_[phi_two].suffix_transition_;
    }
    if(this->states_[phi_one].lrs_ <= this->states_[phi_two].lrs_)
      return this->states_[phi_one].lrs_;
    else
      return this->states_[phi_two].lrs_;
  };
  int FindBetter(int i, T alpha, const std::vector<T> word)
  {
 
    int len_t = this->RevSuffix[this->states_[i].suffix_transition_].size();
    int state_i = this->states_[i].suffix_transition_;
    if(len_t == 0)
      return 0;
    sort(this->RevSuffix[state_i].begin(), this->RevSuffix[state_i].end());
    for(int j = 0; j < len_t; j++)
    {
      if(this->states_[this->RevSuffix[this->states_[i].suffix_transition_][j]].lrs_ == this->states_[i].lrs_ && word[this->RevSuffix[this->states_[i].suffix_transition_][j] - this->states_[i].lrs_ - 1] == alpha)
      {
        int out = RevSuffix[this->states_[i].suffix_transition_][j];
        return out;
      }
    }
    return 0;
  };
  std::vector<T> FOGenerate(int& i, std::vector<T> v, float q)
  {
 
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(0.0, 1.0);
    float u = dis(gen);
 
    if(this->states_.size() == 2 || this->states_.size() == 1)
    {
      v.push_back(this->states_[0].transition_[0].symbol_);
    }
    else
    {
      if(u < q)
      {
        i = i + 1;
        int len = this->states_.size();
        if(i >= len)
          i = len - 1;
        T w = this->states_[i].transition_[0].symbol_;
        v.push_back(std::move(w));
      }
      else
      {
        int lenSuffix = this->states_[this->states_[i].suffix_transition_].transition_.size() - 1;
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis_int(0, lenSuffix);
        int rand_alpha = dis_int(gen);
        T alpha = this->states_[this->states_[i].suffix_transition_].transition_[rand_alpha].symbol_;
        i = this->states_[this->states_[i].suffix_transition_].transition_[rand_alpha].last_state_;
        if(i == -1)
        {
          i = 0;
        }
        v.push_back(std::move(alpha));
      }
    }
    return v;
  };
  void FactorOracleStart(const std::vector<T> word)
  {
 
    int len = std::ssize(word);
    this->states_.resize(2);
    this->states_[0].state_ = 0;
    this->states_[0].lrs_ = 0;
    this->states_[0].suffix_transition_ = -1;
    this->RevSuffix.resize(2);
  };
  void AddState(int first_state) { this->states_[first_state].state_ = first_state; };
  void AddTransition(int first_state, int last_state, T symbol)
  {
    SingleTransition<T> transition_i;
    transition_i.first_state_ = first_state;
    transition_i.last_state_ = last_state;
    transition_i.symbol_ = std::move(symbol);
    this->states_[first_state].transition_.push_back(std::move(transition_i));
  };
  std::vector<T> CallGenerate(int len, float q)
  {
 
    std::vector<T> oracle = {};
    fo_iter = 1;
    for(int x = 0; x < len; x++)
    {
      oracle = this->FOGenerate(fo_iter, oracle, q);
      if(fo_iter == len)
        fo_iter = len - 1;
    }
    return oracle;
  };
};
}
namespace Nodes::FactorOracle2
{
struct Node
{
  halp_meta(name, "New Factor Oracle")
  halp_meta(c_name, "New Factor Oracle")
  halp_meta(category, "Control/Impro")
  halp_meta(manual_url, "")
  halp_meta(author, "Maria Paula Carrero Rivas")
  halp_meta(description, "Factor Oracle algorithm .") // TODO cite
  halp_meta(uuid, "66F1C352-C48F-40A2-9283-35C2CB376258")
 
  struct
  {
 
  } inputs;
  struct
  {
 
  } outputs;
  static const constexpr auto controls = tuplet::make_tuple(Control::IntSlider{"Sequence length", 1, 64, 8});
  static const constexpr value_in value_ins[]{"in", "regen", "bang"};
  static const constexpr value_out value_outs[]{"out"};
 
  struct State
  {
    int i = 0;
    std::size_t sequence_idx{};
    debug_vector_t<ossia::value> sequence;
    Factor::FactorOracle<ossia::value> oracle;
  };
  ossia::value* buffer = nullptr;
  using control_policy = ossia::safe_nodes::last_tick;
  static void run(const ossia::value_port& in, const ossia::value_port& regen, const ossia::value_port& bangs, int seq_len, ossia::value_port& out, ossia::token_request, ossia::exec_state_facade, State& self)
  {
 
    // Entrées sont dans p1
    for(auto val : in.get_data())
    {
      self.oracle.input_values.push_back(val.value);
      self.oracle.AddLetter(self.oracle.current_state, self.oracle.input_values);
      self.oracle.current_state = self.oracle.current_state + 1;
    }
 
    if(!regen.get_data().empty())
    {
      self.sequence = self.oracle.CallGenerate(seq_len, 0.6);
    }
 
    if(!self.sequence.empty())
    {
      for(auto& bang : bangs.get_data())
      {
        self.sequence_idx = ossia::clamp<int64_t>((int64_t)self.sequence_idx, 0, (int64_t)self.sequence.size() - 1);
        out.write_value(self.sequence[self.sequence_idx], bang.timestamp);
        self.sequence_idx = (self.sequence_idx + 1) % self.sequence.size();
      }
    }
  }
};
#undef debug_vector_t
}