Added pyeo. Some changes needed to be made for include files and the like

in some files (and some bugs were fixed as well [Marc: eoOneToOneBreeder was a mess])

eoFunctor.h now contains static functor_category members, this shouldn't hurt anyone.

eo/src/pyeo/test/maxone.py

@@ -0,0 +1,81 @@
+
+import sys
+sys.path.append('..')
+
+print 'importing pyeo'
+from pyeo import *
+print 'done'
+
+from copy import copy
+
+
+class EvalFunc(eoEvalFunc):
+    def __call__(self, eo):
+	eo.fitness = reduce(lambda x,y: x+y, eo.genome, 0)
+
+class Init(eoInit):
+    def __init__(self, genome_length = 10):
+	eoInit.__init__(self)
+	self.length = genome_length
+    def __call__(self, eo):
+	eo.genome = [rng().flip(0.5) for x in range(self.length)]
+	
+class Mutate(eoMonOp):
+    def __call__(self, eo):
+	eo.genome = copy(eo.genome)
+
+	prob = 1. / len(eo.genome)
+	for i in range(len(eo.genome)):
+	    if rng().flip(0.5):
+		eo.genome[i] = 1-eo.genome[i];
+	return 1 
+
+class Crossover(eoQuadOp):
+    def __call__(self, eo1, eo2):
+	eo1.genome = copy(eo1.genome);
+	eo2.genome = copy(eo2.genome);
+
+	point = rng().random( len(eo1.genome) );
+
+	eo1.genome[:point] = eo2.genome[:point];
+	eo2.genome[point:] = eo1.genome[point:];
+	
+	return 1
+
+evaluate = EvalFunc()
+init = Init(3)
+mutate = Mutate()
+xover = Crossover()
+
+if __name__ == '__main__':
+    
+    eo = EO()
+    eo1 = EO()
+    
+    init(eo1)
+    init(eo)
+    evaluate(eo)
+    print eo
+    
+    for i in range(10):
+	xover(eo, eo1)
+	mutate(eo)
+	
+	evaluate(eo)
+	print eo, eo1
+  
+    print
+    print
+    print
+    
+    pop = Pop(1, init)
+    
+    pop[0] = eo;
+
+    mutate(pop[0])
+    pop[0].invalidate()
+    evaluate(pop[0])
+    
+    print pop[0], eo
+     
+

eo/src/pyeo/test/run_tests.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+for i in *.py
+do
+    python $i
+done
+
+

eo/src/pyeo/test/test_breeders.py

@@ -0,0 +1,37 @@
+from maxone import *
+import unittest
+	
+evaluate = EvalFunc()
+init = Init(20)
+mutate = Mutate()
+xover = Crossover()
+
+class TestSGA(unittest.TestCase):
+    
+    def runtest(self, breed):
+	
+	pop = Pop(50, init)
+	for indy in pop: evaluate(indy)
+	
+	newpop = Pop();
+
+	breed(pop,newpop)
+	
+	print pop.best()
+	for indy in newpop: evaluate(indy)
+	print newpop.best()
+
+    def testGeneralBreeder(self):
+	
+	seq = eoSequentialOp();
+	seq.add(xover, 0.7)
+	seq.add(mutate, 0.9)
+
+	sel = eoDetTournamentSelect(3)
+
+	breed = eoGeneralBreeder(sel, seq)
+
+	self.runtest(breed)
+
+if __name__=='__main__':
+    unittest.main()

eo/src/pyeo/test/test_pickling.py

@@ -0,0 +1,102 @@
+from maxone import *
+import unittest
+import cPickle
+import tempfile
+import os
+
+class TestPickling(unittest.TestCase):
+   
+    def do_pickle(self, object):
+    
+	filename = tempfile.mktemp()
+	file = open(filename, 'wb')
+	pickler = cPickle.Pickler(file)
+
+	pickler.dump(object);
+	del pickler
+	file.close()
+	
+	file = open(filename)
+	
+	unpickler = cPickle.Unpickler(file)
+
+	object2 = unpickler.load()
+
+	del unpickler
+	file.close()
+	os.remove(filename)
+
+	return object2
+
+    def testInvalidEO(self):
+	
+	eo = EO();
+	eo.genome = [1,2,3];
+	
+	eo2 = self.do_pickle(eo)
+	self.failUnlessEqual( str(eo), str(eo2) )
+
+    def testValidEO(self):
+	
+	eo = EO();
+	eo.genome = [1,2,3];
+	eo.fitness = 10
+
+	eo2 = self.do_pickle(eo)
+
+	self.failUnlessEqual( str(eo), str(eo2) )
+    
+    def testPop(self):
+	
+	pop = Pop(40, init)
+	for indy in pop: 
+	    evaluate(indy)
+
+	pop2 = self.do_pickle(pop)
+	
+	self.failUnlessEqual( str(pop), str(pop2) )
+
+    def testHowMany(self):
+	
+	howmany = eoHowMany(0.8);
+	howmany2 = self.do_pickle(howmany)
+
+	self.failUnlessEqual(howmany(10), howmany2(10))
+	self.failUnlessEqual( str(howmany), str(howmany) )
+
+    def testRNG(self):
+	
+	for i in range(10):
+	    rng().rand()
+	
+	filename = tempfile.mktemp()
+	file = open(filename, 'wb')
+	pickler = cPickle.Pickler(file)
+	
+	s = rng().to_string()
+
+	pickler.dump(s);
+	del pickler
+	file.close()
+	
+	file = open(filename)
+	
+	unpickler = cPickle.Unpickler(file)
+
+	s = unpickler.load()
+
+	rng2 = eoRng(1)
+	rng2.from_string(s)
+
+	del unpickler
+	file.close()
+	os.remove(filename)
+	
+	for i in range(100):
+	    a = rng().rand()
+	    b = rng2.rand()
+	    self.failUnlessEqual(a,b)
+
+
+if __name__=='__main__':
+    unittest.main()

eo/src/pyeo/test/test_populator.py

@@ -0,0 +1,86 @@
+print 'importing maxone'
+from maxone import *
+print 'done'
+import unittest
+
+class Mut(Mutate):
+    def __init__(self):
+	Mutate.__init__(self)
+	self.cnt = 0;
+    def __call__(self, eo):
+	self.cnt += 1;
+	return Mutate.__call__(self, eo)
+
+class Xover(Crossover):
+    def __init__(self):
+	Crossover.__init__(self)
+	self.cnt = 0;
+    def __call__(self, eo1, eo2):
+	self.cnt += 1;
+	return Crossover.__call__(self, eo1, eo2)
+
+class TestPopulator(unittest.TestCase):
+    
+    def make_pop(self):
+	pop = Pop(20, init)
+	for indy in pop: evaluate(indy)
+	return pop
+	
+    def test_sequential(self):
+	pop = self.make_pop()
+	populator = eoSeqPopulator(pop, pop)
+	
+	print populator.get()
+	print populator.get()
+    
+    def test_selective(self):
+	sel = eoDetTournamentSelect(2)
+	pop = self.make_pop()
+
+	populator = eoSelectivePopulator(pop, pop, sel)
+	
+	print populator.get()
+	print populator.get()
+
+    def runOpContainer(self, opcontainer):
+    	
+	mutate = Mut()
+	xover = Xover()
+	
+	print 'making seq'
+	seq = opcontainer()
+	
+	print "xovertype", xover.getType()
+	print "mutationtype", mutate.getType()
+
+	seq.add(mutate, 0.4)
+	seq.add(xover, 0.8)
+
+	pop = self.make_pop();
+	offspring = Pop()
+	
+	sel = eoDetTournamentSelect(2)
+    
+	print "making populator"
+	populator = eoSelectivePopulator(pop, offspring, sel)
+	print 'made'
+	
+	for i in xrange(1000):
+	    seq(populator)
+	
+	print mutate.cnt
+	print xover.cnt
+
+
+    def test_sequentialOp(self):
+	print '*'*20, "SequentialOp", '*'*20	
+	self.runOpContainer(eoSequentialOp)
+	
+    def test_proportionalOp(self):
+	print '*'*20, "ProportionalOp", '*'*20	
+	self.runOpContainer(eoProportionalOp)
+
+
+
+if __name__=='__main__':
+    unittest.main()

eo/src/pyeo/test/test_reduce.py

@@ -0,0 +1,34 @@
+from maxone import *
+import unittest
+
+class TestReduce(unittest.TestCase):
+    
+    def run_test(self, ReduceClass, Arg = None):
+	pop = Pop(10, init)
+	for indy in pop: evaluate(indy)
+	
+	if Arg:
+	    red = ReduceClass(Arg)
+	else:
+	    red = ReduceClass()
+
+	red(pop, 5);
+
+	self.failUnlessEqual( len(pop), 5) 
+    
+    def test_eoTruncate(self):
+	self.run_test(eoTruncate)
+    def test_eoRandomeReduce(self):
+	self.run_test(eoRandomReduce)
+    def test_eoEPRReduce(self):
+	self.run_test(eoEPReduce, 2)
+    def test_eoLinearTruncate(self):
+	self.run_test(eoLinearTruncate)
+    def test_eoDetTournamentTruncate(self):
+	self.run_test(eoDetTournamentTruncate, 2)
+    def test_eoStochTournamentTruncate(self):
+	self.run_test(eoStochTournamentTruncate, 0.9)
+	
+												 
+if __name__=='__main__':
+    unittest.main()

eo/src/pyeo/test/test_selectone.py

@@ -0,0 +1,66 @@
+from maxone import *
+import unittest
+
+class Init(eoInit):
+    def __call__(self, eo):
+	pass
+
+class TestSGA(unittest.TestCase):
+
+    def __init__(self, a):
+	unittest.TestCase.__init__(self, a)	
+	self.pop = Pop(4, Init())
+
+	for i in range(len(self.pop)):
+	   self.pop[i].fitness = i; 
+	
+
+    def do_test(self, selectOne):
+	
+	print '*'*20, "Testing", str(selectOne.__class__), '*'*20
+	selection = [0. for i in range(len(self.pop))]
+
+	nTries = 500
+	for i in range(nTries):
+	    selection[ selectOne(self.pop).fitness ] += 1
+	
+	for i in range(len(self.pop)):
+	    print i, selection[i], selection[i] / nTries
+	
+	return selection, nTries
+    
+    def test_eoDetTournamenSelect(self):
+	
+	selectOne = eoDetTournamentSelect(2)
+	self.do_test(selectOne)
+    
+    def test_eoRandomSelect(self):
+	selectOne = eoRandomSelect()
+	self.do_test(selectOne)
+
+    def test_eoBestSelect(self):
+	selectOne = eoBestSelect()
+	(sel, nTries) = self.do_test(selectOne)
+
+	self.failUnlessEqual(sel[0], 0);
+	self.failUnlessEqual(sel[-1], nTries);
+
+    def test_eoNoSelect(self):
+	selectOne = eoNoSelect()
+	self.do_test(selectOne)
+
+    def test_eoStochTournament(self):
+	selectOne = eoStochTournamentSelect(0.75)
+	self.do_test(selectOne)
+
+    def test_eoSequentialSelect(self):
+	selectOne = eoSequentialSelect();
+	self.do_test(selectOne)
+	
+    def test_eoEliteSequentialSelect(self):
+	selectOne = eoEliteSequentialSelect();
+	self.do_test(selectOne)
+	
+
+if __name__=='__main__':
+    unittest.main()

eo/src/pyeo/test/test_sga.py

@@ -0,0 +1,25 @@
+from maxone import *
+import unittest
+
+class TestSGA(unittest.TestCase):
+    
+    def test(self):
+	evaluate = EvalFunc()
+	init = Init(20)
+	mutate = Mutate()
+	xover = Crossover()
+
+	pop = Pop(50, init)
+	for indy in pop: evaluate(indy)
+
+	select = eoDetTournamentSelect(3);
+	cont = eoGenContinue(20);
+
+	sga = eoSGA(select, xover, 0.6, mutate, 0.4, evaluate, cont);
+
+	sga(pop)
+
+	print pop.best()
+
+if __name__=='__main__':
+    unittest.main()