mhl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd67377b3670dfd8f235044614d2f4b9965ead18
+  data.tar.gz: a3a98c4c0a8ead65030715cbf0e0f9f24f1d0a3c
+SHA512:
+  metadata.gz: a7dfe8e770e05c0bae580e3e0f21cb9da2accc690b05d19d6e1ce330dcae0e6a54ee3c95630809aabec34c9cc0af8a9befeb7ee1faabbbb87356e809522f2f46
+  data.tar.gz: cd3bb8ce03f86c22250d549251908d7ff2c7eb88b70a9108fe258213686afa7b9024eb0888607feb24031f912769e2073b6436c53ad7af059b90e78b462c8137

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mhl.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mauro Tortonesi
+
+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,71 @@
+#ruby-mhl
+
+A Ruby metaheuristics library
+
+
+## Installation
+
+### Stable version
+
+You can get the stable version of ruby-mhl by installing the mhl gem from
+RubyGems:
+
+    gem install mhl
+
+### Development version
+
+If you want to try the development version of ruby-mhl, instead, just place
+this line:
+
+```ruby
+gem 'mhl', git: 'https://github.com/mtortonesi/ruby-mhl.git'
+```
+
+in your Gemfile and run:
+
+    bundle install
+
+
+## Examples
+
+Here is an example demonstrating how to find the argument that minimizes the
+2-dimension parabola x_1 ^ 2 + x_2 ^ 2 equation with a genetic algorithm:
+
+```ruby
+require 'mhl'
+
+solver = MHL::GeneticAlgorithmSolver.new(
+  :population_size           => 40,
+  :genotype_space_type       => :integer,
+  :mutation_probability      => 0.5,
+  :recombination_probability => 0.5,
+  :genotype_space_conf       => {
+    :dimensions         => 2,
+    :recombination_type => :intermediate,
+    :random_func        => lambda { Array.new(2) { rand(20) } }
+  },
+  :exit_condition => lambda {|generation,best| best[:fitness] == 0}
+)
+solver.solve(Proc.new{|x| -(x[0] ** 2 + x[1] ** 2) })
+```
+
+and with particle swarm optimization:
+
+```ruby
+require 'mhl'
+
+solver = MHL::ParticleSwarmOptimizationSolver.new(
+  :swarm_size           => 40,
+  :random_position_func => lambda { Array.new(2) { rand(20) } },
+  :random_velocity_func => lambda { Array.new(2) { rand(10) } },
+  :exit_condition       => lambda {|generation,best| best[:height].abs < 0.001 },
+)
+solver.solve(Proc.new{|x| -(x[0] ** 2 + x[1] ** 2) })
+```
+
+Other examples and a full documentation will be publised as ruby-mhl matures.
+
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/mhl.rb

@@ -0,0 +1,3 @@
+require 'mhl/version'
+require 'mhl/genetic_algorithm_solver'
+require 'mhl/particle_swarm_optimization_solver'

data/lib/mhl/bitstring_genotype_space.rb

@@ -0,0 +1,84 @@
+require 'bitstring'
+
+module MHL
+
+  # This class implements a genotype with bitstring representation
+  class BitstringGenotypeSpace
+    def initialize(opts)
+      @bitstring_length = opts[:bitstring_length].to_i
+      unless @bitstring_length and @bitstring_length > 0
+        raise ArgumentError, 'Must have positive integer bitstring_length'
+      end
+
+      @random_func = opts[:random_func] || default_random_func(opts[:random_one_to_zero_ratio] || 1.0)
+    end
+
+    def get_random
+      @random_func.call
+    end
+
+    # reproduction with bitflip mutation and one-point crossover
+    def reproduce_from(p1, p2, mutation_rv, recombination_rv)
+      # make copies of p1 and p2
+      # (we're only interested in the :genotype key)
+      c1 = { :genotype => p1[:genotype].dup }
+      c2 = { :genotype => p2[:genotype].dup }
+
+      # mutation comes first
+      bitflip_mutation(c1[:genotype], mutation_rv)
+      bitflip_mutation(c2[:genotype], mutation_rv)
+
+      # and then recombination
+      c1[:genotype], c2[:genotype] =
+        onepoint_crossover(c1[:genotype], c2[:genotype], recombination_rv)
+
+      return c1, c2
+    end
+
+    private
+
+      def bitflip_mutation(bitstring, mutation_rv)
+        # TODO: disable this check in non-debugging mode
+        unless bitstring.length == @bitstring_length
+          raise 'Error! Different bit string sizes!'
+        end
+
+        @bitstring_length.times do |i|
+          if mutation_rv.next < @mutation_threshold
+            bitval       = bitstring[i]
+            bitstring[i] = (bitval == 1 ? '0' : '1')
+          end
+        end
+      end
+
+      def onepoint_crossover(bitstring1, bitstring2, recombination_rv)
+        # TODO: disable this check in non-debugging mode
+        unless bitstring1.length == @bitstring_length and bitstring2.length == @bitstring_length
+          raise 'Error! Different bit string sizes!'
+        end
+
+        if recombination_rv.next < @recombination_threshold
+          size     = bitstring1.length
+          point    = 1 + rand(size - 2)
+          hi_mask  = bitstring1.mask(point, BitString::LOW_END) # lowest point bits
+          low_mask = bitstring1.mask(size - point, BitString::HIGH_END) # highest size-point bits
+          new_b1   = (bitstring1 & hi_mask) | (bitstring2 & low_mask)
+          new_b2   = (bitstring2 & hi_mask) | (bitstring1 & low_mask)
+          return new_b1, new_b2
+        end
+        return bitstring1, bitstring2
+      end
+
+      def default_random_func(one_to_zero_ratio)
+        random_percentage_of_ones = one_to_zero_ratio / (1.0 + one_to_zero_ratio)
+        lambda do
+          str = (0...@bitstring_length).inject("") do |s,i|
+            s << ((rand < random_percentage_of_ones) ? '1' : '0')
+          end
+          BitString.new(str, size)
+        end
+      end
+
+  end
+
+end

data/lib/mhl/genetic_algorithm_solver.rb

@@ -0,0 +1,164 @@
+require 'concurrent'
+require 'erv'
+
+require 'mhl/bitstring_genotype_space'
+require 'mhl/integer_genotype_space'
+
+
+module MHL
+
+  class GeneticAlgorithmSolver
+    def initialize(opts)
+      @population_size = opts[:population_size].to_i
+      unless @population_size and @population_size.even?
+        raise ArgumentError, 'Even population size required!'
+      end
+
+      # perform genotype space-specific configuration
+      case opts[:genotype_space_type]
+      when :integer
+        @genotype_space = IntegerVectorGenotypeSpace.new(opts[:genotype_space_conf])
+
+        begin
+          p_m = opts[:mutation_probability].to_f
+          @mutation_rv = \
+            ERV::RandomVariable.new(:distribution           => :geometric,
+                                    :probability_of_success => p_m)
+        rescue
+          raise ArgumentError, 'Mutation probability configuration is wrong.'
+        end
+
+        begin
+          p_r = opts[:recombination_probability].to_f
+          @recombination_rv = \
+            ERV::RandomVariable.new(:distribution => :uniform,
+                                    :min_value    => -p_r,
+                                    :max_value    => 1.0 + p_r)
+        rescue
+          raise ArgumentError, 'Recombination probability configuration is wrong.'
+        end
+
+      when :bitstring
+        @genotype_space   = BitstringGenotypeSpace.new(opts[:genotype_space_conf])
+        @recombination_rv = ERV::RandomVariable.new(:distribution => :uniform, :max_value => 1.0)
+        @mutation_rv      = ERV::RandomVariable.new(:distribution => :uniform, :max_value => 1.0)
+
+      else
+        raise ArgumentError, 'Only integer and bitstring genotype representations are supported!'
+      end
+
+      @exit_condition   = opts[:exit_condition]
+      @start_population = opts[:genotype_space_conf][:start_population]
+    end
+
+
+    # This is the method that solves the optimization problem
+    #
+    # Parameter func is supposed to be a method (or a Proc, a lambda, or any callable
+    # object) that accepts the genotype as argument (that is, the set of
+    # parameters) and returns the phenotype (that is, the function result)
+    def solve(func)
+      # setup population
+      if @start_population.nil?
+        population = Array.new(@population_size) do
+          # generate random genotype according to the chromosome type
+          { :genotype => @genotype_space.get_random }
+        end
+      else
+        population = @start_population.map do |x|
+          { :genotype => x }
+        end
+      end
+
+      # initialize variables
+      gen = 0
+      overall_best = nil
+
+      # default behavior is to loop forever
+      begin
+        gen += 1
+        puts "Starting generation #{gen} at #{Time.now}"
+
+        # assess fitness for every member of the population
+        population.each do |s|
+          s[:task] = Concurrent::Future.new { func.call(s[:genotype]) }
+        end
+
+        # wait for all the evaluations to end
+        population.each do |s|
+          s[:fitness] = s[:task].value
+        end
+
+        # find fittest member
+        population_best = population.max_by {|x| x[:fitness] }
+
+        # calculate overall best
+        if overall_best.nil?
+          overall_best = population_best
+        else
+          overall_best = [ overall_best, population_best ].max_by {|x| x[:fitness] }
+        end
+
+        # print results
+        puts "> gen #{gen}, best: #{overall_best[:genotype]}, #{overall_best[:fitness]}"
+
+        # selection by binary tournament
+        children = new_generation(population)
+
+        # update population and generation number
+        population = children
+      end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
+    end
+
+
+    private
+
+      # reproduction with point mutation and one-point crossover
+      def new_generation(population)
+        population_size = population.size
+
+        # check correct population size
+        # TODO: disable this check in non-debugging mode
+        raise ArgumentError, 'Population size error!' if population_size != @population_size
+
+        # prepare children
+        children = []
+
+        # select members to reproduce through binary tournament
+        selected = Array.new(@population_size) { |i| binary_tournament(population) }
+        selected.shuffle!
+
+        # reproduction
+        selected.each_slice(2) do |p1, p2|
+          # get two new samples...
+          c1, c2 = @genotype_space.reproduce_from(p1, p2, @mutation_rv, @recombination_rv)
+
+          # ...and add them to the children population
+          children.push(c1, c2)
+
+          # check correct population size
+          # TODO: disable this check in non-debugging mode
+          raise 'Children size error!' if children.size > population_size
+        end
+
+        return children
+      end
+
+      # This method implements binary tournament selection, which is probably
+      # the most popular selection method for genetic algorithms
+      def binary_tournament(population)
+        i = rand(population.size)
+        j = rand(population.size - 1)
+        j += 1 if j >= i
+
+        select_fittest(population[i], population[j])
+      end
+
+      def select_fittest(*a)
+        # TODO: disable this check in non-debugging mode
+        raise 'Attempting to select the fittest sample of an empty population!' if a.empty?
+        a.max_by {|x| x[:fitness] }
+      end
+  end
+
+end

data/lib/mhl/integer_genotype_space.rb

@@ -0,0 +1,106 @@
+module MHL
+
+  # This class implements a genotype with integer space representation
+  class IntegerVectorGenotypeSpace
+    def initialize(opts)
+      @random_func = opts[:random_func]
+
+      @dimensions = opts[:dimensions].to_i
+      unless @dimensions and @dimensions > 0
+        raise ArgumentError, 'Must have positive integer dimensions'
+      end
+
+      # TODO: enable to choose which recombination function to use
+      case opts[:recombination_type].to_s
+      when /intermediate/i
+        @recombination_func = :intermediate_recombination
+      when /line/i
+        @recombination_func = :line_recombination
+      else
+        raise ArgumentError, 'Recombination function must be either line or intermediate!'
+      end
+    end
+
+    def get_random
+      if @random_func
+        @random_func.call
+      else
+        # TODO: implement this
+      end
+    end
+
+    # reproduction with random geometric mutation
+    # and intermediate recombination
+    def reproduce_from(p1, p2, mutation_rv, recombination_rv)
+      # make copies of p1 and p2
+      # (we're only interested in the :genotype key)
+      c1 = { :genotype => p1[:genotype].dup }
+      c2 = { :genotype => p2[:genotype].dup }
+
+      # mutation comes first
+      random_geometric_mutation(c1[:genotype], mutation_rv)
+      random_geometric_mutation(c2[:genotype], mutation_rv)
+
+      # and then recombination
+      send(@recombination_func, c1[:genotype], c2[:genotype], recombination_rv)
+
+      return c1, c2
+    end
+
+
+    private
+
+      def random_geometric_mutation(g, mutation_rv)
+        g.each_index do |i|
+          # being sampled from a geometric distribution, delta will always
+          # be a non-negative integer (that is, 0 or greater)
+          delta = mutation_rv.next
+
+          if rand() >= 0.5
+            # half of the times the variation will be positive ...
+            g[i] += delta
+          else
+            # ... and half of the times it will be negative
+            g[i] -= delta
+          end
+        end
+      end
+
+      def intermediate_recombination(g1, g2, recombination_rv)
+        # TODO: disable this check in non-debugging mode
+        raise ArgumentError, 'g1 and g2 must have the same dimension' unless g1.size == g2.size
+
+        # recombination
+        g1.each_index do |i|
+          begin
+            alpha = recombination_rv.next
+            beta  = recombination_rv.next
+            t = (alpha * g1[i] + (1.0 - alpha) * g2[i] + 0.5).floor
+            s = ( beta * g2[i] + (1.0 -  beta) * g1[i] + 0.5).floor
+          end # until t >= 0 and s >= 0 # TODO: implement within-bounds condition checking
+          g1[i] = t
+          g2[i] = s
+        end
+      end
+
+      def line_recombination(g1, g2, recombination_rv)
+        # TODO: disable this check in non-debugging mode
+        raise ArgumentError, 'g1 and g2 must have the same dimension' unless g1.size == g2.size
+
+        alpha = recombination_rv.next
+        beta  = recombination_rv.next
+
+        # recombination
+        g1.each_index do |i|
+          t = (alpha * g1[i] + (1.0 - alpha) * g2[i] + 0.5).floor
+          s = ( beta * g2[i] + (1.0 -  beta) * g1[i] + 0.5).floor
+          # if t >= 0 and s >= 0 # TODO: implement within-bounds condition checking
+            g1[i] = t
+            g2[i] = s
+          # end
+        end
+      end
+
+  end
+
+end

data/lib/mhl/particle_swarm_optimization_solver.rb

@@ -0,0 +1,122 @@
+require 'matrix'
+require 'securerandom'
+
+module MHL
+
+  class ParticleSwarmOptimizationSolver
+
+    def initialize(opts={})
+      @swarm_size = opts[:swarm_size].to_i
+      unless @swarm_size
+        raise ArgumentError, 'Swarm size is a required parameter!'
+      end
+
+      @random_position_func = opts[:random_position_func]
+      @random_velocity_func = opts[:random_velocity_func]
+
+      @start_positions = opts[:start_positions]
+      @exit_condition  = opts[:exit_condition]
+    end
+
+    # This is the method that solves the optimization problem
+    #
+    # Parameter func is supposed to be a method (or a Proc, a lambda, or any callable
+    # object) that accepts the genotype as argument (that is, the set of
+    # parameters) and returns the phenotype (that is, the function result)
+    def solve(func)
+      # setup particles
+      if @start_positions.nil?
+        particles = Array.new(@swarm_size) do
+          { position: Vector[*@random_position_func.call], velocity: Vector[*@random_velocity_func.call] }
+        end
+      else
+        particles = @start_positions.each_slice(2).map do |pos,vel|
+          { position: Vector[*pos], velocity: Vector[*vel] }
+        end
+      end
+
+      # initialize variables
+      gen = 0
+      overall_best = nil
+
+      # completely made up values
+      alpha   = 0.5
+      beta    = 0.3
+      gamma   = 0.7
+      delta   = 0.5
+      epsilon = 0.6
+
+      # default behavior is to loop forever
+      begin
+        gen += 1
+        puts "Starting generation #{gen} at #{Time.now}"
+
+        # assess height for every particle
+        particles.each do |p|
+          p[:task] = Concurrent::Future.new { func.call(p[:position]) }
+        end
+
+        # wait for all the evaluations to end
+        particles.each_with_index do |p,i|
+          p[:height] = p[:task].value
+          if p[:highest_value].nil? or p[:height] > p[:highest_value]
+            p[:highest_value]    = p[:height]
+            p[:highest_position] = p[:position]
+          end
+        end
+
+        # find highest particle
+        highest_particle = particles.max_by {|x| x[:height] }
+
+        # calculate overall best
+        if overall_best.nil?
+          overall_best = highest_particle
+        else
+          overall_best = [ overall_best, highest_particle ].max_by {|x| x[:height] }
+        end
+
+        # mutate swarm
+        particles.each do |p|
+          # randomly sample particles and use them as informants
+          informants = random_portion(particles)
+
+          # make sure that p is included among the informants
+          informants << p unless informants.include? p
+
+          # get fittest informant
+          fittest_informant = informants.max_by {|x| x[:height] }
+
+          # update velocity
+          p[:velocity] =
+            alpha * p[:velocity] +
+            beta  * (p[:highest_position] - p[:position]) +
+            gamma * (fittest_informant[:highest_position] - p[:position]) +
+            delta * (overall_best[:highest_position] - p[:position])
+
+          # update position
+          p[:position] = p[:position] + epsilon * p[:velocity]
+        end
+
+      end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
+    end
+
+    private
+
+      def random_portion(array, ratio=0.1)
+        # get size of random array to return
+        size = (ratio * array.size).ceil
+
+        (1..size).inject([]) do |acc,i|
+          # randomly sample a new element
+          begin
+            new_element = array[SecureRandom.random_number(array.size)]
+          end while acc.include? new_element
+
+          # insert element in the accumulator
+          acc << new_element
+        end
+      end
+
+  end
+
+end

data/lib/mhl/version.rb

@@ -0,0 +1,3 @@
+module MHL
+  VERSION = '0.0.1'
+end

data/mhl.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mhl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mhl'
+  spec.version       = MHL::VERSION
+  spec.authors       = ['Mauro Tortonesi']
+  spec.email         = ['mauro.tortonesi@unife.it']
+  spec.description   = %q{A Ruby Metaheuristics library}
+  spec.summary       = %q{A scientific library for Ruby that provides several metaheuristics}
+  spec.homepage      = 'https://github.com/mtortonesi/ruby-mhl'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/).reject{|x| x == '.gitignore' }
+  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_dependency 'bitstring'
+  spec.add_dependency 'concurrent-ruby'
+  spec.add_dependency 'erv'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/spec/mhl/genetic_algorithm_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe MHL::GeneticAlgorithmSolver do
+
+  it 'should accept bitstring representation genotypes' do
+    lambda {
+      MHL::GeneticAlgorithmSolver.new(
+        :population_size           => 128,
+        :genotype_space_type       => :bitstring,
+        :mutation_threshold        => 0.5,
+        :recombination_threshold   => 0.5,
+        :genotype_space_conf       => {
+            :bitstring_length => 120,
+        }
+      )
+    }.should_not raise_error
+  end
+
+  it 'should accept integer representation genotypes' do
+    lambda {
+      MHL::GeneticAlgorithmSolver.new(
+        :population_size           => 128,
+        :genotype_space_type       => :integer,
+        :mutation_probability      => 0.5,
+        :recombination_probability => 0.5,
+        :genotype_space_conf       => {
+            :dimensions         => 6,
+            :recombination_type => :intermediate,
+        }
+      )
+    }.should_not raise_error
+  end
+
+  it 'should solve a 2-dimension parabola in integer space' do
+    solver = MHL::GeneticAlgorithmSolver.new(
+        :population_size           => 40,
+        :genotype_space_type       => :integer,
+        :mutation_probability      => 0.5,
+        :recombination_probability => 0.5,
+        :genotype_space_conf       => {
+            :dimensions         => 2,
+            :recombination_type => :intermediate,
+            :random_func        => lambda { Array.new(2) { rand(20) } }
+        },
+        :exit_condition => lambda {|generation,best_sample| best_sample[:fitness] == 0}
+    )
+    solver.solve(Proc.new{|genotype| -(genotype[0]**2 + genotype[1]**2)  })
+  end
+
+  # it 'should solve a 2-dimension parabola in real space'
+
+end
+

data/spec/mhl/particle_swarm_optimization_solver_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe MHL::ParticleSwarmOptimizationSolver do
+
+  it 'should solve a 2-dimension parabola in real space' do
+    solver = MHL::ParticleSwarmOptimizationSolver.new(
+      :swarm_size           => 40,
+      :random_position_func => lambda { Array.new(2) { rand(20) } },
+      :random_velocity_func => lambda { Array.new(2) { rand(10) } },
+      :exit_condition       => lambda {|generation,best_sample| best_sample[:height].abs < 0.001 },
+    )
+    solver.solve(Proc.new{|position| -(position[0]**2 + position[1]**2) })
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+
+require 'mhl'
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: mhl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mauro Tortonesi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bitstring
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: erv
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: A Ruby Metaheuristics library
+email:
+- mauro.tortonesi@unife.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/mhl.rb
+- lib/mhl/bitstring_genotype_space.rb
+- lib/mhl/genetic_algorithm_solver.rb
+- lib/mhl/integer_genotype_space.rb
+- lib/mhl/particle_swarm_optimization_solver.rb
+- lib/mhl/version.rb
+- mhl.gemspec
+- spec/mhl/genetic_algorithm_spec.rb
+- spec/mhl/particle_swarm_optimization_solver_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mtortonesi/ruby-mhl
+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.1
+signing_key:
+specification_version: 4
+summary: A scientific library for Ruby that provides several metaheuristics
+test_files:
+- spec/mhl/genetic_algorithm_spec.rb
+- spec/mhl/particle_swarm_optimization_solver_spec.rb
+- spec/spec_helper.rb