charlie 0.5.0

data/lib/charlie/etc/minireport.rb

@@ -0,0 +1,45 @@
+
+# This was handled by ruport earlier, but that turned out to be overkill and give a huge amount of dependencies.
+
+class Array
+  def to_table(colnames=nil)
+    Table.new(self,colnames)
+  end
+end
+
+class Table < Array
+  def initialize(tbl,colnames=nil)
+    @colnames = colnames || tbl[0].map_with_index{|e,i|i+1}
+    super(tbl.map{|row|row.dup.map(&:to_s)})
+  end
+ 
+  def to_html
+    "<table>\n" +
+      "<tr>" + @colnames.map{|t| "<th>#{t}</th>" }.join + "</tr>\n" +
+	map{|r| "<tr>\n" + r.map{|e| "\t<td>#{e.gsub('<','&lt;')}</td>\n"  }.join + "</tr>\n" }.join +
+    "</table>"
+  end
+
+  def to_csv
+    map{|r| r.map(&:inspect).join(', ') }.join("\n")
+  end
+
+  def to_s(csz=nil)
+    rsz = at(0).size    
+    csz ||= [(80-rsz) / rsz]*rsz
+    pad = ' ' * csz.max
+    sep = csz.map{|x|'-'*x}.join('+')
+    ([sep,@colnames.zip_with(csz){|str,sz| (str+pad)[0...sz] }.join('|'),sep]+
+    map{|r| r.zip_with(csz){|str,sz| (str+pad)[0...sz] }.join('|') } << sep).join("\n")
+  end
+
+end
+
+if __FILE__ == $0
+ t = [['aaaaaaa"a<>aaaaaaa',23],['bb',421]].to_table(['xx','yy'])
+ puts t.to_s
+ puts
+ puts t.to_html
+ puts
+ puts t.to_csv
+end

data/lib/charlie/etc/monkey.rb

@@ -0,0 +1,136 @@
+# I should probably replace some of this with a dependency on facets.
+
+class Numeric
+  def between(minval,maxval)
+    [[self,minval].max,maxval].min
+  end
+end
+
+module Enumerable
+  def group_by
+    ret = {}
+    each{|e| (ret[yield(e)] ||= []) << e }
+    ret
+  end
+
+  def zip_with(a2,&b)
+    zip(a2).map(&b)
+  end
+
+  def count
+    count = 0
+    each {|e| count+=1 if yield(e) }
+    count
+  end
+end
+
+class Array
+
+  def shuffle
+    sort_by{ rand }
+  end
+
+  def sum
+    inject(0){|a,b|a+b}
+  end
+
+  def inner_product(v)
+    zip_with(v){|a,b|a*b}.sum
+  end
+
+  def rand_index
+    rand(size)
+  end
+
+  def at_rand
+    self[rand(size)]
+  end
+
+  def stats
+    [min,max,average,stddev]
+  end
+
+  def average
+    sum.to_f / size
+  end
+  
+  def map_with_index
+   r=[]
+   each_with_index{|e,i| r << yield(e,i) }
+   r
+  end
+ 
+  def stddev
+    mu = average
+    Math.sqrt( map{|x| (x-mu)*(x-mu) }.sum / size )
+  end
+end
+
+
+class String
+  def rand_index
+    rand(size)
+  end
+
+  def rand_at
+    self[rand(size)]
+  end
+
+  def chars
+    split('')  
+  end
+  
+  def each_char(&b)
+    chars.each(&b)
+  end
+end
+
+class Symbol
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+
+  # This function was added because :npoint[3] just looks so much nicer than [:npoint,3]
+  def [](*args)
+    [self,*args]
+  end
+
+  def intern
+    self
+  end
+end
+
+class Module
+  def metaclass
+    class << self;self;end
+  end
+
+  # Used to give anonymous modules a name.
+  def name=(n)
+    metaclass.send(:define_method,:to_s) { n }
+  end
+end
+
+class Class
+  # For each module passed:
+  # Includes the module if it has a mutate! method, and includes it in the metaclass otherwise.
+  # Used to include selection/crossover/mutation modules in one line, or just to avoid all the class<<self;include ...;end
+  #  class Example < Genotype
+  #    use RandomSelection, NullCrossover, NullMutator
+  #  end
+  def use(*mods)
+   mods.each{|mod|
+    if mod.instance_methods.include? 'mutate!'
+      include mod
+    else
+      metaclass.class_eval{
+        include mod
+      }
+    end
+   }
+  end
+
+end
+
+
+

data/lib/charlie/genotype.rb

@@ -0,0 +1,45 @@
+# Contains the base class for genotypes
+
+
+# Base class. Inherit this if you're starting from scratch
+class Genotype
+  attr_accessor :genes
+
+  # raises an exception when called
+  def fitness
+    raise NoMethodError, "You need to define a fitness function in your genotype class!"
+  end 
+  # raises an exception when called
+  def fight(other)
+    raise NoMethodError, "You need to define a fight(other) function in your genotype class to use this selection strategy!"
+  end 
+
+  class << self
+    # Creates a new instance of your genotype class given its genes.
+    def from_genes(g)
+      r = new  # how to avoid initialize here?
+      r.genes = g
+      r
+    end
+  end
+
+  def dup
+    self.class.from_genes(genes.dup)
+  end
+
+  def mutate
+    dup.mutate!
+  end
+
+  def to_s
+    @genes.to_s
+  end
+
+  include Comparable
+  def <=>(b)
+    fitness <=> b.fitness
+  end
+  # Higher default max. population size for the selection
+  # .dup on constant modules ensures inherited classes can revert back to this
+  use NullCrossover.dup, NullMutator.dup, Elitism(ScaledRouletteSelection(),1)
+end

data/lib/charlie/list/list_crossover.rb

@@ -0,0 +1,30 @@
+# List crossovers: SinglePointCrossover, UniformCrossover
+
+
+# Simple single point crossover, returns two children.
+module SinglePointCrossover
+  def cross(parent1,parent2)
+    cross_pt = rand(parent1.size+1)
+    [ parent1.genes[0...cross_pt] + parent2.genes[cross_pt..-1],
+      parent2.genes[0...cross_pt] + parent1.genes[cross_pt..-1]].map{|x| from_genes(x) }
+  end
+end
+
+# Uniform crossover, returns two children.
+module UniformCrossover
+  def cross(parent1,parent2)
+    c1 = []; c2=[]
+    parent1.genes.zip(parent2.genes).each{|a,b|
+      if rand(2).zero?
+        c1 << a; c2 << b
+      else
+        c2 << a; c1 << b
+      end
+    }
+    [c1,c2].map{|x| from_genes(x) }
+  end
+end
+
+
+
+

data/lib/charlie/list/list_genotype.rb

@@ -0,0 +1,53 @@
+# This file defines several different genotype (aka genome, chromosomes) classes.
+# Inherit from one of these classes and define a fitness function to use them.
+
+
+# Genotype of +n+ floats in the range +range+.
+# Individuals are initialized as an array of +n+ random numbers in this range.
+# Note that mutations may cross range min/max.
+def FloatListGenotype(n,range=0..1)
+ Class.new(Genotype) {
+  @@range = range
+  define_method(:size){ n }
+  def initialize
+    @genes = Array.new(size){ rand * (@@range.end - @@range.begin) + @@range.begin }
+  end
+  def to_s
+    @genes.inspect
+  end
+  use ListMutator(), SinglePointCrossover.dup
+ }
+end
+
+# Genotype of +n+ bits.
+# Individuals are initialized as an array of +n+ random bits.
+def BitStringGenotype(n)
+ Class.new(Genotype) {
+  define_method(:size){ n }
+  def initialize
+    @genes = Array.new(size){ rand(2) }
+  end
+  def to_s
+    @genes.map(&:to_s).join
+  end
+  use ListMutator(:expected_n,:flip), SinglePointCrossover.dup
+ }
+end
+
+# Genotype of +n+ elements (not necessarily chars).
+# Individuals are initialized as an array of +n+ elements, each randomly chosen from the +elements+ array.
+def StringGenotype(n,elements)
+ elements = elements.chars if elements.is_a? String # string to array of chars
+ elements = elements.to_a
+ Class.new(Genotype) {
+  define_method(:size){ n }
+  define_method(:elements){ elements }
+  def initialize
+    @genes = Array.new(size){ elements.at_rand }
+  end
+  def to_s
+    @genes.map(&:to_s).join
+  end
+  use ListMutator(:expected_n[2],:replace[*elements]), SinglePointCrossover.dup
+ }
+end

data/lib/charlie/list/list_mutate.rb

@@ -0,0 +1,75 @@
+# List mutators: generated by the ListMutator function
+
+# The mutation strategies for ListMutator
+# * :single_point : Mutates a single element
+# * :n_point[n=3] : Mutates a single element, n times.     Example: :n_point, :n_point[2]
+# * :probability[ p=0.05 ] : Mutates each element with probability p
+# * :expected_n[n=3]     : Mutates each element with probability n/genes.size, i.e. such that the expected # of mutations is n
+MutationStrategies = {  # TODO: change to default parameters in 1.9
+  :probability => Proc.new{|genes,pointmut,p| 
+    p ||= 0.05
+    genes.map!{|e| rand < p ? pointmut.call(e) : e }
+  },
+  :expected_n => Proc.new{|genes,pointmut,n|
+    n ||= 3
+    p   = n.to_f / genes.size
+    genes.map!{|e| rand < p ? pointmut.call(e) : e }
+  },
+  :single_point => Proc.new{|genes,pointmut|
+    i = genes.rand_index
+    genes[i] = pointmut.call(genes[i])
+  },
+  :n_point => Proc.new{|genes,pointmut,n|
+    n ||= 3
+    n.times{ i = genes.rand_index; genes[i] = pointmut.call(genes[i]) }
+  }
+}
+
+# The point mutators for ListMutator
+# * :flip                  :  flips bit (x->1-x), use in BitStringGenotype
+# * :replace[ c1,c2,...,cn ]  :  replaces the element with one of the arguments. use in StringGenotype.  Example: :replace[ *'a'..'z' ]
+# * :uniform[ max_size=0.25 ]:  adds a random number in the range [-max_size,+max_size], uniformly distributed.
+# * :gaussian[ sigma=0.2 ]   :  adds a random number, gaussian distributed with standard deviation sigma
+PointMutators = {
+  :replace => proc{|x,*pos| pos.at_rand },
+  :flip    => proc{|x| 1-x },
+  :uniform => Proc.new{|x,max_size| max_size ||= 0.25;  x - max_size + max_size * 2 * rand },
+  :gaussian=> Proc.new{|x,sigma|
+     sigma ||= 0.2;
+     delta = Math.sqrt(-2 * Math.log(rand)) * Math.cos(2 * Math::PI * rand)  # Box-Muller transformation
+     x + delta * sigma
+   }
+}
+
+# Generates a module which can be used as a mutator for array-based genotypes like FloatListGenotype, BitStringGenotype and StringGenotype
+# * strategy      should be one of the MutationStrategies, or a proc
+# * point_mutator should be one of the PointMutators, or a proc
+# * nil is equivalent to proc{} for the point mutator
+def ListMutator(strategy=:expected_n ,point_mutator=:uniform)
+  strat, *strat_args = *strategy
+  pm   , *pm_args    = *point_mutator
+
+  pm ||= proc{}
+
+  strat = MutationStrategies[strat.intern] unless strat.is_a? Proc
+  pm    = PointMutators[pm.intern]         unless pm.is_a? Proc
+  
+  raise ArgumentError,"Invalid mutation strategy" if strat.nil?
+  raise ArgumentError,"Invalid point mutator"     if point_mutator.nil?
+
+  if pm_args.empty?
+    point_mutator_with_args = pm    
+  else
+    point_mutator_with_args = proc{|*args| pm.call(*(args+pm_args) ) }
+  end
+
+  Module.new{
+    define_method(:mutate!) {
+      strat.call(@genes,point_mutator_with_args,*strat_args)
+      self
+    }
+    self.name= "ListMutator(#{strategy.inspect},#{point_mutator.inspect})"
+  }
+end
+
+

data/lib/charlie/mutate.rb

@@ -0,0 +1,25 @@
+# Contains some basic mutators and functions on mutators
+
+# Simply returns the non-mutated genes
+module NullMutator
+  def mutate!; self; end 
+end
+
+
+# Takes mutator m1 with probability p, and mutator m2 with probability 1-p
+def PMutate(p,m1,m2=NullMutator)
+  Module.new{
+    @@p = p
+    include m2
+    alias :mutate2! :mutate!
+    include m1
+    def mutate!(*args)
+      rand < @@p ? super(*args) : mutate2!(*args)
+    end
+    self.name= "PMutate(#{p},#{m1},#{m2})"
+  }
+end
+
+
+
+

data/lib/charlie/permutation/permutation.rb

@@ -0,0 +1,47 @@
+# Contains genotypes, crossovers and mutators for permutations
+
+# Generates a genotype class which represents a permutation of +elements+
+# Includes the PermutationMutator and PermutationCrossover by default
+def PermutationGenotype(n,elements=0...n)
+ elements = elements.chars if elements.is_a? String # string to array of chars
+ elements = elements.to_a
+ Class.new(Genotype) {
+  define_method(:size)    { n }
+  define_method(:elements){ elements }
+
+  def initialize
+    @genes = elements.dup.shuffle
+  end
+
+  def to_s
+    @genes.inspect
+  end
+  use PermutationMutator.dup , PermutationCrossover.dup
+ }
+end
+
+# Transposition mutator for PermutationGenotype
+module PermutationMutator
+
+  # Transposes two elements
+  def mutate!
+    i1, i2 = @genes.rand_index,@genes.rand_index 
+    @genes[i1],@genes[i2] = @genes[i2], @genes[i1]
+    self
+  end
+end
+
+# One point partial preservation crossover for PermutationGenotype
+# Child 1 is identical to parent 1 up to the cross point, and contains the remaining elements in the same order as parent 2.
+module PermutationCrossover
+  def cross(parent1,parent2)
+    p1, p2 = parent1.genes, parent2.genes
+    cross_pt = rand(p1.size+1)
+    st1, st2 =  p1[0...cross_pt],  p2[0...cross_pt]
+
+    [ st1 + (p2 - st1), st2 + (p1 - st2) ].map{|x| from_genes(x) }
+  end
+end
+
+
+