darwinning 0.0.3 → 0.1.0

data/Gemfile

@@ -3,7 +3,7 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
-  gem 'rspec', '~> 2.14.0'
+  gem 'rspec'
 end
 
 group :development, :test do

data/README.md

@@ -1,6 +1,6 @@
 Darwinning
 ==========
-[![Gem Version](https://badge.fury.io/rb/darwinning.png)](http://badge.fury.io/rb/darwinning)
+[![Gem Version](https://badge.fury.io/rb/darwinning.svg)](http://badge.fury.io/rb/darwinning)
 
 [gem]: https://rubygems.org/gems/darwinning
 
@@ -13,99 +13,116 @@ Installation
 gem install darwinning
 ```
 
-Examples
+Usage
 --------
 
-### Fifteen
+There are two ways of using Darwinning. You can either start with a class that is a subclass of `Darwinning::Organism` or you can include `Darwinning` in an existing class that you would like to make evolveable.
+
+### Include Style:
+
+*This style is useful if you want to take existing objects and use Darwinning on them when needed.*
 
 Here's an dumb example of how you might use Darwinning to solve a pointless problem:
 
-Let's say for some reason you need a set of 3 number that add up to 15.  This is a strange problem to have, but let's solve it anyway.
+Let's say for some reason you need a set of 3 numbers (within a range of 0-100) that add up to 100.  This is a strange problem to have, but let's solve it anyway.
 
 ```ruby
-class Triple < Darwinning::Organism
+require 'darwinning'
 
-	@name = "Triple"
-	@genes = [
-			Darwinning::Gene.new(name: "first digit", value_range: (0..9)),
-			Darwinning::Gene.new(name: "second digit", value_range: (0..9)),
-			Darwinning::Gene.new(name: "third digit", value_range: (0..9))
-		]
-
-	def fitness
-		# Try to get the sum of the 3 digits to add up to 15
-		(genotypes.inject{ |sum, x| sum + x } - 15).abs
-	end
-end 
-
-p = Darwinning::Population.new(
-	organism: Triple, population_size: 10,
-	fitness_goal: 0, generations_limit: 100
-)
-p.evolve!
+class Triple
+  include Darwinning
 
-p.best_member.nice_print # prints the member representing the solution
-```
+  GENE_RANGES = {
+    first_number: (0..100),
+    second_number: (0..100),
+    third_number: (0..100)
+  }
 
-This code declares an organism class that inherits from Darwinning's Organism parent class to represent solutions.  Then we create a population of these solution organisms and evolve the population until a solution meets the fitness threshold or the generation limit is met.
+  attr_accessor :first_number, :second_number, :third_number
 
-### Cookies
+  def fitness
+    # Try to get the sum of the 3 digits to add up to 100
+    (first_number + second_number + third_number - 100).abs
+  end
+end
+```
 
-Or let's say you want to find the perfect chocolate chip cookie recipie.  Sure you could ask your grandmother, but why not let a genetic algorithm do all the work for you?  Some baking may be required for this one.
+In order to use Darwinning this way you must:
+- `include Darwinning` in your class
+- define a `GENE_RANGES` constant with your relivant value names as keys
+- define `attr_accessor`s for all your values
+- define a `fitness` method
 
-Define a cookie Organism class, generate an initial population, bake a batch of each and have your friends rate each batch.  Use that rating as the fitness value for each recipie and then generate the next generation of cookie recipies.  Repeat until you have optimized the recipie or you are sick from eating too many cookies.
+Once you have your organism class that includes Darwinning, you can create a population and evolve it:
 
 ```ruby
-class Cookie < Darwinning::Organism
-
-	@name = "Chocolate Chip Cookie"
-	@genes = [
-			Darwinning::Gene.new(name: "white sugar", value_range: (0..1), units: "cup"),
-			Darwinning::Gene.new(name: "brown sugar", value_range: (0..1), units: "cup"),
-			Darwinning::Gene.new(name: "flour", value_range: (0..3), units: "cup"),
-			Darwinning::Gene.new(name: "eggs", value_range: (0..3)),
-			Darwinning::Gene.new(name: "baking powder", value_range: (0..2), units: "teaspoon"),
-			Darwinning::Gene.new(name: "salt", value_range: (0..2), units: "teaspoon"),
-			Darwinning::Gene.new(name: "butter", value_range: (0..2), units: "cup"),
-			Darwinning::Gene.new(name: "vanilla extract", value_range: (0..2), units: "teaspoon"),
-			Darwinning::Gene.new(name: "chocolate chips", value_range: (0..20), units: "ounce"),
-			Darwinning::Gene.new(name: "oven temp", value_range: (300..400), units: "degrees F"),
-			Darwinning::Gene.new(name: "cook time", value_range: (5..20), units: "minute")
-		]
+if Triple.is_evolveable?
+  triple_pop = Triple.build_population(0, 10, 100)
+  triple_pop.evolve! # evolve until fitness goal is or generations limit is met
 
+  pp "Best member: #{triple_pop.best_member}"
 end
+```
 
-p = Darwinning::Population.new(
-	organism: Cookie, population_size: 10,
-	fitness_goal: 5, generations_limit: 100
-)
+### Inheritance Style:
 
-first_gen_ratings = [1.5, 4, 3, 3.5, 2, 1, 1.5, 3, 2.5, 0.5]
-p.set_members_fitness!(first_gen_ratings)
+*This style is good when you just want to set up some quick objects to only use in Darwinning tasks.*
 
-p.make_next_generation!
+Let's solve the same dumb problem we looked at before...
 
-p.members.each { |m| m.nice_print } # print second generation of cookie recipies
-```
+```ruby
+require 'darwinning'
 
-### Binary String Organism
+class Triple < Darwinning::Organism
+  @name = "Triple"
+  @genes = [
+    Darwinning::Gene.new(name: "first digit", value_range: (0..100)),
+    Darwinning::Gene.new(name: "second digit", value_range: (0..100)),
+    Darwinning::Gene.new(name: "third digit", value_range: (0..100))
+  ]
+
+  def fitness
+  # Try to get the sum of the 3 digits to add up to 100
+    (genotypes.values.inject { |sum, x| sum + x } - 100).abs
+  end
+end
+```
 
-A simple binary string representation of an organism can be easily created thusly:
+With this `Darwinning::Organism` class, you can now build a population and evolve it:
 
 ```ruby
-class BinaryOrganism < Darwinning::Organism
+triple_pop = Darwinning::Population.new(
+  organism: Triple, population_size: 10,
+  fitness_goal: 0, generations_limit: 100
+)
+triple_pop.evolve!
+
+pp "Best member: #{triple_pop.best_member}"
+```
 
-	10.times { |s| @genes << Darwinning::Gene.new("", [0,1]) }
+### Stepping Through Generations Manually
 
-	def fitness
-		# whatever makes sense here
-	end  
-end
+```ruby
+# pop is a Darwinning::Population of organisms
+puts pop.generation
+# 0
+pop.make_next_generation!
+puts pop.generation
+# 1
+
+# you can view a history of population's evolion
+puts pop.history
+# [[gen0_member1, gen0_member2,...], [gen1_member1, gen1_member2,...]]
 ```
 
+### More Examples
+
+Check out the `/examples` folder for more examples. That seems like a good place to put examples, right?
+
 ## Built by:
 * [Dave Schwantes](https://github.com/dorkrawk "dorkrawk")
 
 ### With help from:
 * [Cameron Dutro](https://github.com/camertron "camertron")
-* [Maurizio Del Corno](https://github.com/druzn3k "druzn3k")
+* [Maurizio Del Corno](https://github.com/druzn3k "druzn3k")
+* [Evan Brynne](https://github.com/ebrynne "ebrynne")

data/lib/darwinning.rb

@@ -1,9 +1,64 @@
 require_relative 'darwinning/gene'
 require_relative 'darwinning/organism'
-require_relative 'darwinning/evolution_types'
+require_relative 'darwinning/evolution_types/mutation'
+require_relative 'darwinning/evolution_types/reproduction'
 require_relative 'darwinning/population'
 require_relative 'darwinning/config'
 
 module Darwinning
   extend Config
-end
+
+  def self.included(base)
+    def base.genes
+      gene_ranges.map { |k,v| Gene.new(name: k, value_range: v) }
+    end
+
+    def base.build_population(fitness_goal, population_size = 10, generations_limit = 100, 
+                         evolution_types = Population::DEFAULT_EVOLUTION_TYPES)
+      Population.new(organism: self, population_size: population_size,
+                     generations_limit: generations_limit, fitness_goal: fitness_goal,
+                     evolution_types: evolution_types)
+    end
+
+    def base.is_evolveable?
+      has_gene_ranges? &&
+      gene_ranges.is_a?(Hash) &&
+      gene_ranges.any? &&
+      valid_genes? &&
+      has_fitness_method?
+    end
+
+    private
+
+    def base.has_gene_ranges?
+      self.constants.include?(:GENE_RANGES)
+    end
+
+    def base.has_fitness_method?
+      self.instance_methods.include?(:fitness)
+    end
+
+    def base.gene_ranges
+      self::GENE_RANGES
+    end
+
+    def base.valid_genes?
+      genes.each do |gene|
+        return false unless self.method_defined? gene.name
+      end
+      true
+    end
+  end
+
+  def genes
+    self.class.genes
+  end
+
+  def genotypes
+    gt = {}
+    genes.each do |gene|
+      gt[gene] = self.send(gene.name)
+    end
+    gt
+  end
+end

data/lib/darwinning/config.rb

@@ -2,5 +2,6 @@ module Darwinning
   module Config
     # crossover mask?
     # ordered vs weighted fitness
+    CROSSOVER_METHOD = :alternating_swap
   end
 end

data/lib/darwinning/evolution_types/reproduction.rb

@@ -1,9 +1,16 @@
 module Darwinning
   module EvolutionTypes
-
     class Reproduction
-      def evolve(organism, m1, m2)
-        sexytimes(organism, m1, m2)
+
+      # Available crossover_methods:
+      #   :alternating_swap
+      #   :random_swap
+      def initialize(options = {})
+        @crossover_method = options.fetch(:crossover_method, :alternating_swap)
+      end
+
+      def evolve(m1, m2)
+        sexytimes(m1, m2)
       end
 
       def pairwise?
@@ -12,23 +19,61 @@ module Darwinning
 
       protected
 
-      def sexytimes(organism, m1, m2)
-        genotypes1 = []
-        genotypes2 = []
+      def sexytimes(m1, m2)
+        raise "Only organisms of the same type can breed" unless m1.class == m2.class
+
+        new_genotypes = send(@crossover_method, m1, m2)
+
+        organism_klass = m1.class
+        organism1 = new_member_from_genotypes(organism_klass, new_genotypes.first)
+        organism2 = new_member_from_genotypes(organism_klass, new_genotypes.last)
+
+        [organism1, organism2]
+      end
+
+      def new_member_from_genotypes(organism_klass, genotypes)
+        new_member = organism_klass.new
+        if organism_klass.superclass.to_s == "Darwinning::Organism"
+          new_member.genotypes = genotypes
+        else
+          new_member.genes.each do |gene|
+            new_member.send("#{gene.name}=", genotypes[gene])
+          end
+        end
+        new_member
+      end
+
+      def alternating_swap(m1, m2)
+        genotypes1 = {}
+        genotypes2 = {}
 
-        m1.genotypes.zip(m2.genotypes).each do |g|
-          if m1.genotypes.index(g[0]) % 2 == 0
-            genotypes1 << g[0]
-            genotypes2 << g[1]
+        m1.genes.each_with_index do |gene, i|
+          if i % 2 == 0
+            genotypes1[gene] = m1.genotypes[gene]
+            genotypes2[gene] = m2.genotypes[gene]
           else
-            genotypes1 << g[1]
-            genotypes2 << g[0]
+            genotypes1[gene] = m2.genotypes[gene]
+            genotypes2[gene] = m1.genotypes[gene]
           end
         end
 
-        [organism.new(genotypes1), organism.new(genotypes2)]
+        [genotypes1, genotypes2]
       end
-    end
 
+      def random_swap(m1, m2)        
+        genotypes1 = {}
+        genotypes2 = {}
+
+        m1.genes.each do |gene|
+          g1_parent = [m1,m2].sample
+          g2_parent = [m1,m2].sample
+
+          genotypes1[gene] = g1_parent.genotypes[gene]
+          genotypes2[gene] = g2_parent.genotypes[gene]          
+        end
+
+        [genotypes1, genotypes2]
+      end
+    end
   end
 end

data/lib/darwinning/gene.rb

@@ -1,8 +1,6 @@
 module Darwinning
-
   class Gene
-    attr_accessor :name, :value_range, :invalid_values, :units
-    attr_accessor :value
+    attr_reader :name, :value_range, :invalid_values, :units, :value
 
     def initialize(options = {})
       @name = options.fetch(:name, '')
@@ -11,6 +9,22 @@ module Darwinning
       @units = options.fetch(:units, '')
     end
 
+    def ==(o)
+      o.class == self.class &&
+      o.name == name &&
+      o.value_range == value_range &&
+      o.invalid_values == invalid_values &&
+      o.units == units
+    end
+
+    def eql?(o)
+      o == self
+    end
+
+    def hash
+      name.hash ^ value_range.hash ^ invalid_values.hash ^ units.hash ^ value.hash
+    end
+
     def express
       (value_range - invalid_values).sample
     end

data/lib/darwinning/organism.rb

@@ -26,7 +26,6 @@ module ClassLevelInheritableAttributes
 end
 
 module Darwinning
-
   class Organism
     include ClassLevelInheritableAttributes
     inheritable_attributes :genes, :name
@@ -35,26 +34,21 @@ module Darwinning
     @genes = []  # Gene instances
     @name = ""
 
-    def initialize(genotypes = [])
-      #TODO: catch errors if genotype.length != @genotypes.length
-      # catch if genotype[x] is not a valid value for @gene[x]
-
-      if genotypes == []
+    def initialize(genotypes = {})
+      if genotypes == {}
         # fill genotypes with expressed Genes
-        @genotypes = self.class.genes.map { |g| g.express } # Gene expressions
+        @genotypes = {}
+        genes.each do |g|
+          # make genotypes a hash with gene objects as keys
+          @genotypes[g] = g.express
+        end
       else
         @genotypes = genotypes
       end
 
       @fitness = -1
     end
-
-    def nice_print
-      puts self.class.name == "" ? "[no name]" : self.class.name
-      self.class.genes.to_enum.each_with_index { |g, i| puts "  #{g.name}: #{@genotypes[i]} #{g.units}" }
-      puts "    fitness: #{fitness}"
-    end
-
+    
     def name
       self.class.name
     end

data/lib/darwinning/population.rb

@@ -1,12 +1,14 @@
 module Darwinning
-
   class Population
-    attr_accessor :members, :generations_limit, :fitness_goal
-    attr_accessor :organism, :generation, :population_size
-    attr_accessor :evolution_types
+
+    EPSILON = 0.01
+
+    attr_reader :members, :generations_limit, :fitness_goal,
+                :organism, :population_size, :generation,
+                :evolution_types, :history
 
     DEFAULT_EVOLUTION_TYPES = [
-      Darwinning::EvolutionTypes::Reproduction.new,
+      Darwinning::EvolutionTypes::Reproduction.new(crossover_method: :alternating_swap),
       Darwinning::EvolutionTypes::Mutation.new(mutation_rate: 0.10)
     ]
 
@@ -18,13 +20,15 @@ module Darwinning
       @evolution_types = options.fetch(:evolution_types, DEFAULT_EVOLUTION_TYPES)
       @members = []
       @generation = 0 # initial population is generation 0
+      @history = []
 
       build_population(@population_size)
+      @history << @members
     end
 
     def build_population(population_size)
       population_size.times do |i|
-        @members << organism.new
+        @members << build_member
       end
     end
 
@@ -34,14 +38,73 @@ module Darwinning
       end
     end
 
+    def set_members_fitness!(fitness_values)
+      throw "Invaid number of fitness values for population size" if fitness_values.size != members.size
+      members.to_enum.each_with_index { |m, i| m.fitness = fitness_values[i] }
+    end
+
+    def make_next_generation!
+      temp_members = members
+      new_members = []
+
+      until new_members.length == members.length
+        m1 = weighted_select(members)
+        m2 = weighted_select(members)
+
+        new_members += apply_pairwise_evolutions(m1, m2)
+      end
+
+      @members = apply_non_pairwise_evolutions(new_members)
+      @history << @members
+      @generation += 1
+    end
+
+    def evolution_over?
+      # check if the fitness goal or generation limit has been met
+      if generations_limit > 0
+        generation == generations_limit || best_member.fitness == fitness_goal
+      else
+        best_member.fitness == fitness_goal
+      end
+    end
+
+    def best_member
+      @members.sort_by { |m| m.fitness }.first
+    end
+
+    def size
+      @members.length
+    end
+
+    def organism_klass
+      real_organism = @organism
+      fitness_function = @fitness_function
+      klass = Class.new(Darwinning::Organism) do
+        @name = real_organism.name
+        @genes = real_organism.genes
+      end
+    end
+
+    private
+
+    def build_member
+      member = organism.new
+      unless member.class.superclass.to_s == "Darwinning::Organism"
+        member.class.genes.each do |gene|
+          gene_expression = gene.express
+          member.send("#{gene.name}=", gene_expression)
+        end
+      end
+      member
+    end
+
     def weighted_select(members)
-      e = 0.01
       fitness_sum = members.inject(0) { |sum, m| sum + m.fitness }
 
       weighted_members = members.sort_by do |m|
         (m.fitness - fitness_goal).abs
       end.map do |m|
-        [m, fitness_sum / ((m.fitness - fitness_goal).abs + e)]
+        [m, fitness_sum / ((m.fitness - fitness_goal).abs + EPSILON)]
       end
 
       weight_sum = weighted_members.inject(0) { |sum, m| sum + m[1] }
@@ -58,33 +121,10 @@ module Darwinning
       selected_member.first
     end
 
-    def set_members_fitness!(fitness_values)
-      members.to_enum.each_with_index { |m, i| m.fitness = fitness_values[i] }
-    end
-
-    def make_next_generation!
-      temp_members = members
-      used_members = []
-      new_members = []
-
-      until new_members.length == members.length / 2
-        m1 = weighted_select(members - used_members)
-        used_members << m1
-        m2 = weighted_select(members - used_members)
-        used_members << m2
-
-        new_members << apply_pairwise_evolutions(organism, m1, m2)
-      end
-
-      new_members.flatten!
-      @members = apply_non_pairwise_evolutions(new_members)
-      @generation += 1
-    end
-
-    def apply_pairwise_evolutions(organism, m1, m2)
+    def apply_pairwise_evolutions(m1, m2)
       evolution_types.inject([m1, m2]) do |ret, evolution_type|
         if evolution_type.pairwise?
-          evolution_type.evolve(organism, *ret)
+          evolution_type.evolve(*ret)
         else
           ret
         end
@@ -101,22 +141,5 @@ module Darwinning
       end
     end
 
-    def evolution_over?
-      # check if the fiteness goal or generation limit has been met
-      if generations_limit > 0
-        generation == generations_limit || best_member.fitness == fitness_goal
-      else
-        generation == generations_limit || best_member.fitness == fitness_goal
-      end
-    end
-
-    def best_member
-      @members.sort_by { |m| m.fitness }.first
-    end
-
-    def size
-      @members.length
-    end
   end
-
 end

data/lib/darwinning/version.rb

@@ -1,3 +1,3 @@
 module Darwinning
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/spec/classes/chimps.rb

@@ -0,0 +1,23 @@
+class GenelessChimp
+  include Darwinning
+end
+
+class BadGenesChimp
+  include Darwinning
+
+  GENE_RANGES = "throw poop?"
+end
+
+class EmptyGenesChimp
+  include Darwinning
+
+  GENE_RANGES = {}
+end
+
+class NoValuesChimp
+  include Darwinning
+
+  GENE_RANGES = {
+    throwing_range: (0..100)
+  }
+end

data/spec/classes/new_triple.rb

@@ -0,0 +1,16 @@
+class NewTriple
+  include Darwinning
+
+  GENE_RANGES = {
+    first_digit: (0..9),
+    second_digit: (0..9),
+    third_digit: (0..9)
+  }
+
+  attr_accessor :first_digit, :second_digit, :third_digit
+
+  def fitness
+    # Try to get the sum of the 3 digits to add up to 15
+    (first_digit + second_digit + third_digit - 15).abs
+  end
+end

data/spec/classes/triple.rb

@@ -8,6 +8,6 @@ class Triple < Darwinning::Organism
 
   def fitness
     # Try to get the sum of the 3 digits to add up to 15
-    (genotypes.inject{ |sum, x| sum + x } - 15).abs
+    (genotypes.values.inject{ |sum, x| sum + x } - 15).abs
   end
 end

data/spec/darwinning_spec.rb

@@ -1,94 +1,98 @@
-require 'darwinning'
-require './spec/classes/triple'
-
-describe Darwinning::Gene do
-  before do
-    @digit = Darwinning::Gene.new(name: "digit", value_range: (0..9))
-    @day_hour = Darwinning::Gene.new(
-      name: "hour",
-      value_range: (0..23),
-      invalid_values: [0, 1, 2, 3, 4, 20, 21, 22, 23],
-      units: "o'clock"
-    )
-  end
+require 'spec_helper'
 
-  it "name should be set" do
-    @digit.name.should == "digit"
-  end
+describe Darwinning do
+  let(:triple_pop) { NewTriple.build_population(0, 20, 1000) }
+  let(:triple_pop_member) { triple_pop.members.first }
 
-  it "value range should be set" do
-    @digit.value_range.should == (0..9).to_a
-  end
+  describe '#build_population' do
+    it 'creates a population of the correct size' do
+      expect(triple_pop.size).to eq 20
+    end
 
-  it "invalid values should be set" do
-    @day_hour.invalid_values.should == [0, 1, 2, 3, 4, 20, 21, 22, 23]
-  end
+    it 'creates a population with the correct generation limit' do
+      expect(triple_pop.generations_limit).to eq 1000
+    end
 
-  it "units should be set" do
-    @day_hour.units.should == "o'clock"
-  end
-end
+    it 'uses the fitness function defined by #fitness' do
+      a_triple = triple_pop.members.first
+      manual_fitness = (a_triple.first_digit + a_triple.second_digit + a_triple.third_digit - 15).abs
 
-describe Darwinning::Organism do
-  before do
-    @org = Darwinning::Organism.new
-    @triple = Triple.new
+      expect(a_triple.fitness).to eq manual_fitness
+    end 
   end
 
-  it "name should default to blank" do
-    @org.name.should == ""
+  describe '#genes' do
+    it 'creates a gene for every value in GENE_RANGES' do
+      expect(NewTriple.genes.size).to eq NewTriple::GENE_RANGES.size
+    end
   end
 
-  it "genes should default to empty array" do
-    @org.genes.should == []
-  end
+  describe '#is_evolveable?' do
+    it 'is true for a class that implments the necessary Darwinning features' do
+      expect(NewTriple.is_evolveable?).to be true
+    end
 
-  it "genotypes should initialize to empty array if genes is empty" do
-    @org.genotypes.should == []
-  end
+    it 'is false if the class is missing get GENE_RANGES constant' do
+      expect(GenelessChimp.is_evolveable?).to be false
+    end
 
-  it "fitness should default to -1" do
-    @org.fitness.should == -1
-  end
+    it 'is false if GENE_RANGES not a Hash' do
+      expect(BadGenesChimp.is_evolveable?).to be false
+    end
 
-  it "child class should set name" do
-    @triple.name.should == "Triple"
-  end
+    it 'is false if the genes are invalid' do
+      expect(NoValuesChimp.is_evolveable?).to be false
+    end
 
-  it "child class should set genes" do
-    @triple.genes.length.should == 3 # not the best test...
-  end
+    it 'is false if GENE_RANGES is empty' do
+      expect(EmptyGenesChimp.is_evolveable?).to be false
+    end
 
-  it "child class should initialize genotypes from genes" do
-    @triple.genotypes.length.should == 3 # not the best test...
+    it 'is false if the class is missing a fitness method' do
+      expect(GenelessChimp.is_evolveable?).to be false
+    end
   end
 
-end
+  describe 'population member' do 
+    it 'is of the parent class' do
+      expect(triple_pop_member.class.name).to eq "NewTriple"
+    end
 
-describe Darwinning::Population do
-  before do
-    @pop_triple = Darwinning::Population.new(
-      organism: Triple, population_size: 10, fitness_goal: 0
-    )
-  end
+    it 'has genotype values validly set' do
+      expect(NewTriple.genes.first.value_range).to include(triple_pop_member.send(NewTriple.genes.first.name))
+    end
 
-  it "fitness goal should be set to 0" do
-    @pop_triple.fitness_goal.should == 0
-  end
+    it 'has a genes method' do
+      expect(triple_pop_member.respond_to?(:genes)).to be true
+    end
 
-  it "population size should be 10" do
-    @pop_triple.members.length.should == 10
-  end
+    it 'has genes that are Darwinning::Genes' do
+      gene_classes = triple_pop_member.genes.map { |g| g.class.name }.uniq.compact
+      expect(gene_classes).to eq ["Darwinning::Gene"]
+    end
 
-  it "population should start on generation 0" do
-    @pop_triple.generation.should == 0
-  end
+    it 'has gene for each of the class defined genes' do
+      expect(triple_pop_member.genes).to eq NewTriple.genes
+    end
+
+    it 'has a genotypes method' do
+      expect(triple_pop_member.respond_to?(:genotypes)).to be true
+    end
 
-  it "make_next_generation! should evolve population by one generation" do
-    old_members = @pop_triple.members
-    @pop_triple.make_next_generation!
-    @pop_triple.generation.should == 1
-    @pop_triple.members.should_not == old_members
+    it 'has genotype values for every gene' do
+      genotype_values_equal = triple_pop_member.genotypes.map { |k, v| v == triple_pop_member.send(k.name) }.uniq.compact
+      expect(genotype_values_equal).to eq [true]
+    end
   end
 
+  describe 'population evolution' do
+    let(:evolving_triple_pop) { NewTriple.build_population(0, 10, 100) }
+
+    it 'sets the genotypes of the next generation' do
+      evolving_triple_pop.make_next_generation!
+      pop_member = evolving_triple_pop.members.first
+      genotype_values_equal = pop_member.genotypes.map { |k, v| v != nil }.uniq.compact
+      expect(genotype_values_equal).to eq [true]
+    end
+  end
 end

data/spec/gene_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Darwinning::Gene do
+  let(:digit) { Darwinning::Gene.new(name: "digit", value_range: (0..9)) }
+  let(:day_hour) {
+    Darwinning::Gene.new(
+      name: "hour",
+      value_range: (0..23),
+      invalid_values: [0, 1, 2, 3, 4, 20, 21, 22, 23],
+      units: "o'clock"
+    )
+  }
+  
+  it "name should be set" do
+    expect(digit.name).to eq "digit"
+  end
+
+  it "value range should be set" do
+    expect(digit.value_range).to eq (0..9).to_a
+  end
+
+  it "invalid values should be set" do
+    expect(day_hour.invalid_values).to eq [0, 1, 2, 3, 4, 20, 21, 22, 23]
+  end
+
+  it "units should be set" do
+    expect(day_hour.units).to eq "o'clock"
+  end
+end

data/spec/organism_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Darwinning::Organism do
+  let(:org) { Darwinning::Organism.new }
+  let(:triple) { Triple.new }
+
+  it "name should default to blank" do
+    expect(org.name).to eq ""
+  end
+
+  it "genes should default to empty array" do
+    expect(org.genes).to eq []
+  end
+
+  it "genotypes should initialize to empty array if genes is empty" do
+    expect(org.genotypes).to be {}
+  end
+
+  it "fitness should default to -1" do
+    expect(org.fitness).to eq -1
+  end
+
+  it "child class should set name" do
+    expect(triple.name).to eq "Triple"
+  end
+
+  it "child class should set genes" do
+    expect(triple.genes.length).to eq 3
+  end
+
+  it "child class should initialize genotypes from genes" do
+    expect(triple.genotypes.length).to eq 3
+  end
+
+end

data/spec/population_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Darwinning::Population do
+  let(:pop_triple) {
+    Darwinning::Population.new(
+      organism: Triple, population_size: 10, fitness_goal: 0
+    )
+  }
+  
+  it "fitness goal should be set to 0" do
+    expect(pop_triple.fitness_goal).to eq 0
+  end
+
+  it "population size should be 10" do
+    expect(pop_triple.members.length).to eq 10
+  end
+
+  it "population should start on generation 0" do
+    expect(pop_triple.generation).to eq 0
+  end
+
+  it "make_next_generation! should evolve population by one generation" do
+    old_members = pop_triple.members
+    pop_triple.make_next_generation!
+
+    expect(pop_triple.generation).to eq 1
+    expect(pop_triple.members).not_to eq old_members
+  end
+
+  describe "#history" do
+
+    it "should be generations + 1 in size" do
+      pop_triple.evolve!
+      expect(pop_triple.history.size).to eq pop_triple.generation + 1
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'darwinning'
+require './spec/classes/triple'
+require './spec/classes/new_triple'
+require './spec/classes/chimps'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: darwinning
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2015-09-27 00:00:00.000000000 Z
 dependencies: []
 description: Darwinning provides tools to build genetic algorithm solutions using
   a Gene, Organism, and Population structure.
@@ -30,8 +30,14 @@ files:
 - Gemfile
 - Rakefile
 - README.md
+- spec/classes/chimps.rb
+- spec/classes/new_triple.rb
 - spec/classes/triple.rb
 - spec/darwinning_spec.rb
+- spec/gene_spec.rb
+- spec/organism_spec.rb
+- spec/population_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/dorkrawk/darwinning
 licenses: []
 post_install_message: 
@@ -57,5 +63,11 @@ signing_key:
 specification_version: 3
 summary: A Ruby gem to aid in the use of genetic algorithms.
 test_files:
+- spec/classes/chimps.rb
+- spec/classes/new_triple.rb
 - spec/classes/triple.rb
 - spec/darwinning_spec.rb
+- spec/gene_spec.rb
+- spec/organism_spec.rb
+- spec/population_spec.rb
+- spec/spec_helper.rb