tasks_generator 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e91eff44e7a87a65e00fd652886107421d5fc84
+  data.tar.gz: 4b720339ea6cadbc50fd3b729821f86de4f90838
+SHA512:
+  metadata.gz: 37d7779c7e40e8dda51dd55703f449e3b590b3c0f632611f6e4136a31d359cac8944fbcf9ecf878936e5235af4616b4bdd4d629105280b313c18e38db2073248
+  data.tar.gz: 8755e7db35aac4d84e648fb77c10ea705b1cec784f4ef271cfd1de68f8274c0665029ae51c10363690fc8a8cce41be58201cfc547a7b7125672edde8c32536f2

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tasks_generator.gemspec
+gemspec
+rake
+rice

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Arslan Urtashev
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# TasksGenerator
+
+Test tasks generator for AI lab MEPhI
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tasks_generator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tasks_generator
+
+## Usage
+
+### TasksGenerator::Config
+Config for configure Generator
+* life_time - iterations count for genetic algorithm (default: 1000)
+* mutation_chance - mutation chance (default: 0.05)
+* population_size - starting population (default: 1000)
+* tasks - tasks count
+* themes - array of Theme
+
+### TasksGenerator::Theme
+Theme class for config.themes  
+* theme_id
+* difficulty_min
+* difficulty_max
+
+### TasksGenerator::Question
+Question class for questions in Generator constructor
+* question_id
+* theme_id
+* difficulty
+
+### Tasks::Generator::Generator
+Test tasks generator
+* generate() - this method returns array of questions
+
+## Contributing
+
+1. Fork it ( https://github.com/Abitella/tasks_generator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+# coding: utf-8
+
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+
+spec = Gem::Specification.load("tasks_generator.gemspec")
+
+Rake::ExtensionTask.new("tasks_generator", spec) do |ext|
+  ext.lib_dir = "lib/tasks_generator"
+end

data/ext/tasks_generator/bindings.cc

@@ -0,0 +1,200 @@
+#include "rice/Array.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Object.hpp"
+
+#include "config.h"
+#include "generator.h"
+#include "question.h"
+#include "theme.h"
+
+using namespace tasks_generator;
+
+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 d = from_ruby<size_t>(obj.call("difficulty"));
+
+  return question_t(qid, tid, d);
+}
+
+template<>
+Rice::Object to_ruby(question_t const &q) {
+  return Rice::Data_Object<question_t>(new question_t(q));
+}
+
+template<>
+std::vector<question_t> from_ruby<std::vector<question_t>>(Rice::Object obj) {
+  Rice::Array arr(obj);
+
+  std::vector<question_t> res;
+  res.reserve(arr.size());
+
+  for (Rice::Object o : arr)
+    res.push_back(from_ruby<question_t>(o));
+
+  return res;
+}
+
+template<>
+Rice::Object to_ruby(std::vector<question_t> const &questions) {
+  Rice::Array arr;
+  for (question_t const &q : questions)
+    arr.push(to_ruby(q));
+  return arr;
+}
+
+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"));
+
+  return theme_t(id, dmin, dmax);
+}
+
+template<>
+Rice::Object to_ruby<theme_t>(theme_t const &th) {
+  return Rice::Data_Object<theme_t>(new theme_t(th)); 
+}
+
+template<>
+std::vector<theme_t> from_ruby<std::vector<theme_t>>(Rice::Object obj) {
+  Rice::Array arr(obj);
+
+  std::vector<theme_t> themes;
+  themes.reserve(arr.size());
+
+  for (Rice::Object obj : arr)
+    themes.push_back(from_ruby<theme_t>(obj));
+
+  return themes;
+}
+
+void set_life_time(Rice::Object obj, size_t life_time) {
+  Rice::Data_Object<config_t>(obj)->life_time = life_time;
+}
+
+size_t get_life_time(Rice::Object obj) {
+  return Rice::Data_Object<config_t>(obj)->life_time; 
+}
+
+void set_mutation_chance(Rice::Object obj, double mutation_chance) {
+  Rice::Data_Object<config_t>(obj)->mutation_chance = mutation_chance;
+}
+
+double get_mutation_chance(Rice::Object obj) {
+  return Rice::Data_Object<config_t>(obj)->mutation_chance;
+}
+
+void set_population_size(Rice::Object obj, size_t population_size) {
+  Rice::Data_Object<config_t>(obj)->population_size = population_size;
+}
+
+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;
+}
+
+size_t get_tasks(Rice::Object obj) {
+  return Rice::Data_Object<config_t>(obj)->tasks;
+}
+
+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);
+}
+
+Rice::Array get_themes(Rice::Object obj) {
+  std::vector<theme_t> const &themes = Rice::Data_Object<config_t>(obj)->themes;
+
+  Rice::Array arr;
+  for (theme_t const &t : themes)
+    arr.push(to_ruby<theme_t>(t));
+
+  return arr;
+}
+
+template<>
+config_t from_ruby<config_t>(Rice::Object obj) {
+  config_t result;
+  
+  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"));
+
+  return result;
+}
+
+template<>
+Rice::Object to_ruby<config_t>(config_t const &cnf) {
+  return Rice::Data_Object<config_t>(new config_t(cnf));
+}
+
+template<>
+generator_t from_ruby<generator_t>(Rice::Object obj) {
+  config_t config = from_ruby<config_t>(obj.call("config"));
+  std::vector<question_t> questions = from_ruby<std::vector<question_t>>(obj.call("questions"));
+
+  return generator_t(std::move(config), std::move(questions));
+}
+
+template<>
+Rice::Object to_ruby(generator_t const &t) {
+  return Rice::Data_Object<generator_t>(new generator_t(t));
+}
+
+template<>
+Rice::Object to_ruby<generator_t::answer_t>(generator_t::answer_t const &ans) {
+  Rice::Array result;
+  for (std::vector<question_t> const &arr : ans) {
+    Rice::Array buffer;
+    for (question_t const &q : arr)
+      buffer.push(to_ruby<question_t>(q));
+    result.push(buffer);
+  }
+  return result;
+}
+
+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_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("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);
+
+  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_method("question_id", &question_t::get_question_id)
+    .define_method("theme_id", &question_t::get_theme_id)
+    .define_method("difficulty", &question_t::get_difficulty);
+
+  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_method("generate", &generator_t::generate);
+}

data/ext/tasks_generator/config.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "theme.h"
+#include "types.h"
+
+namespace tasks_generator {
+
+struct config_t {
+  size_t life_time;
+  double mutation_chance;
+  size_t population_size;
+
+  size_t tasks;
+
+  std::vector<theme_t> themes;
+
+  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) {
+  }
+
+  explicit config_t(size_t tasks = 0) :
+      life_time(1000),
+      mutation_chance(0.05),
+      population_size(1000),
+      tasks(tasks),
+      themes() {
+  }
+
+  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;
+  }
+};
+
+}

data/ext/tasks_generator/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf-rice'
+
+$CXXFLAGS = '-std=c++0x -O3 -g -Wall -Werror'
+
+create_makefile 'tasks_generator/tasks_generator'

data/ext/tasks_generator/function.cc

@@ -0,0 +1,141 @@
+#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);
+  return metric_one; // 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

@@ -0,0 +1,22 @@
+#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

@@ -0,0 +1,23 @@
+#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/generator.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "function.h"
+#include "question.h"
+#include "types.h"
+
+namespace tasks_generator {
+
+class generator_t {
+  config_t config;
+  std::vector<question_t> questions;
+
+public:
+  typedef std::vector<std::vector<question_t>> answer_t;
+
+  generator_t(generator_t const &t) :
+      config(t.config),
+      questions(t.questions) {
+  }
+
+  generator_t(config_t const &config, std::vector<question_t> const &questions) :
+      config(config),
+      questions(questions) {
+  }
+
+  generator_t(config_t &&config, std::vector<question_t> &&questions) :
+      config(config),
+      questions(std::move(questions)) {
+  }
+
+  config_t get_config() const {
+    return config;
+  }
+
+  std::vector<question_t> const &get_questions() const {
+    return questions;
+  }
+
+  answer_t generate() const;
+};
+
+}

data/ext/tasks_generator/question.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <string>
+
+namespace tasks_generator {
+
+class question_t {
+  size_t question_id, theme_id, difficulty;
+
+public:
+  question_t() :
+      question_id(0),
+      theme_id(0),
+      difficulty(0) {
+  }
+
+  question_t(size_t qid, size_t tid, size_t difficulty) :
+      question_id(qid),
+      theme_id(tid),
+      difficulty(difficulty) {
+  }
+
+  size_t get_difficulty() const {
+    return difficulty;
+  }
+
+  size_t get_question_id() const {
+    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;
+  }
+
+  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;
+  }
+
+  static bool difficulty_size_t_cmp(question_t const &a, size_t d) {
+    return a.difficulty < d;
+  }
+};
+
+}

data/ext/tasks_generator/theme.h

@@ -0,0 +1,42 @@
+#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

@@ -0,0 +1,18 @@
+#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;
+
+}

data/lib/tasks_generator.rb

@@ -0,0 +1,7 @@
+require "tasks_generator/version"
+
+module TasksGenerator
+  # Your code goes here...
+end
+
+require 'tasks_generator/tasks_generator'

data/lib/tasks_generator/version.rb

@@ -0,0 +1,3 @@
+module TasksGenerator
+  VERSION = "0.1"
+end

data/tasks_generator.gemspec

@@ -0,0 +1,29 @@
+# coding utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'tasks_generator/version'
+
+spec = Gem::Specification.new do |spec|
+  spec.name          = "tasks_generator"
+  spec.version       = TasksGenerator::VERSION
+  spec.authors       = ["Arslan Urtashev"]
+  spec.email         = ["urtashev@gmail.com"]
+  spec.summary       = %q{Test Tasks Generator}
+  spec.description   = %q{Test Tasks Generator for AI lab MEPhI}
+  spec.homepage      = 'https://github.com/Avitella/tasks_generator'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rice"
+
+  spec.platform = Gem::Platform::RUBY
+  spec.extensions = %w[ext/tasks_generator/extconf.rb]
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: tasks_generator
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Arslan Urtashev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  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: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Test Tasks Generator for AI lab MEPhI
+email:
+- urtashev@gmail.com
+executables: []
+extensions:
+- ext/tasks_generator/extconf.rb
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- 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
+- lib/tasks_generator.rb
+- lib/tasks_generator/version.rb
+- tasks_generator.gemspec
+homepage: https://github.com/Avitella/tasks_generator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Test Tasks Generator
+test_files: []