gegene 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 41e8a0e177bba73f066e17c27edcd7577d43633c
+  data.tar.gz: 4c23284c8be074707981392045deb5db19243fe3
+SHA512:
+  metadata.gz: 3ff2f8fa8335626a395e0c5aeb4b6b46d8d2cf65ba032773b3fb7e9e51acbc8b163be6e663cb34cc8f875559d990b574b1c155a4f726c61b3d1fe3583d509e20
+  data.tar.gz: be8ee9a256f9f2a927b0aa0ad4faf1cb45bf10ba355c1dbdde8390fd5a85abf1f65d009fa3c544961a0c38c27ce80c1cc512c1305e823ea835ba346ecf81599e

data/example/adding_gene_type.rb

@@ -0,0 +1,34 @@
+require 'gegene'
+
+class PalindromeGene < Gene      
+    def initialize(size)
+      @size = size
+    end
+
+    # Will raise an error in Gene class if not overloaded here
+    def random_allele_value
+      prefix = Array.new(@size/2){ rand(97..122).chr}.join("")
+      prefix + (@size%2 == 0 ? "" : rand(97..122).chr) +prefix.reverse()
+    end
+
+    # Will raise an error in Gene class if not overloaded here
+    def mutate(previous_value)
+      self.random_allele_value
+    end
+end
+
+# The following code is not mandatory
+# use it if you'd rather have Gene.Palyndrome(9) instead of a ctor call
+#class Gene
+#  Gene.Palyndrome(size) PalyndromeGene.new(size) end
+#end
+
+genome_description = [{palyndrome:PalindromeGene.new(9)}]
+
+def fitness(karyotype)
+  karyotype[:palyndrome].split(//).select{|c| c =~ /[aeiou]/}.size
+end
+
+population = Population.new(25, genome_description, method(:fitness))
+population.evolve(10)
+puts population.karyotypes[0][:palyndrome]

data/example/one_max.rb

@@ -0,0 +1,34 @@
+require 'gegene'
+
+# Follow a genome description for the one max problem:
+genome_description = [
+    { v1: Gene.Integer(0,1) },
+    { v2: Gene.Integer(0,1) },
+    { v3: Gene.Integer(0,1) }
+  ]
+
+# Here is the fitness function of the one max problem:
+def fitness(karyotype)
+  karyotype[:v1] + karyotype[:v2] + karyotype[:v3]
+end
+
+# We create a population of six individuals with the previous desc & func:
+population = Population.new(6, genome_description, method(:fitness))
+
+# As we known the best solution for the one max problem, we set a
+# fitness target of 3 (1+1+1).
+population.fitness_target = 3
+
+# As the population is quite small, we add a little more funk to our
+# evolution process by setting a 30% mutation rate
+population.mutation_rate = 0.3
+
+# Let's go for some darwinist fun !
+population.evolve(10)
+
+# population.karyotypes is sorted by fitness score, so we can assume that
+# the first element is the fittest
+best_karyotype = population.karyotypes[0]
+
+puts "Best karyotype scored #{best_karyotype.fitness}:"
+[:v1, :v2, :v3].each {|x| puts "    #{x.to_s}:#{best_karyotype[x]}" }

data/example/simple.rb

@@ -0,0 +1,10 @@
+require 'gegene'
+FITNESS_TARGET = 1 / 0.001
+population = Population.new(
+    50,
+    [{a:Gene.Integer(0, 5)},{b:Gene.Integer(-5,5)}],
+    lambda {|k| 1 / (0.001 + (12-(k[:a]**2+k[:b])).abs) }
+  )
+population.set_mutation_rate(0.5).set_fitness_target(FITNESS_TARGET).evolve(50)
+bk = population.karyotypes[0]
+warn "a:#{bk[:a]} b:#{bk[:b]} => a*a + b = #{bk[:a]**2+bk[:b]}"

data/lib/allele.rb

@@ -0,0 +1,16 @@
+class Allele
+  attr_accessor :value
+  def initialize(gene, value)
+    @gene = gene
+    @value = value
+  end
+  
+  def mutate
+    @value = @gene.mutate(@value)
+  end
+  
+  def copy
+    # /!\ if @value is a ref, its underlying object won't be copied
+    Allele.new(@gene, @value)
+  end
+end

data/lib/chromosome.rb

@@ -0,0 +1,26 @@
+require 'gene'
+require 'allele'
+class Chromosome
+  
+  def initialize(alleles)
+    @alleles = alleles
+  end
+  
+  def copy
+    Chromosome.new(@alleles.map{|allele| allele.copy })
+  end
+  
+  def Chromosome.create_random_from(description)
+    Chromosome.new(description.map{|gene| gene.create_random() })
+  end
+  
+  def [](gene_position)
+    @alleles[gene_position]
+  end
+  
+  def mutate
+    allele_index = rand @alleles.size
+    @alleles[allele_index].mutate()
+  end
+  
+end

data/lib/gegene.rb

@@ -0,0 +1,2 @@
+require 'gene'
+require 'population'

data/lib/gene.rb

@@ -0,0 +1,72 @@
+
+class Gene  
+  def mutate(allele)
+    raise "the 'mutate' function must be overloaded in the inheriting class."
+  end
+
+  def random_allele_value
+    raise "the 'random_allele_value' function must be overloaded in the inheriting class."
+  end
+  def create_random
+    Allele.new(self, self.random_allele_value)
+  end
+end
+
+class NumericGene < Gene
+  attr_accessor :min, :max
+  def initialize(min, max)
+    raise "max (#{max}) must be greater than min (#{min})" if max <= min
+    @min = min
+    @max = max
+  end
+
+  def mutate(previous_value)
+    next_value = random_allele_value
+    while next_value == previous_value do
+      next_value = random_allele_value
+    end
+    next_value
+  end
+end 
+
+class IntegerGene < NumericGene
+  def initialize(min, max) super(min, max) end
+  
+  def random_allele_value() rand(self.min..self.max) end
+end
+
+class FloatGene < NumericGene
+  def initialize(min, max) super(min, max) end
+  
+  def random_allele_value
+    rand() * (self.max - self.min) + self.min
+  end
+end
+
+class EnumGene < Gene
+  attr_accessor :enum_values
+
+  def initialize(enum_values)
+    raise "EnumGene initialization require an Array" unless enum_values.is_a? Array
+    raise "EnumGene require at least two values" unless enum_values.size > 1
+    @enum_values = enum_values
+  end
+  
+  def random_allele_value
+    @enum_values[rand @enum_values.size]
+  end
+  
+  def mutate(previous_value)
+    new_value = self.random_allele_value
+    while new_value == previous_value
+      new_value = self.random_allele_value
+    end
+    new_value
+  end
+end
+
+class Gene
+  def self.Integer(min, max) IntegerGene.new(min, max) end
+  def self.Float(min, max) FloatGene.new(min, max) end
+  def self.Enum(enum_values) EnumGene.new(enum_values) end
+end

data/lib/genome.rb

@@ -0,0 +1,27 @@
+require 'Karyotype'
+
+class Genome
+  
+  def initialize(genome_description)
+    raise "Genome description MUST be an Array" unless genome_description.is_a? Array
+    @chromosomes_description = []
+    @gene_positions = {}
+    genome_description.each_with_index do |chomosome_hash, chromosome_position|
+      gene_array = []
+      chomosome_hash.keys.each_with_index do |gene_name, gene_position|
+        @gene_positions[gene_name] = [chromosome_position, gene_position]
+        gene_array << chomosome_hash[gene_name]
+      end
+      @chromosomes_description << gene_array
+    end
+  end
+  attr_accessor :gene_positions
+  def get_gene_position(gene_name)
+    @gene_positions[gene_name]
+  end
+  
+  def create_random_karyotype
+    Karyotype.create_random_from(self, @chromosomes_description)
+  end
+  
+end

data/lib/karyotype.rb

@@ -0,0 +1,45 @@
+require 'chromosome'
+class Karyotype
+  attr_accessor :chromosomes
+  attr_accessor :fitness
+  def initialize(genome, chromosomes_description)
+    @genome = genome
+    @chromosomes_description = chromosomes_description
+  end
+  private :initialize
+  def copy
+    karyotype = Karyotype.new(@genome, @chromosomes_description)
+    karyotype.chromosomes = self.chromosomes.map{|chromosome| chromosome.copy}
+    karyotype
+  end
+  def to_s
+    @genome.gene_positions.keys.map{|gn| "#{gn}=>#{self[gn]}"}.join';'
+  end
+  def Karyotype.create_random_from(genome, chromosomes_description)
+    karyotype = Karyotype.new(genome, chromosomes_description)
+    karyotype.chromosomes = chromosomes_description.map {|description|
+      Chromosome.create_random_from(description)
+    }
+    karyotype
+  end
+  
+  def [](gene_name)
+    return nil if @chromosomes.nil?
+    chromosome_position, gene_position = @genome.get_gene_position(gene_name)
+    return nil if chromosome_position.nil? || gene_position.nil?
+    return @chromosomes[chromosome_position][gene_position].value
+  end
+  
+  def +(other)
+    child = copy
+    other.chromosomes.each_with_index {
+      |chromosome, index| child.chromosomes[index] = chromosome if rand(2) == 0
+    }
+    child
+  end
+  
+  def mutate
+    @chromosomes[rand @chromosomes.size].mutate
+    self
+  end
+end

data/lib/population.rb

@@ -0,0 +1,101 @@
+require 'genome'
+
+class Population
+  DEFAULT_MUTATION_RATE = 0.01
+  DEFAULT_KEEP_ALIVE_RATE = 0.1
+  DEFAULT_EVOLVE_ITERATIONS = 1
+  
+  attr_accessor :mutation_rate, :keep_alive_rate, :fitness_target, :karyotypes
+
+  def evaluate
+    @karyotypes.each { |k| k.fitness = @fitness_calculator.call(k) if k.fitness.nil? }
+    @karyotypes.sort! { |x,y| y.fitness <=> x.fitness }
+  end
+  
+  private :evaluate
+  
+  def initialize(size, genome, fitness_calculator)
+    @mutation_rate = DEFAULT_MUTATION_RATE
+    @keep_alive_rate = DEFAULT_KEEP_ALIVE_RATE
+    @genome = Genome.new(genome)
+    @fitness_calculator = fitness_calculator
+    @karyotypes = Array.new(size){ @genome.create_random_karyotype }
+    evaluate
+  end
+  
+  def set_mutation_rate(rate)
+    @mutation_rate = rate
+    self
+  end
+  
+  def set_keep_alive_rate(rate)
+    @keep_alive_rate = rate
+    self
+  end
+  
+  def set_fitness_target(target)
+    @fitness_target = target
+    self
+  end
+  
+  def size
+    @karyotypes.size
+  end
+
+  def linear_random_select
+    @karyotypes[rand @karyotypes.size]
+  end
+    
+  def create_random_mutation
+    linear_random_select.copy.mutate
+  end
+
+  private :linear_random_select, :create_random_mutation
+
+  def random_select
+    @karyotypes[
+      @karyotypes.size - Integer(Math.sqrt(Math.sqrt(1 + rand(@karyotypes.size**4 - 1))))
+    ]
+  end
+  
+  def random_breed
+    random_select + random_select
+  end
+
+private :random_select, :random_breed
+  
+  def evolve(iterations = DEFAULT_EVOLVE_ITERATIONS)
+    i = 1
+    while (i <= iterations) &&
+      (@fitness_target.nil? || @fitness_target > @karyotypes[0].fitness) do
+      evolve_impl
+      i += 1
+    end
+    self
+  end
+  
+  def evolve_impl
+    new_population = []    
+    
+    # Keeping alive a specific amount of the best karyotypes
+    keep_alive_count = Integer(@karyotypes.size * @keep_alive_rate)
+    if keep_alive_count > 0 then
+      @karyotypes[0, keep_alive_count].each {|karyotype| new_population.push(karyotype)}
+    end
+        
+    mutation_count = Integer(@karyotypes.size * @mutation_rate)
+    (0..mutation_count-1).each {
+      new_population.push create_random_mutation
+    }
+    
+    remaining = @karyotypes.size-mutation_count-keep_alive_count
+    (0..remaining-1).each {
+      child = random_breed
+      new_population.push child      
+    }
+    @karyotypes = new_population
+    evaluate
+  end
+  private :evolve_impl
+
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: gegene
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alexandre Ignjatovic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-27 00:00:00.000000000 Z
+dependencies: []
+description: Framework for fast genetic algorithm development
+email: alexandre.ignjatovic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/allele.rb
+- lib/chromosome.rb
+- lib/gegene.rb
+- lib/gene.rb
+- lib/genome.rb
+- lib/karyotype.rb
+- lib/population.rb
+- example/adding_gene_type.rb
+- example/one_max.rb
+- example/simple.rb
+homepage: https://github.com/bankair/gegene
+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.1.4
+signing_key: 
+specification_version: 4
+summary: Genetic algorithm helpers
+test_files: []