genetic_algorithms 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.swp
+coverage/
+results.log
+*.gem

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3@genetic_algorithms"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.16.6 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    genetic_algorithms (0.0.1)
+      logging (~> 1.8.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    little-plugger (1.1.3)
+    logging (1.8.0)
+      little-plugger (>= 1.1.3)
+      multi_json (>= 1.3.6)
+    multi_json (1.3.6)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  genetic_algorithms!
+  rspec
+  simplecov

data/README.rdoc

@@ -0,0 +1,17 @@
+{<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/execdd17/genetic_algorithms]
+
+== Description
+
+This project contains my work in progress on Genetic Algorithms. The basic premise involves creating an initial random population of chromosomes and evolving them until they reach some ideal state.
+
+== Usage
+
+A chromosome is a solution to a problem, and represented as a bit string. It is intentionally general in order to lend itself to multiple domains. The only thing linking it to a particular problem set is the fitness function. A fitness function evaluates a chromosome, that is, the effectiveness of a proposed solution.
+
+In my GeneticAlgorithms project, I use the engine to encapsulate the entire evolution process. You can quickly use it with default values like this:
+
+<tt>GeneticAlgorithms::Engine.new.start "AllOffSample"</tt>
+
+The argument to the start method is a fitness function. I have included a few with this project as a basic guide for creating your own.
+
+The engine has three optional parameters that can be utilized during construction. The population size, chromosome length, and number of generations to evolve (in that order). You'll notice that modifying these values can have a tremendous effect on the algorithm itself, and that is one of the interesting characteristics of genetic algorithms. In the future I will be opening up more parameters as well; currently many of them are tightly coupled to their respective classes.

data/genetic_algorithms.gemspec

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'genetic_algorithms/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'genetic_algorithms'
+  s.version     = GeneticAlgorithms::VERSION
+  s.authors     = ["Alexander Vanadio"]
+  s.email       = 'execdd17@gmail.com'
+  s.homepage    = 'https://github.com/execdd17/genetic_algorithms'
+  s.summary     = "A simple API for using genetic algorithms in Ruby"
+  s.description = "This gem allows you to evolve chromosomes in order to solve problems"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency("logging", "~> 1.8.0")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("simplecov")
+end

data/lib/genetic_algorithms.rb

@@ -0,0 +1,24 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))             
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib/genetic_algorithms'))
+
+require 'logging'
+
+%W{Population Chromosome RouletteWheel}.each do |logger_type|
+  log = Logging.logger["GeneticAlgorithms::#{logger_type}"]
+  log.level = :debug
+  log.add_appenders Logging.appenders.file("results.log")
+end
+
+module GeneticAlgorithms
+  require 'genetic_algorithms/chromosome'
+  require 'genetic_algorithms/exceptions'
+  require 'genetic_algorithms/roulette_wheel'
+  require 'genetic_algorithms/population'
+
+  ff_path = File.join(File.expand_path("..", __FILE__), "genetic_algorithms/fitness_functions")
+  Dir[File.join ff_path, "**/*.rb"].each do |f|
+    require f
+  end
+
+  require 'genetic_algorithms/engine'
+end

data/lib/genetic_algorithms/chromosome.rb

@@ -0,0 +1,64 @@
+module GeneticAlgorithms
+  class Chromosome < String
+
+    OFF, ON = "0", "1"
+
+    def initialize(string)
+      unless string.each_char.all? { |s| s == OFF or s == ON }
+        raise InvalidChromosome, "A chromosome can only have 0's and 1's" 
+      end
+
+      @logger = Logging.logger[self.class]
+      super(string)
+    end
+
+    def self.random(length)
+      chromosome = (0...length).inject(String.new) do |chromosome, i|
+        chromosome += (rand(2) == 0 ? OFF : ON)
+      end
+
+      Chromosome.new chromosome
+    end
+
+    def mutate(prob=0.05)
+      @logger.debug "MUTATION: Starting on\t#{self}"
+
+      chromosome = self.each_char.map do |char|
+        mutate?(prob) ? flip(char) : char
+      end.join
+
+      @logger.debug "MUTATION: Result\t\t#{chromosome}"
+      Chromosome.new chromosome
+    end
+
+    def flip(char)
+      @logger.debug "MUTATION: Triggered on #{self}" if char == ON
+      char == ON ? OFF : ON
+    end
+    
+    def crossover(chromosome, probability=0.7)
+      unless self.size == chromosome.size
+        raise IncompatibleChromosomes, "Both chromosomes need to be the same size"
+      end
+
+      offspring = self
+
+      if crossover?(probability)
+        index       = rand(0...length)
+        offspring   = Chromosome.new self[0...index] + chromosome[index...length]
+        @logger.debug "CROSSOVER: Using the first #{index} bits from #{self} and " +
+                      "the last #{length - index} bits from #{chromosome}"
+        @logger.debug "CROSSOVER: Result\t#{offspring}"
+      end
+
+      offspring.mutate  
+    end
+    
+    def check_prob(prob)
+      rand <= prob
+    end
+    
+    alias_method :crossover?, :check_prob
+    alias_method :mutate?,    :check_prob
+  end
+end

data/lib/genetic_algorithms/engine.rb

@@ -0,0 +1,32 @@
+module GeneticAlgorithms
+  class Engine 
+    
+    def initialize(population_size=10, chromosome_length=10, num_generations=5)
+      @population_size    = population_size 
+      @chromosome_length  = chromosome_length
+      @num_generations    = num_generations
+
+      @chromosomes = Population.random_chromosomes @population_size, @chromosome_length
+      @population  = Population.new @chromosomes
+    end 
+
+    def start(fitness_function_type)
+      extend GeneticAlgorithms::FitnessFunctions.const_get(fitness_function_type)
+
+      highest_score, best_gen = 0, nil
+      
+      (0...@num_generations).inject(@population) do |newest_population, i|
+        next_gen = newest_population.evolve(&fitness_function)
+
+        if newest_population.highest_score > highest_score
+          highest_score, best_gen = newest_population.highest_score, newest_population
+          break if highest_score == self.best_possible_score
+        end
+
+        next_gen
+      end
+
+      {best_gen.best_solution => best_gen.highest_score}
+    end
+  end
+end

data/lib/genetic_algorithms/exceptions.rb

@@ -0,0 +1,4 @@
+module GeneticAlgorithms
+  class InvalidChromosome < Exception; end
+  class IncompatibleChromosomes < Exception; end
+end

data/lib/genetic_algorithms/fitness_functions/all_off_sample.rb

@@ -0,0 +1,19 @@
+module GeneticAlgorithms
+  module FitnessFunctions
+    module AllOffSample
+
+      def best_possible_score
+        @chromosome_length
+      end
+  
+      def fitness_function
+        lambda do |chromosome|
+          chromosome.each_char.inject(0) do |accum, char|
+            accum += 1 if char == Chromosome::OFF
+            accum
+          end
+        end
+      end
+    end
+  end
+end

data/lib/genetic_algorithms/fitness_functions/alternating_on_off_sample.rb

@@ -0,0 +1,20 @@
+module GeneticAlgorithms
+  module FitnessFunctions
+    module AlternatingOnOffSample
+
+      def best_possible_score
+        @chromosome_length
+      end
+  
+      def fitness_function
+        lambda do |chromosome|
+          (0...chromosome.length).inject(0) do |accum, index|
+            accum += 1 if index % 2 == 0 and chromosome[index] == Chromosome::ON
+            accum += 1 if index % 2 == 1 and chromosome[index] == Chromosome::OFF
+            accum
+          end
+        end
+      end
+    end
+  end
+end

data/lib/genetic_algorithms/natural_hash.rb

@@ -0,0 +1,22 @@
+module GeneticAlgorithms
+  class NaturalHash < Hash
+    def map
+      result = super()
+      hash_structure?(result) ? NaturalHash[ result ] : result
+    end
+
+    def sort_by
+      NaturalHash[ super ]
+    end
+
+    private 
+
+    def hash_structure?(obj)
+      if obj.is_a? Array and not obj.empty?
+        return true if obj.all? { |i| i.is_a? Array and i.length == 2}
+      end
+
+      false
+    end
+  end
+end

data/lib/genetic_algorithms/population.rb

@@ -0,0 +1,46 @@
+module GeneticAlgorithms
+
+  #TODO: add input validation
+  class Population
+
+    attr_reader :chromosomes, :highest_score, :best_solution
+
+    def initialize(chromosomes)
+      @chromosomes  = chromosomes
+      @logger       = Logging.logger[self.class]
+    end
+
+    def self.random_chromosomes(total_chromosomes, chromosome_length)
+      Array.new(total_chromosomes).map do 
+        Chromosome.random(chromosome_length)
+      end
+    end
+
+    def evolve(&block)
+      weighted_chromosomes = @chromosomes.inject(Hash.new) do |memo, chromosome|
+        memo[chromosome] = block.call(chromosome)
+        memo
+      end
+
+      highest_weighted = Hash[[ weighted_chromosomes.invert.sort.last ]].invert
+      @best_solution = highest_weighted.keys.first
+      @highest_score = highest_weighted.values.first
+
+      roulette_wheel = RouletteWheel.new weighted_chromosomes
+
+      offspring = (0...(@chromosomes.size)).inject(Array.new) do |offspring|
+        mates = Array.new(2).map do
+          roulette_wheel.spin
+        end
+
+        child_chromosome    = mates.first.crossover(mates.last)
+        offspring          << child_chromosome
+      end
+
+      @logger.info "Highest Score in population: #@highest_score"
+      @logger.info "Best Solution in population: #@best_solution"
+
+      Population.new offspring
+    end
+  end
+end

data/lib/genetic_algorithms/roulette_wheel.rb

@@ -0,0 +1,30 @@
+require 'genetic_algorithms/natural_hash'
+
+module GeneticAlgorithms
+  class RouletteWheel
+    def initialize chromosomes_and_scores
+      chromosomes_and_scores  = NaturalHash[ chromosomes_and_scores ]
+      total                   = chromosomes_and_scores.values.inject(:+)
+      @logger                 = Logging.logger[self]
+
+      normalized = chromosomes_and_scores.map do |chromosome, score| 
+        [chromosome, score.to_f/total]
+      end
+
+      @normalized = normalized.sort_by { |chromosome, probability| probability }
+    end
+
+    def spin 
+      accumulator, prng = 0, rand
+
+      @normalized.each_pair do |chromosome, probability| 
+        if prng <= probability + accumulator
+          @logger.debug "Choosing #{chromosome} with probability #{probability}"
+          return chromosome 
+        end
+
+        accumulator += probability
+      end
+    end
+  end
+end

data/lib/genetic_algorithms/version.rb

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

data/spec/chromosome_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+include GeneticAlgorithms
+
+describe Chromosome do
+  describe ".initialize" do
+    it "should raise an exception when given non 0 and 1 characters" do
+      lambda { Chromosome.new("01AB") }.should raise_error InvalidChromosome
+    end
+
+    it "should not raise an exception when given good data" do
+      lambda { Chromosome.new("01110010") }.should_not raise_error 
+    end
+  end
+
+  describe "#mutate" do
+    subject { Chromosome.new "0000" }
+
+    it "should flip bits when triggered" do
+      subject.mutate(1.0).should == "1111"
+    end
+
+    it "should not flip bits when it isn't triggered" do
+      subject.mutate(0.0).should == "0000"
+    end
+  end
+
+  describe "#crossover" do
+    ROUNDS = 1000
+
+    before(:each) do
+      @chromosome_1 = Chromosome.new "0000"
+      @chromosome_2 = Chromosome.new "1111"
+    end
+
+    it "should return a single Chromosome" do
+      @chromosome_1.crossover(@chromosome_2).is_a?(Chromosome).should == true
+    end
+
+    it "should return a chromosome identical to the caller over time" do
+      (0...ROUNDS).any? do |i|
+        @chromosome_1.crossover(@chromosome_2) == @chromosome_1
+      end.should == true
+    end
+
+    it "should return a chromosome identical to the receiver over time" do
+      (0...ROUNDS).any? do |i|
+        @chromosome_1.crossover(@chromosome_2) == @chromosome_2
+      end.should == true
+    end
+
+    it "should return a distinct new chromosome over time" do
+      (0...ROUNDS).any? do |i|
+        offspring = @chromosome_1.crossover(@chromosome_2)
+        offspring != @chromosome_1 and offspring != @chromosome_2
+      end.should == true
+    end
+
+    it "should raise an exception when trying to swap chromosomes of different sizes" do
+      lambda do 
+        @chromosome_1.crossover(Chromosome.new("01"), 0.0)
+      end.should raise_error IncompatibleChromosomes
+    end
+  end
+
+  describe ".random" do
+    it "should return an instance of Chromosome" do
+      Chromosome.random(10).is_a?(Chromosome).should == true
+    end
+
+    it "should be the length specified" do
+      Chromosome.random(10).length.should ==  10
+    end
+  end
+end

data/spec/engine_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+include GeneticAlgorithms
+
+describe Engine do
+  subject { Engine.new }
+
+  # TODO: DRY out this code
+  describe "#start" do
+    context "AllOffSample fitness function" do
+      it "returns a hash" do
+        subject.start("AllOffSample").is_a?(Hash).should == true
+      end
+
+      it "returns the best solution as a Chromosome" do
+        subject.start("AllOffSample").keys.first.is_a?(Chromosome).should == true
+      end
+
+      it "returns the best score as a Fixnum" do
+        subject.start("AllOffSample").values.first.is_a?(Fixnum).should == true
+      end
+    end
+
+    context "AlternatingOnOffSample fitness function" do
+      it "returns a hash" do
+        subject.start("AlternatingOnOffSample").is_a?(Hash).should == true
+      end
+
+      it "returns the best solution as a Chromosome" do
+        subject.start("AlternatingOnOffSample").keys.first.is_a?(Chromosome).should == true
+      end
+
+      it "returns the best score as a Fixnum" do
+        subject.start("AlternatingOnOffSample").values.first.is_a?(Fixnum).should == true
+      end
+    end
+  end
+end

data/spec/natural_hash_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+include GeneticAlgorithms
+
+describe NaturalHash do
+  
+  subject { NaturalHash[ {a:1, b:2} ] }
+
+  describe "#map" do
+    it "should return a NaturalHash when mapping a 2d array" do
+      subject.map { |k,v| [k,v] }.is_a?(NaturalHash).should == true
+    end
+
+    it "should return the normal value when mapping anything else" do
+      subject.map { |k,v| "test" }.is_a?(NaturalHash).should == false
+    end
+  end
+
+  describe "#sort_by" do
+    it "should return a NaturalHash" do
+      subject.sort_by { |k,v| v }.is_a?(NaturalHash).should == true
+    end
+  end
+end

data/spec/population_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+include GeneticAlgorithms
+
+# NOTE: changing the constants can alter the tests dramatically
+describe Population do
+
+  POPULATION_SIZE   = 100   # the number of chromosomes
+  CHROMOSOME_LENGTH = 30    
+  NUM_GENERATIONS   = 50
+  
+  before(:each) do 
+    @chromosomes = Population.random_chromosomes POPULATION_SIZE, CHROMOSOME_LENGTH
+  end
+
+  describe ".random_chromosomes" do
+    it "should return an array of chromosomes" do
+      @chromosomes.all? { |element| element.is_a? Chromosome }.should == true
+    end
+
+    it "should return the correct number of chromosomes" do
+      @chromosomes.length.should == POPULATION_SIZE
+    end
+
+    it "should return chromosomes of the correct length" do
+      @chromosomes.all? { |chromosome| chromosome.length == CHROMOSOME_LENGTH }.should == true
+    end
+  end
+
+  describe "#evolve" do
+    
+    before(:each) do
+      @population = Population.new @chromosomes
+      @best_score = CHROMOSOME_LENGTH
+    end
+    
+    it "should accept a block that holds the fitness function" do
+      lambda do
+        @population.evolve { |chromosome| rand(@best_score) }
+      end.should_not raise_error
+    end
+    
+    it "should return a population" do
+      next_gen = @population.evolve { |chromosome| rand(chromosome.length) }
+      next_gen.is_a?(Population).should == true
+    end
+
+    it "should return a population different than the one before evolution" do
+      next_gen = @population.evolve { |chromosome| rand(chromosome.length) }
+      next_gen.eql?(@population).should == false
+    end
+  end
+end

data/spec/roulette_wheel_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+include GeneticAlgorithms
+
+describe RouletteWheel do
+  subject { RouletteWheel.new({a: 3, b: 1, c: 2}) }
+
+  describe "#spin" do
+
+    SPINS = 1000
+
+    it "should return the highest score on a long enough timeline" do
+      results = {a: 0, b: 0, c: 0}
+      SPINS.times { results[subject.spin] += 1 }
+
+      (results[:a] > results[:b] and results[:a] > results[:c]).should == true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require './lib/genetic_algorithms'

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: genetic_algorithms
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Vanadio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem allows you to evolve chromosomes in order to solve problems
+email: execdd17@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- genetic_algorithms.gemspec
+- lib/genetic_algorithms.rb
+- lib/genetic_algorithms/chromosome.rb
+- lib/genetic_algorithms/engine.rb
+- lib/genetic_algorithms/exceptions.rb
+- lib/genetic_algorithms/fitness_functions/all_off_sample.rb
+- lib/genetic_algorithms/fitness_functions/alternating_on_off_sample.rb
+- lib/genetic_algorithms/natural_hash.rb
+- lib/genetic_algorithms/population.rb
+- lib/genetic_algorithms/roulette_wheel.rb
+- lib/genetic_algorithms/version.rb
+- spec/chromosome_spec.rb
+- spec/engine_spec.rb
+- spec/natural_hash_spec.rb
+- spec/population_spec.rb
+- spec/roulette_wheel_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/execdd17/genetic_algorithms
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A simple API for using genetic algorithms in Ruby
+test_files:
+- spec/chromosome_spec.rb
+- spec/engine_spec.rb
+- spec/natural_hash_spec.rb
+- spec/population_spec.rb
+- spec/roulette_wheel_spec.rb
+- spec/spec_helper.rb