tasks_generator 0.5 → 1.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: df500fd0b31dd89d245bba5d3c053c85fcce70bc
-  data.tar.gz: 39b7d2b58aaf8c4cda12f8090c0a87a5e0d34ad5
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDA0NjJhMmY0YWEzY2VmYzA0M2Q1YjU0MzA4NTNhZWQwNjFiOWNiYg==
+  data.tar.gz: !binary |-
+    YmJiMTZhYTZlMjQyODk0YmI5ZjM0MmZlOWU2NjE5Y2ExZjM2ZjM5OQ==
 SHA512:
-  metadata.gz: e5b154d344d579dfcf2b195cc83c11eaf9ac1388808cc4b1018b394f7db76a64b169e67bfbfc915ee21dac4b86e7e03490e9df6a8d2dfb34bff3e2fc32391e7e
-  data.tar.gz: 8257965c4b2ef0c80f7680dee458d361a61ab0d89c29cfccdf84754b741fd69781e3e44329d3d52cd85f4ef44462746004c7d4fceaf1c7cf422999d361785f71
+  metadata.gz: !binary |-
+    MTcyMDk2ZTg5ZTI4NTM3ZmI2ZWU2NzdlNDE3ZTMwNWFhZWI4MzhmNzA2NWU3
+    YmY5ZmJjOTMxMjY5NjMzNWQyNzA3YWNlY2VmYzAxMjY5MTljYmIyMDhjNmMx
+    OTc5N2NmY2ZiZTk0OTczNjIyNWJhNDAxNWM0OGZlZDZkOGRjY2I=
+  data.tar.gz: !binary |-
+    MzA4ODU4YzBmMDMzZWJhMWYzZWJmOThkNWYxYjQ5YjVhYmRjZWE5YjhhZjAx
+    MDA4OWM1MDc3ZmYxNzFmYjIwNDY0ZjZkMjFlY2EyYWI2NDhiYzdlMTAwNGY1
+    OWZlYTE5YTdhMzI2MGU3MGJiOGUyNThjNDYwODU4NTcxYTA0Nzc=

data/ext/tasks_generator/bindings.cc

@@ -5,17 +5,18 @@
 #include "config.h"
 #include "generator.h"
 #include "question.h"
-#include "theme.h"
+#include "topic.h"
 
-using namespace tasks_generator;
+using namespace ailab;
 
 template<>
 question_t from_ruby<question_t>(Rice::Object obj) {
   size_t qid = from_ruby<size_t>(obj.call("question_id"));
-  size_t tid = from_ruby<size_t>(obj.call("theme_id"));
+  size_t tid = from_ruby<size_t>(obj.call("topic_id"));
   size_t d = from_ruby<size_t>(obj.call("difficulty"));
+  std::string t = from_ruby<std::string>(obj.call("text"));
 
-  return question_t(qid, tid, d);
+  return question_t(qid, tid, d, t);
 }
 
 template<>
@@ -45,30 +46,48 @@ Rice::Object to_ruby(std::vector<question_t> const &questions) {
 }
 
 template<>
-theme_t from_ruby<theme_t>(Rice::Object obj) {
-  size_t id = from_ruby<size_t>(obj.call("theme_id"));
-  size_t dmin = from_ruby<size_t>(obj.call("difficulty_min"));
-  size_t dmax = from_ruby<size_t>(obj.call("difficulty_max"));
+topic_t from_ruby<topic_t>(Rice::Object obj) {
+  size_t id = from_ruby<size_t>(obj.call("topic_id"));
+  size_t pid = from_ruby<size_t>(obj.call("parent_id"));
+  std::string text = from_ruby<std::string>(obj.call("text"));
 
-  return theme_t(id, dmin, dmax);
+  return topic_t(id, pid, text);
 }
 
 template<>
-Rice::Object to_ruby<theme_t>(theme_t const &th) {
-  return Rice::Data_Object<theme_t>(new theme_t(th)); 
+Rice::Object to_ruby<topic_t>(topic_t const &th) {
+  return Rice::Data_Object<topic_t>(new topic_t(th)); 
 }
 
 template<>
-std::vector<theme_t> from_ruby<std::vector<theme_t>>(Rice::Object obj) {
+std::vector<topic_t> from_ruby<std::vector<topic_t>>(Rice::Object obj) {
   Rice::Array arr(obj);
 
-  std::vector<theme_t> themes;
-  themes.reserve(arr.size());
+  std::vector<topic_t> topics;
+  topics.reserve(arr.size());
 
   for (Rice::Object obj : arr)
-    themes.push_back(from_ruby<theme_t>(obj));
+    topics.push_back(from_ruby<topic_t>(obj));
 
-  return themes;
+  return topics;
+}
+
+template<>
+Rice::Object to_ruby<std::vector<size_t>>(std::vector<size_t> const &v) {
+  return Rice::Data_Object<std::vector<size_t>>(new std::vector<size_t>(v));
+}
+
+template<>
+std::vector<size_t> from_ruby<std::vector<size_t>>(Rice::Object obj) {
+  Rice::Array arr(obj);
+
+  std::vector<size_t> result;
+  result.reserve(arr.size());
+
+  for (Rice::Object obj : arr)
+    result.push_back(from_ruby<size_t>(obj));
+
+  return result;
 }
 
 void set_life_time(Rice::Object obj, size_t life_time) {
@@ -95,25 +114,33 @@ size_t get_population_size(Rice::Object obj) {
   return Rice::Data_Object<config_t>(obj)->population_size;
 }
 
-void set_tasks(Rice::Object obj, size_t tasks) {
-  Rice::Data_Object<config_t>(obj)->tasks = tasks;
+void set_variants_count(Rice::Object obj, size_t variants_count) {
+  Rice::Data_Object<config_t>(obj)->variants_count = variants_count;
+}
+
+size_t get_variants_count(Rice::Object obj) {
+  return Rice::Data_Object<config_t>(obj)->variants_count;
+}
+
+void set_questions_count(Rice::Object obj, size_t questions_count) {
+  Rice::Data_Object<config_t>(obj)->questions_count = questions_count;
 }
 
-size_t get_tasks(Rice::Object obj) {
-  return Rice::Data_Object<config_t>(obj)->tasks;
+size_t get_questions_count(Rice::Object obj) {
+  return Rice::Data_Object<config_t>(obj)->questions_count;
 }
 
-void set_themes(Rice::Object obj, Rice::Array themes) {
-  std::vector<theme_t> th = from_ruby<std::vector<theme_t>>(themes);
-  Rice::Data_Object<config_t>(obj)->themes = std::move(th);
+void set_topics(Rice::Object obj, Rice::Array topics) {
+  std::vector<size_t> th = from_ruby<std::vector<size_t>>(topics);
+  Rice::Data_Object<config_t>(obj)->topics = std::move(th);
 }
 
-Rice::Array get_themes(Rice::Object obj) {
-  std::vector<theme_t> const &themes = Rice::Data_Object<config_t>(obj)->themes;
+Rice::Array get_topics(Rice::Object obj) {
+  std::vector<size_t> const &topics = Rice::Data_Object<config_t>(obj)->topics;
 
   Rice::Array arr;
-  for (theme_t const &t : themes)
-    arr.push(to_ruby<theme_t>(t));
+  for (size_t t : topics)
+    arr.push(to_ruby<size_t>(t));
 
   return arr;
 }
@@ -125,8 +152,9 @@ config_t from_ruby<config_t>(Rice::Object obj) {
   result.life_time = from_ruby<size_t>(obj.call("life_time"));
   result.mutation_chance = from_ruby<double>(obj.call("mutation_chance"));
   result.population_size = from_ruby<size_t>(obj.call("population_size"));
-  result.tasks = from_ruby<size_t>(obj.call("tasks"));
-  result.themes = from_ruby<std::vector<theme_t>>(obj.call("themes"));
+  result.variants_count = from_ruby<size_t>(obj.call("variants_count"));
+  result.questions_count = from_ruby<size_t>(obj.call("questions_count"));
+  result.topics = from_ruby<std::vector<size_t>>(obj.call("topics"));
 
   return result;
 }
@@ -139,9 +167,10 @@ Rice::Object to_ruby<config_t>(config_t const &cnf) {
 template<>
 generator_t from_ruby<generator_t>(Rice::Object obj) {
   config_t config = from_ruby<config_t>(obj.call("config"));
+  std::vector<topic_t> topics = from_ruby<std::vector<topic_t>>(obj.call("topics"));
   std::vector<question_t> questions = from_ruby<std::vector<question_t>>(obj.call("questions"));
 
-  return generator_t(std::move(config), std::move(questions));
+  return generator_t(std::move(config), std::move(topics), std::move(questions));
 }
 
 template<>
@@ -150,9 +179,10 @@ Rice::Object to_ruby(generator_t const &t) {
 }
 
 template<>
-Rice::Object to_ruby<generator_t::answer_t>(generator_t::answer_t const &ans) {
+Rice::Object to_ruby<variants_t>(variants_t const &ans) {
+  std::vector<std::vector<question_t>> const &questions = ans.get_questions();
   Rice::Array result;
-  for (std::vector<question_t> const &arr : ans) {
+  for (std::vector<question_t> const &arr : questions) {
     Rice::Array buffer;
     for (question_t const &q : arr)
       buffer.push(to_ruby<question_t>(q));
@@ -165,36 +195,38 @@ extern "C" void Init_tasks_generator() {
   Rice::Module rb_mTasksGenerator = Rice::define_module("TasksGenerator");
 
   Rice::Data_Type<config_t> rb_cConfig = Rice::define_class_under<config_t>(rb_mTasksGenerator, "Config")
-    .define_constructor(Rice::Constructor<config_t, size_t>(), Rice::Arg("tasks") = 0)
+    .define_constructor(Rice::Constructor<config_t, size_t, size_t>(),
+      (Rice::Arg("variants_count") = 8, Rice::Arg("questions_count") = 8))
     .define_method("life_time=", &set_life_time)
     .define_method("mutation_chance=", &set_mutation_chance)
     .define_method("population_size=", &set_population_size)
-    .define_method("tasks=", &set_tasks)
+    .define_method("variants_count=", &set_variants_count)
+    .define_method("questions_count=", &set_questions_count)
     .define_method("life_time", &get_life_time)
     .define_method("mutation_chance", &get_mutation_chance)
     .define_method("population_size", &get_population_size)
-    .define_method("tasks", &get_tasks)
-    .define_method("themes", &get_themes)
-    .define_method("themes=", &set_themes);
-
-  Rice::Data_Type<theme_t> rb_cTheme = Rice::define_class_under<theme_t>(rb_mTasksGenerator, "Theme")
-    .define_constructor(Rice::Constructor<theme_t, size_t, size_t, size_t>(),
-      (Rice::Arg("id"), Rice::Arg("dmin"), Rice::Arg("dmax")))
-    .define_method("theme_id", &theme_t::get_theme_id)
-    .define_method("difficulty_min", &theme_t::get_difficulty_min)
-    .define_method("difficulty_max", &theme_t::get_difficulty_max);
+    .define_method("variants_count", &get_variants_count)
+    .define_method("questions_count", &get_questions_count)
+    .define_method("topics", &get_topics)
+    .define_method("topics=", &set_topics);
+
+  Rice::Data_Type<topic_t> rb_ctopic = Rice::define_class_under<topic_t>(rb_mTasksGenerator, "Topic")
+    .define_constructor(Rice::Constructor<topic_t, size_t, size_t, std::string>(),
+      (Rice::Arg("id"), Rice::Arg("pid"), Rice::Arg("text")))
+    .define_method("topic_id", &topic_t::get_topic_id)
+    .define_method("parent_id", &topic_t::get_parent_id)
+    .define_method("text", &topic_t::get_text);
 
   Rice::Data_Type<question_t> rb_cQuestion = Rice::define_class_under<question_t>(rb_mTasksGenerator, "Question")
-    .define_constructor(Rice::Constructor<question_t, size_t, size_t, size_t>(),
-      (Rice::Arg("id"), Rice::Arg("tid"), Rice::Arg("difficulty")))
+    .define_constructor(Rice::Constructor<question_t, size_t, size_t, size_t, std::string>(),
+      (Rice::Arg("id"), Rice::Arg("tid"), Rice::Arg("difficulty"), Rice::Arg("text")))
     .define_method("question_id", &question_t::get_question_id)
-    .define_method("theme_id", &question_t::get_theme_id)
-    .define_method("difficulty", &question_t::get_difficulty);
+    .define_method("topic_id", &question_t::get_topic_id)
+    .define_method("difficulty", &question_t::get_difficulty)
+    .define_method("text", &question_t::get_text);
 
   Rice::Data_Type<generator_t> rb_cGenerator = Rice::define_class_under<generator_t>(rb_mTasksGenerator, "Generator")
-    .define_constructor(Rice::Constructor<generator_t, config_t, std::vector<question_t>>(),
-      (Rice::Arg("cnf"), Rice::Arg("questions")))
-    .define_method("config", &generator_t::get_config)
-    .define_method("questions", &generator_t::get_questions)
+    .define_constructor(Rice::Constructor<generator_t, config_t, std::vector<topic_t>, std::vector<question_t>>(),
+      (Rice::Arg("cnf"), Rice::Arg("topics"), Rice::Arg("questions")))
     .define_method("generate", &generator_t::generate);
 }

data/ext/tasks_generator/config.h

@@ -1,43 +1,79 @@
 #pragma once
 
-#include "theme.h"
-#include "types.h"
+#include <iostream>
+#include <unordered_map>
 
-namespace tasks_generator {
+namespace ailab {
 
 struct config_t {
   size_t life_time;
-  double mutation_chance;
+  size_t try_generate;
   size_t population_size;
+  double mutation_chance;
+  double mutation_duplicate_chance;
+  bool log_enabled;
+  bool stat_enabled;
 
-  size_t tasks;
+  size_t variants_count;
+  size_t questions_count;
 
-  std::vector<theme_t> themes;
+  std::vector<size_t> topics;
 
-  config_t(config_t const &cnf) :
-      life_time(cnf.life_time),
-      mutation_chance(cnf.mutation_chance),
-      population_size(cnf.population_size),
-      tasks(cnf.tasks),
-      themes(cnf.themes) {
+  config_t(size_t v_count = 8, size_t q_count = 8) noexcept :
+      life_time(200),
+      try_generate(10),
+      population_size(100),
+      mutation_chance(0.01),
+      mutation_duplicate_chance(0.03),
+      log_enabled(false),
+      stat_enabled(false),
+      variants_count(v_count),
+      questions_count(q_count),
+      topics() {
   }
 
-  explicit config_t(size_t tasks = 0) :
-      life_time(1000),
-      mutation_chance(0.05),
-      population_size(1000),
-      tasks(tasks),
-      themes() {
+  config_t(std::unordered_map<std::string, std::string> const &map) noexcept :
+      config_t() {
+    if (map.find("life-time") != map.end())
+      life_time = std::stoul(map.at("life-time"));
+    if (map.find("population-size") != map.end())
+      population_size = std::stoul(map.at("population-size"));
+    if (map.find("mutation-chance") != map.end())
+      mutation_chance = std::stod(map.at("mutation-chance"));
+    if (map.find("log-enabled") != map.end())
+      log_enabled = true;
+    if (map.find("variants-count") != map.end())
+      variants_count = std::stoul(map.at("variants-count"));
+    if (map.find("questions-count") != map.end())
+      questions_count = std::stoul(map.at("questions-count"));
+    if (map.find("stat-enabled") != map.end())
+      stat_enabled = true;
+    if (map.find("mutation-duplicate-chance") != map.end())
+      mutation_duplicate_chance = std::stod(map.at("mutation-duplicate-chance"));
+    if (map.find("try-generate") != map.end())
+      try_generate = std::stod(map.at("try-generate"));
   }
+};
 
-  config_t &operator = (config_t const &cnf) {
-    life_time = cnf.life_time;
-    mutation_chance = cnf.mutation_chance;
-    population_size = cnf.population_size;
-    tasks = cnf.tasks;
-    themes = cnf.themes;
-    return *this;
+std::ostream& operator << (std::ostream& out, config_t const &config) {
+  out << "config.life_time = " << config.life_time << std::endl;
+  out << "config.population_size = " << config.population_size << std::endl;
+  out << "config.mutation_chance = " << config.mutation_chance << std::endl;
+  out << "config.mutation_duplicate_chance = " << config.mutation_duplicate_chance << std::endl;
+  out << "config.log_enabled = " << config.log_enabled << std::endl;
+  out << "config.stat_enabled = " << config.stat_enabled << std::endl;
+  out << "config.variants_count = " << config.variants_count << std::endl;
+  out << "config.questions_count = " << config.questions_count << std::endl;
+  out << "config.try_generate = " << config.try_generate << std::endl;
+  out << "config.topics = ";
+  for (size_t i = 0; i < config.topics.size(); ++i) {
+    out << config.topics[i];
+    if (i + 1 != config.topics.size())
+      out << ", ";
   }
-};
+  out << std::endl;
+
+  return out;
+}
 
 }

data/ext/tasks_generator/generator.h

@@ -1,42 +1,185 @@
 #pragma once
 
-#include "function.h"
+#include <vector>
+
+#include "config.h"
 #include "question.h"
-#include "types.h"
+#include "question_shaker.h"
+#include "topic.h"
+#include "variants.h"
 
-namespace tasks_generator {
+namespace ailab {
 
 class generator_t {
+  struct stat_t {
+    size_t mutations_count;
+    size_t mutations_attempts;
+    size_t mutation_duplicate_count;
+    size_t mutation_duplicate_attempts;
+    size_t tried_generate;
+    double first_fitness_function;
+    double best_fitness_function;
+
+    stat_t() :
+        mutations_count(0),
+        mutations_attempts(0),
+        mutation_duplicate_count(0),
+        mutation_duplicate_attempts(0),
+        tried_generate(0),
+        first_fitness_function(0),
+        best_fitness_function(0) {
+    }
+  };
+
+  mutable stat_t stat;
+
   config_t config;
+  std::vector<topic_t> topics;
   std::vector<question_t> questions;
 
-public:
-  typedef std::vector<std::vector<question_t>> answer_t;
+  std::vector<variants_t> generate_population(question_shaker_t const &shaker) const {
+    std::vector<variants_t> result;
+
+    for (size_t k = 0; k < config.population_size; ++k) {
+      result.push_back(variants_t(config));
+      for (size_t i = 0; i < config.variants_count; ++i) {
+        for (size_t j = 0; j < config.questions_count; ++j) {
+          size_t r = rand() % config.topics.size();
+          result[k][i].push_back(shaker.get_question(config.topics[r]));
+        }
+      }
+    }
 
-  generator_t(generator_t const &t) :
-      config(t.config),
-      questions(t.questions) {
+    return result;
   }
 
-  generator_t(config_t const &config, std::vector<question_t> const &questions) :
-      config(config),
-      questions(questions) {
+  void crossover(std::vector<variants_t> &population) const noexcept {
+    std::sort(population.begin(), population.end(), [] (variants_t const &a, variants_t const &b) -> bool {
+      return a.calculate_fitness_function() > b.calculate_fitness_function();
+    });
+    size_t population_size = population.size();
+    for (size_t i = 0; i + 1 < population_size; i += 2)
+      population.push_back(population[i].crossover(population[i + 1]));
+    for (size_t i = 0; i * 2 < population_size; ++i) {
+      size_t r = rand() % (population_size - i) + i;
+      population.push_back(population[i].crossover(population[r]));
+    }
+  }
+
+  void mutation(std::vector<variants_t> &population, question_shaker_t const &shaker) const {
+    size_t population_size = population.size();
+    for (size_t i = 0; i < population_size; ++i) {
+      bool b = (1 + rand() % 100) <= 100 * config.mutation_duplicate_chance;
+      ++stat.mutation_duplicate_attempts;
+      if (b) {
+        population.push_back(population[i]);
+        ++stat.mutation_duplicate_count;
+      }
+      for (size_t j = 0; j < population[i].size(); ++j)
+        for (size_t k = 0; k < population[i][j].size(); ++k) {
+          bool b = (1 + rand() % 100) <= 100 * config.mutation_chance;
+          ++stat.mutations_attempts;
+          if (b) {
+            size_t r = rand() % config.topics.size();
+            population[i][j][k] = shaker.get_question(config.topics[r]);
+            ++stat.mutations_count;
+          }
+        }
+    }
+  }
+
+  void selection(std::vector<variants_t> &population) const noexcept {
+    std::sort(population.begin(), population.end(), [] (variants_t const &a, variants_t const &b) -> bool {
+      return a.calculate_fitness_function() > b.calculate_fitness_function();
+    });
+    std::random_shuffle(population.begin() + config.population_size / 2, population.end());
+    population.resize(config.population_size + config.population_size / 2);
+  }
+
+  variants_t best(std::vector<variants_t> &population) const noexcept {
+    std::sort(population.begin(), population.end(), [] (variants_t const &a, variants_t const &b) -> bool {
+      return a.calculate_fitness_function() > b.calculate_fitness_function();
+    });
+    return population.front();
   }
 
-  generator_t(config_t &&config, std::vector<question_t> &&questions) :
-      config(config),
-      questions(std::move(questions)) {
+  void strong_mutation(std::vector<variants_t> &population, question_shaker_t const &shaker) const noexcept {
+    for (variants_t &v : population)
+      v.strong_mutation(shaker);
   }
 
-  config_t get_config() const {
-    return config;
+  bool good_result(variants_t const &v) const noexcept {
+    for (size_t i = 0; i < v.size(); ++i) {
+      std::unordered_set<size_t> counter;
+      for (size_t j = 0; j < v[i].size(); ++j)
+        counter.insert(v[i][j].get_question_id());
+      if (counter.size() < v[i].size())
+        return false;
+    }
+    return true;
   }
 
-  std::vector<question_t> const &get_questions() const {
-    return questions;
+ public:
+  generator_t(config_t const &cnf, std::vector<topic_t> const &topics, std::vector<question_t> const &questions) noexcept :
+      config(cnf),
+      topics(topics),
+      questions(questions) {
+  }
+
+  generator_t(config_t &&cnf, std::vector<topic_t> &&topics, std::vector<question_t> &&questions) noexcept :
+      config(cnf),
+      topics(topics),
+      questions(questions) {
+  }
+
+  generator_t(generator_t const &other) noexcept :
+      config(other.config),
+      topics(other.topics),
+      questions(other.questions) {
   }
 
-  answer_t generate() const;
+  variants_t generate() {
+    ++stat.tried_generate;
+
+    question_shaker_t shaker(topics, questions);
+    std::vector<variants_t> population = generate_population(shaker);
+
+    variants_t result = best(population);
+    stat.best_fitness_function = stat.first_fitness_function = result.calculate_fitness_function();
+
+    for (size_t current_time = 1; current_time <= config.life_time; ++current_time) {
+      crossover(population);
+      selection(population);
+      mutation(population, shaker);
+      strong_mutation(population, shaker);
+      
+      if (config.log_enabled)
+        std::cerr << current_time << '\t' << result.calculate_fitness_function() << std::endl;
+
+      variants_t buf = best(population);
+      if (buf.calculate_fitness_function() > result.calculate_fitness_function()) {
+        result = buf;
+        stat.best_fitness_function = result.calculate_fitness_function();
+      }
+    }
+
+    if (good_result(result) || stat.tried_generate == config.try_generate) {
+      if (config.stat_enabled) {
+        std::cerr << std::endl;
+        std::cerr << "stat.tried_generate = " << stat.tried_generate << std::endl;
+        std::cerr << "stat.mutations_attempts = " << stat.mutations_attempts << std::endl;
+        std::cerr << "stat.mutations_count = " << stat.mutations_count << std::endl;
+        std::cerr << "stat.mutation_duplicate_attempts = " << stat.mutation_duplicate_attempts << std::endl;
+        std::cerr << "stat.mutation_duplicate_count = " << stat.mutation_duplicate_count << std::endl;
+        std::cerr << "stat.first_fitness_function = " << stat.first_fitness_function << std::endl;
+        std::cerr << "stat.best_fitness_function = " << stat.best_fitness_function << std::endl;
+        std::cerr << std::endl;
+      }
+      return result;
+    } else {
+      return generate();
+    }
+  }
 };
 
 }

data/ext/tasks_generator/question.h

@@ -2,50 +2,42 @@
 
 #include <string>
 
-namespace tasks_generator {
+namespace ailab {
 
 class question_t {
-  size_t question_id, theme_id, difficulty;
+  size_t question_id, topic_id, difficulty, select_id;
+  std::string text;
 
-public:
-  question_t() :
-      question_id(0),
-      theme_id(0),
-      difficulty(0) {
+ public:
+  question_t(size_t question_id, size_t topic_id, size_t difficulty, std::string const text = "") noexcept :
+      question_id(question_id),
+      topic_id(topic_id),
+      difficulty(difficulty),
+      text(text) {
   }
 
-  question_t(size_t qid, size_t tid, size_t difficulty) :
-      question_id(qid),
-      theme_id(tid),
-      difficulty(difficulty) {
+  void set_select_id(size_t x) noexcept {
+    select_id = x;
   }
 
-  size_t get_difficulty() const {
-    return difficulty;
+  size_t get_select_id() const noexcept {
+    return select_id;
   }
 
-  size_t get_question_id() const {
+  size_t get_question_id() const noexcept {
     return question_id;
   }
 
-  size_t get_theme_id() const {
-    return theme_id;
-  }
-
-  bool operator == (question_t const &q) const {
-    return question_id == q.question_id;
+  size_t get_topic_id() const noexcept {
+    return topic_id;
   }
 
-  static bool theme_id_cmp(question_t const &a, question_t const &b) {
-    return a.theme_id < b.theme_id;
-  }
-
-  static bool difficulty_cmp(question_t const &a, question_t const &b) {
-    return a.difficulty < b.difficulty;
+  size_t get_difficulty() const noexcept {
+    return difficulty;
   }
 
-  static bool difficulty_size_t_cmp(question_t const &a, size_t d) {
-    return a.difficulty < d;
+  std::string const &get_text() const noexcept {
+    return text;
   }
 };
 

data/ext/tasks_generator/question_shaker.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <algorithm>
+#include <cstdlib>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "topic.h"
+#include "question.h"
+
+namespace ailab {
+
+// TODO: make it without O(n^2) size
+class question_shaker_t {
+  std::unordered_map<size_t, topic_t> topics;
+  std::unordered_map<size_t, std::vector<question_t>> questions;
+
+  void dfs(size_t u, std::unordered_map<size_t, std::vector<size_t>> const &g, std::unordered_set<size_t> &used) noexcept {
+    used.insert(u);
+    if (g.find(u) == g.end())
+      return;
+    for (size_t i = 0; i < g.at(u).size(); ++i) {
+      size_t v = g.at(u)[i];
+      if (used.find(v) == used.end()) {
+        dfs(v, g, used);
+        for (question_t const &q : questions[v])
+          questions[u].push_back(q);
+      }
+    }
+  }
+
+ public:
+  question_shaker_t(std::vector<topic_t> const &t, std::vector<question_t> const &q) noexcept {
+    for (question_t const &question : q)
+      questions[question.get_topic_id()].push_back(question);
+    for (topic_t const &topic : t)
+      topics[topic.get_topic_id()] = topic;
+    std::unordered_map<size_t, std::vector<size_t>> g;
+    std::unordered_set<size_t> used;
+    for (topic_t const &topic : t)
+      if (topic.get_parent_id() != 0)
+        g[topic.get_parent_id()].push_back(topic.get_topic_id());
+    for (topic_t const &topic : t)
+      if (used.find(topic.get_topic_id()) == used.end())
+        dfs(topic.get_topic_id(), g, used);
+    for (auto &p : questions)
+      std::random_shuffle(p.second.begin(), p.second.end());
+    srand(time(0));
+  }
+
+  question_t get_question(size_t topic_id) const {
+    if (questions.at(topic_id).empty())
+      throw std::logic_error("Not enough questions for topic");
+    size_t r = rand() % questions.at(topic_id).size();
+    question_t result = questions.at(topic_id)[r];
+    result.set_select_id(topic_id);
+    return result;
+  }
+};
+
+}

data/ext/tasks_generator/topic.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+namespace ailab {
+
+class topic_t {
+  size_t topic_id, parent_id;
+  std::string text;
+
+ public:
+  topic_t(size_t topic_id = 0, size_t parent_id = 0, std::string const &text = "") noexcept :
+      topic_id(topic_id),
+      parent_id(parent_id),
+      text(text) {
+  }
+
+  size_t get_topic_id() const noexcept {
+    return topic_id;
+  }
+
+  size_t get_parent_id() const noexcept {
+    return parent_id;
+  }
+
+  std::string const &get_text() const noexcept {
+    return text;
+  }
+};
+
+}

data/ext/tasks_generator/variants.h

@@ -0,0 +1,200 @@
+#pragma once
+
+#include <vector>
+
+#include "question.h"
+
+namespace ailab {
+
+class variants_t {
+  mutable double fitness;
+  mutable bool changed;
+
+  config_t const &config;
+
+  size_t questions_count;
+  std::vector<std::vector<question_t>> questions;
+
+ public:
+  variants_t(config_t const &config = config_t()) noexcept :
+      fitness(0),
+      changed(true),
+      config(config),
+      questions(config.variants_count) {
+  }
+
+  variants_t(variants_t const &v) noexcept :
+      fitness(v.fitness),
+      changed(v.changed),
+      config(v.config),
+      questions(v.questions) {
+  }
+
+  variants_t(variants_t &&v) noexcept :
+      config(v.config) {
+    std::swap(fitness, v.fitness);
+    std::swap(changed, v.changed);
+    std::swap(questions, v.questions);
+  }
+
+  variants_t &operator = (variants_t &&v) noexcept {
+    std::swap(fitness, v.fitness);
+    std::swap(changed, v.changed);
+    std::swap(questions, v.questions);
+
+    return *this;
+  }
+
+  variants_t &operator = (variants_t const &v) noexcept {
+    fitness = v.fitness;
+    changed = v.changed;
+    questions = v.questions;
+    
+    return *this;
+  }
+  
+  void push_back(std::vector<question_t> const &q) noexcept {
+    questions.push_back(q);
+  }
+
+  size_t size() const noexcept {
+    return questions.size();
+  }
+
+  std::vector<std::vector<question_t>>::iterator begin() noexcept {
+    return questions.begin();
+  }
+
+  std::vector<std::vector<question_t>>::iterator end() noexcept {
+    return questions.end();
+  }
+
+  double calculate_fitness_function() const noexcept {
+    if (!changed) 
+      return fitness;
+    size_t questions_count = 0;
+    for (auto const &v : questions)
+      questions_count += v.size();
+    {
+      size_t buffer[questions_count];
+      for (size_t i = 0; i < questions.size(); ++i)
+        for (size_t j = 0; j < questions[i].size(); ++j)
+          buffer[i * config.questions_count + j] = questions[i][j].get_question_id();
+      std::sort(buffer, buffer + questions_count);
+      size_t count = 1;
+      for (size_t i = 1; i < questions_count; ++i)
+        count += buffer[i] != buffer[i - 1];
+      fitness = double(count) / questions_count;
+    }
+    {
+      for (size_t i = 0; i < questions.size(); ++i) {
+        size_t buffer[questions[i].size()];
+        for (size_t j = 0; j < questions[i].size(); ++j)
+          buffer[j] = questions[i][j].get_question_id();
+        std::sort(buffer, buffer + questions[i].size());
+        size_t count = 1;
+        for (size_t j = 1; j < questions[i].size(); ++j)
+          count += buffer[j] != buffer[j - 1];
+        fitness += count == questions[i].size();
+      }
+    }
+    {
+      for (size_t i = 0; i < questions.size(); ++i) {
+        size_t buffer[questions[i].size()];
+        for (size_t j = 0; j < questions[i].size(); ++j)
+          buffer[j] = questions[i][j].get_select_id();
+        std::sort(buffer, buffer + questions[i].size());
+        size_t count = 1;
+        for (size_t j = 1; j < questions[i].size(); ++j)
+          count += buffer[j] != buffer[j - 1];
+        fitness += double(count) / questions[i].size();
+      }
+    }
+    {
+      double buffer[questions_count];
+      for (size_t i = 0; i < questions.size(); ++i)
+        for (size_t j = 0; j < questions[i].size(); ++j)
+          buffer[i * config.questions_count + j] = questions[i][j].get_difficulty();
+      double avg = 0;
+      for (size_t i = 0; i < questions_count; ++i)
+        avg += buffer[i];
+      avg /= questions_count;
+      double x = 0;
+      for (size_t i = 0; i < questions_count; ++i)
+        x += (buffer[i] - avg) * (buffer[i] - avg);
+      x /= questions_count;
+      x = sqrt(x);
+      fitness += x;
+    }
+    {
+      for (size_t i = 0; i < questions.size(); ++i) {
+        size_t buffer[questions[i].size()];
+        for (size_t j = 0; j < questions[i].size(); ++j)
+          buffer[j] = questions[i][j].get_select_id();
+        std::sort(buffer, buffer + questions[i].size());
+        size_t count = 1;
+        for (size_t j = 1; j < questions[i].size(); ++j)
+          count += buffer[j] != buffer[j - 1];
+        std::pair<size_t, size_t> counter[count];
+        ssize_t k = -1;
+        for (size_t j = 0; j < questions[i].size(); ++j) {
+          if (k == -1 || buffer[j] != counter[k].first) {
+            ++k;
+            counter[k].second = 0;
+          }
+          ++counter[k].second;
+        }
+        std::sort(counter, counter + count, [] (std::pair<size_t, size_t> const &a, std::pair<size_t, size_t> const &b) -> bool {
+          return a.second > b.second;
+        });
+        double x = 0;
+        for (size_t j = 1; j < count; ++j)
+          x += counter[j].second / counter[j - 1].second;
+        fitness += x;
+      }
+    }
+    changed = false;
+    return fitness;
+  }
+
+  variants_t crossover(variants_t const &v) const noexcept {
+    variants_t result(*this);
+    size_t questions_count = 0;
+    for (auto const &v : questions)
+      questions_count += v.size();
+    size_t to_swap = rand() % questions_count;
+    for (size_t i = 0; i < result.questions.size() && to_swap; ++i)
+      for (size_t j = 0; j < result.questions[i].size() && to_swap; ++j, --to_swap)
+        result.questions[i][j] = v.questions[i][j];
+    return result;
+  }
+
+  std::vector<question_t> &operator [] (size_t i) noexcept {
+    changed = true;
+    return questions[i];
+  }
+
+  std::vector<question_t> const &operator [] (size_t i) const noexcept {
+    return questions[i];
+  }
+
+  void strong_mutation(question_shaker_t const &shaker) noexcept {
+    for (std::vector<question_t> &q : *this) {
+      std::sort(q.begin(), q.end(), [] (question_t const &a, question_t const &b) -> bool {
+        return a.get_question_id() < b.get_question_id();
+      });
+      for (size_t i = 1; i < q.size(); ++i) {
+        if (q[i].get_question_id() == q[i - 1].get_question_id()) {
+          size_t r = rand() % config.topics.size();
+          q[i - 1] = shaker.get_question(config.topics[r]);
+        }
+      }
+    }
+  }
+
+  std::vector<std::vector<question_t>> const &get_questions() const noexcept {
+    return questions;
+  }
+};
+
+}

data/lib/tasks_generator/version.rb

@@ -1,3 +1,3 @@
 module TasksGenerator
-  VERSION = "0.5"
+  VERSION = "1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tasks_generator
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '1.0'
 platform: ruby
 authors:
 - Arslan Urtashev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2014-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,28 +28,28 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rice
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Test Tasks Generator for AI lab MEPhI
@@ -67,13 +67,11 @@ files:
 - ext/tasks_generator/bindings.cc
 - ext/tasks_generator/config.h
 - ext/tasks_generator/extconf.rb
-- ext/tasks_generator/function.cc
-- ext/tasks_generator/function.h
-- ext/tasks_generator/generator.cc
 - ext/tasks_generator/generator.h
 - ext/tasks_generator/question.h
-- ext/tasks_generator/theme.h
-- ext/tasks_generator/types.h
+- ext/tasks_generator/question_shaker.h
+- ext/tasks_generator/topic.h
+- ext/tasks_generator/variants.h
 - lib/tasks_generator.rb
 - lib/tasks_generator/version.rb
 - tasks_generator.gemspec
@@ -87,17 +85,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: Test Tasks Generator

data/ext/tasks_generator/function.cc

@@ -1,147 +0,0 @@
-#include <algorithm>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <cassert>
-#include <cstdlib>
-
-#include "function.h"
-#include "question.h"
-
-namespace tasks_generator {
-
-population_t generate_population(config_t const &config, std::vector<question_t> const &questions) {
-
-  std::unordered_map<theme_id_t, std::vector<question_t>> all_questions;
-  for (question_t const &question : questions)
-    all_questions[question.get_theme_id()].push_back(question);
-  for (std::pair<theme_id_t const, std::vector<question_t>> &q : all_questions)
-    std::sort(q.second.begin(), q.second.end(), question_t::difficulty_cmp);
-
-  population_t population(config.population_size);
-
-  srand((unsigned int)time(0));
-
-  for (individual_t &individual : population) {
-    individual = individual_t(config.tasks, task_t(config.themes.size()));
-
-    for (task_t &task : individual) {
-      task = task_t(config.themes.size());
-
-      std::unordered_set<question_id_t> used;
-
-      for (size_t i = 0; i < task.size(); ++i) {
-        std::vector<question_t> const &candidates = all_questions[config.themes[i].get_theme_id()];
-
-        std::vector<question_t>::const_iterator lower = std::lower_bound(
-          candidates.begin(),
-          candidates.end(),
-          config.themes[i].get_difficulty_min(),
-          question_t::difficulty_size_t_cmp
-        );
-
-        size_t unused_count = 0;
-        std::vector<question_t>::const_iterator it = lower;
-        while (it != candidates.end() && it->get_difficulty() <= config.themes[i].get_difficulty_max()) {
-          if (used.find(it->get_question_id()) == used.end())
-            ++unused_count;
-          ++it;
-        }
-
-        if (unused_count == 0)
-          throw std::logic_error("hasn't questions for generate test");
-
-        size_t pos = rand() % unused_count;
-
-        it = lower;
-        while (pos > 0 || used.find(it->get_question_id()) != used.end()) {
-          if (used.find(it->get_question_id()) == used.end())
-            --pos;
-          ++it;
-        }
-
-        task[i] = *it;
-        used.insert(it->get_question_id());
-      }
-    }
-  }
-
-  return population;
-}
-
-static double fitness(individual_t const &individual) {
-  double s = 0, sqrs = 0;
-  for (task_t const &task : individual) {
-    double avg = 0;
-    for (question_t const &question : task)
-      avg += question.get_difficulty();
-    avg /= task.size();
-    s += avg;
-    sqrs += avg * avg;
-  }
-  double d = (sqrs - s * s / individual.size()) / individual.size();
-  double metric_one = (d > 0 ? 1.0 / d + 1.0 : 2);
-
-  std::unordered_set<size_t> uniqs;
-  for (task_t const &task : individual)
-    for (question_t const &question : task)
-      uniqs.insert(question.get_question_id());
-
-  return metric_one * uniqs.size(); // FIXME: add diff metric
-}
-
-static individual_t crossover(individual_t const &a, individual_t const &b) {
-  // FIXME: change this crossover
-  assert(a.size() == b.size());
-  individual_t res;
-  size_t to = rand() % a.size();
-  for (size_t i = 0; i < to; ++i)
-    res.push_back(a[i]);
-  for (size_t i = to; i < b.size(); ++i)
-    res.push_back(b[i]);
-  return res;
-}
-
-static void sort_by_fitness(population_t &population) {
-  std::vector<std::pair<double, size_t>> buf(population.size());
-  for (size_t i = 0; i < population.size(); ++i) {
-    buf[i].first = fitness(population[i]);
-    buf[i].second = i;
-  }
-  std::sort(buf.begin(), buf.end());
-  for (size_t i = 0; i < population.size(); ++i)
-    std::swap(population[i], population[buf[i].second]);
-}
-
-individual_t best(population_t &population) {
-  assert(!population.empty());
-  sort_by_fitness(population);
-  return population.front();
-}
-
-void selection(config_t const &config, population_t &population) {
-  // FIXME: make selection better
-  sort_by_fitness(population);
-  population.resize(config.population_size);
-}
-
-void recombination(config_t const &config, population_t &population) {
-  if (population.empty())
-    throw std::logic_error("population is empty");
-  std::vector<individual_t> newbies;
-  for (size_t i = 0; i < population.size(); ++i) {
-    size_t pos = i + rand() % (population.size() - i);
-    std::swap(population[i], population[pos]);
-  }
-  for (size_t i = 0; i < population.size(); i += 2) {
-    newbies.push_back(crossover(population[i], population[i + 1]));
-  }
-  for (size_t i = 0; i < newbies.size(); ++i)
-    population.emplace_back(std::move(newbies[i]));
-}
-
-void mutation(config_t const &, population_t &) {
-}
-
-}

data/ext/tasks_generator/function.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <vector>
-
-#include "config.h"
-#include "question.h"
-#include "types.h"
-
-namespace tasks_generator {
-
-population_t generate_population(config_t const &config, std::vector<question_t> const &questions);
-
-individual_t best(population_t &population);
-
-void selection(config_t const &config, population_t &population);
-
-void recombination(config_t const &config, population_t &population);
-
-void mutation(config_t const &config, population_t &population);
-
-}

data/ext/tasks_generator/generator.cc

@@ -1,23 +0,0 @@
-#include <vector>
-
-#include "generator.h"
-
-#include "function.h"
-#include "question.h"
-#include "types.h"
-
-namespace tasks_generator {
-
-generator_t::answer_t generator_t::generate() const {
-  population_t population = generate_population(config, questions);
-
-  for (size_t current_time = 0; current_time < config.life_time; ++current_time) {
-    selection(config, population);
-    recombination(config, population);
-    mutation(config, population);
-  }
-
-  return best(population);
-}
-
-}

data/ext/tasks_generator/theme.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include "question.h"
-
-namespace tasks_generator {
-
-class theme_t {
-  size_t theme_id, difficulty_min, difficulty_max;
-
- public:
-  theme_t(size_t tid, size_t dmin, size_t dmax) :
-      theme_id(tid), 
-      difficulty_min(dmin),
-      difficulty_max(dmax) {
-  }
-
-  theme_t(theme_t const &th) :
-      theme_id(th.theme_id),
-      difficulty_min(th.difficulty_min),
-      difficulty_max(th.difficulty_max) {
-  }
-
-  size_t get_theme_id() const {
-    return theme_id;
-  }
-
-  size_t get_difficulty_min() const {
-    return difficulty_min;
-  }
-
-  size_t get_difficulty_max() const {
-    return difficulty_max;
-  }
-
-  bool operator == (theme_t const &t) const {
-    return theme_id == t.theme_id &&
-      difficulty_min == t.difficulty_min &&
-      difficulty_max == t.difficulty_max;
-  }
-};
-
-}

data/ext/tasks_generator/types.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include <vector>
-
-#include "question.h"
-
-#define __unsed __attribute__((unused))
-
-namespace tasks_generator {
-
-typedef std::vector<question_t> task_t;
-typedef std::vector<task_t> individual_t;
-typedef std::vector<individual_t> population_t;
-
-typedef size_t theme_id_t;
-typedef size_t question_id_t;
-
-}