move paradiseo/eo to deprecated/ before merge with eodev

deprecated/eo/src/pyeo/test/maxone.py

@@ -0,0 +1,88 @@
+import sys
+sys.path.append('..')
+
+print 'importing pyeo'
+from libPyEO import *
+print 'done'
+
+from copy import copy
+
+class MinimFit(float):
+    def __cmp__(self, other):
+        if other == None: # I seem to be getting None's, don't know why
+            return 1
+        return float.__cmp__(other, self)
+
+class EvalFunc(eoEvalFunc):
+    def __call__(self, eo):
+        eo.fitness = reduce(lambda x,y: x+y, eo.genome, 0)
+
+class MinEvalFunc(eoEvalFunc):
+    def __call__(self, eo):
+        f = reduce(lambda x,y: x+y, eo.genome, 0 )
+        eo.fitness = MinimFit(f)
+
+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 = eoPop(1, init)
+
+    pop[0] = eo;
+
+    mutate(pop[0])
+    pop[0].invalidate()
+    evaluate(pop[0])
+
+    print pop[0], eo

deprecated/eo/src/pyeo/test/run_tests.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+for i in *.py
+do
+    python2 $i > /dev/null
+
+done

deprecated/eo/src/pyeo/test/test_breeders.py

@@ -0,0 +1,30 @@
+from maxone import *
+import unittest
+
+class TestBreeders(unittest.TestCase):
+    def runtest(self, breed):
+	pop = eoPop(50, Init(20))
+	evaluate = EvalFunc()
+	print 'HERE'
+	for indy in pop: evaluate(indy)
+	newpop = eoPop();
+
+	breed(pop,newpop)
+
+	print pop.best()
+	for indy in newpop: evaluate(indy)
+	print newpop.best()
+
+    def testGeneralBreeder(self):
+	seq = eoSequentialOp();
+	seq.add(Crossover(), 0.7)
+	seq.add(Mutate(), 0.1)
+
+	breed = eoGeneralBreeder(eoDetTournamentSelect(3), seq)
+	self.runtest(breed)
+
+def suite():
+    return unittest.makeSuite(TestSGA,'test')
+
+if __name__=='__main__':
+    unittest.main()

deprecated/eo/src/pyeo/test/test_mo.py

@@ -0,0 +1,166 @@
+from maxone import *
+from math import exp
+import unittest
+
+class MyInit(eoInit):
+    def __call__(self, eo):
+	eo.genome = [rng().normal(), rng().normal(), rng().normal()];
+
+class MyMutate(eoMonOp):
+    def __call__(self, eo):
+	std = 0.05
+	eo.genome = copy(eo.genome)
+
+	eo.genome[0] += rng().normal() * std
+	eo.genome[1] += rng().normal() * std
+	eo.genome[2] += rng().normal() * std
+	return 1
+
+class AnEval(eoEvalFunc):
+    def __init__(self):
+	eoEvalFunc.__init__(self)
+
+	setObjectivesSize(2);
+	setObjectivesValue(0,1);
+	setObjectivesValue(1,1);
+
+    def __call__(self, eo):
+	x = abs(eo.genome[0])
+	y = abs(eo.genome[1])
+	z = abs(eo.genome[2])
+
+	eo.fitness = [ x / (x+y+z), y /(x+y+z) ]
+
+import Gnuplot
+
+g = Gnuplot.Gnuplot()
+g.reset()
+
+def do_plot(pop):
+    l1 = []
+    l2 = []
+
+    for indy in pop:
+	l1.append(indy.fitness[0])
+	l2.append(indy.fitness[1])
+
+    d = Gnuplot.Data(l1,l2, with = 'points')
+
+    d2 = Gnuplot.Data([0,1],[1,0], with='lines')
+
+    g.plot(d,d2)
+
+class NSGA_II(eoAlgo):
+    def __init__(self, ngens):
+	self.cont = eoGenContinue(ngens);
+
+	self.selectOne = eoDetTournamentSelect(2);
+	self.evaluate = AnEval()
+	self.mutate = MyMutate()
+	self.init = MyInit()
+
+	self.seq = eoProportionalOp()
+	self.seq.add(self.mutate, 1.0)
+
+	self.perf2worth = eoNDSorting_II()
+
+    def __call__(self, pop):
+	sz = len(pop)
+	i = 0
+	while self.cont(pop):
+	    newpop = eoPop()
+	    populator = eoSelectivePopulator(pop, newpop, self.selectOne);
+
+	    while len(newpop) < sz:
+		self.seq(populator)
+
+	    for indy in newpop:
+		self.evaluate(indy)
+		pop.push_back(indy)
+
+	    self.perf2worth(pop)
+	    self.perf2worth.sort_pop(pop)
+
+	    #print pop[0].fitness, pop[0].genome
+	    pop.resize(sz)
+
+	    #worth = self.perf2worth.getValue()
+	    #print worth[0], worth[sz-1]
+
+	    i += 1
+	    if i%100 == 0:
+		pass
+		do_plot(pop)
+
+	worths = self.perf2worth.getValue()
+
+	w0 = int(worths[0]-0.001)
+
+	for i in range(len(pop)):
+	    if worths[i] <= w0:
+		break;
+
+	    print pop[i].genome
+	    print pop[i].fitness
+
+class TestNSGA_II(unittest.TestCase):
+    def testIndividuals(self):
+	setObjectivesSize(2);
+	setObjectivesValue(0,1);
+	setObjectivesValue(1,1);
+
+	eo1 = EO();
+	eo2 = EO();
+
+	eo1.fitness = [0,1];
+	eo2.fitness = [1,1];
+
+	self.failUnlessEqual(dominates(eo1, eo2), 0)
+	self.failUnlessEqual(dominates(eo2, eo1), 1)
+	self.failUnlessEqual(dominates(eo2, eo2), 0)
+
+	setObjectivesValue(0,-1)
+	setObjectivesValue(1,-1);
+
+	self.failUnlessEqual(dominates(eo1, eo2), 1)
+	self.failUnlessEqual(dominates(eo2, eo1), 0)
+	self.failUnlessEqual(dominates(eo2, eo2), 0)
+
+    def testNDSorting(self):
+	setObjectivesSize(2);
+	setObjectivesValue(0,-1)
+	setObjectivesValue(1,-1);
+
+	pop = eoPop()
+	pop.resize(6)
+
+	pop[5].fitness = [0.15,0.87]
+	pop[4].fitness = [0.1,0.9]
+	pop[3].fitness = [0,1];
+	pop[2].fitness = [1,0];
+	pop[1].fitness = [1,1];
+	pop[0].fitness = [2,1];
+
+	srt = eoNDSorting_II()
+
+	srt(pop)
+	srt.sort_pop(pop)
+
+	for indy in pop:
+	    print indy.fitness
+
+	worths = srt.getValue()
+	print worths
+	print type(worths)
+
+    def testNSGA_II(self):
+	evaluate = AnEval();
+	pop = eoPop(25, MyInit())
+	for indy in pop: evaluate(indy)
+
+	nsga = NSGA_II(50)
+
+	nsga(pop)
+
+if __name__=='__main__':
+    unittest.main()

deprecated/eo/src/pyeo/test/test_pickling.py

@@ -0,0 +1,91 @@
+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 = eoPop(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()
+
+	rng2 = self.do_pickle(rng())
+
+	for i in range(100):
+	    a = rng().rand()
+	    b = rng2.rand()
+	    self.failUnlessEqual(a,b)
+
+    def vParam(self,v):
+	v2 = self.do_pickle(v);
+	self.failUnlessEqual(v.value, v2.value)
+
+    def testValueParam(self):
+	import Numeric
+
+	self.vParam(eoValueParamInt(42,'int'))
+	self.vParam(eoValueParamFloat(4.2,'float'))
+
+	v = eoValueParamVec()
+	v.value = Numeric.arange(10)
+	self.vParam(v)
+
+	v = eoValueParamPair()
+	v.value = (0.3,0.5)
+	self.vParam(v)
+
+if __name__=='__main__':
+    unittest.main()

deprecated/eo/src/pyeo/test/test_populator.py

@@ -0,0 +1,82 @@
+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 = eoPop(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 = eoPop()
+
+	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()

deprecated/eo/src/pyeo/test/test_reduce.py

@@ -0,0 +1,32 @@
+from maxone import *
+import unittest
+
+class TestReduce(unittest.TestCase):
+    def run_test(self, ReduceClass, Arg = None):
+	pop = eoPop(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()

deprecated/eo/src/pyeo/test/test_selectone.py

@@ -0,0 +1,62 @@
+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 = eoPop(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()

deprecated/eo/src/pyeo/test/test_sga.py

@@ -0,0 +1,45 @@
+from maxone import *
+import unittest
+
+class TestSGA(unittest.TestCase):
+    def dotestSGA(self, evaluate):
+        init = Init(20)
+        mutate = Mutate()
+        xover = Crossover()
+
+        pop = eoPop(50, init)
+        for indy in pop: evaluate(indy)
+
+        select = eoDetTournamentSelect(3);
+        cont1 = eoGenContinue(20);
+
+        cont = eoCheckPoint(cont1)
+
+        mon = eoGnuplot1DMonitor()
+
+        avg = eoAverageStat()
+        bst = eoBestFitnessStat()
+        mon.add(avg)
+        mon.add(bst)
+
+        # add it to the checkpoint
+        cont.add(avg)
+        #cont.add(mon)
+        cont.add(bst)
+
+        sga = eoSGA(select, xover, 0.6, mutate, 0.4, evaluate, cont);
+
+        sga(pop)
+
+        print pop.best()
+
+    def testSGA_Max(self):
+        evaluate = EvalFunc()
+        self.dotestSGA(evaluate)
+
+    def testSGA_Min(self):
+        evaluate = MinEvalFunc()
+        self.dotestSGA(evaluate)
+
+if __name__=='__main__':
+    unittest.main()

deprecated/eo/src/pyeo/test/test_transform.py

@@ -0,0 +1,62 @@
+"""Test script for the eoSGATranform class"""
+
+from copy import deepcopy
+from libPyEO import *
+from maxone import *
+
+pop = eoPop()
+
+for i in range(10):
+        eo = EO()
+        init(eo)
+        evaluate(eo)
+        pop.push_back(eo)
+
+transform = eoSGATransform(xover, 0.8, mutate, 0.2)
+
+def test1(pop, transform):
+        pop = deepcopy(pop)
+        print "test 1"
+        print "Initial population:"
+        print pop
+
+        transform(pop)
+
+        print "GM pop:"
+        print pop
+
+def test2(pop, transform):
+        pop = deepcopy(pop)
+
+        print "test 2"
+        print "Initial population"
+        print pop
+
+        checkpoint = eoCheckPoint(eoGenContinue(50))
+        select = eoSelectNumber(eoDetTournamentSelect(3), 10)
+        replace = eoGenerationalReplacement()
+
+        algo = eoEasyEA(checkpoint, evaluate, select, transform, replace)
+        algo(pop)
+
+        print "Evoluated pop:"
+        print pop
+
+if __name__ == "__main__":
+        try:
+                test1(pop, transform)
+        except:
+                import sys
+                print
+                print "Caught an exception:"
+                print sys.exc_type, sys.exc_value
+                print
+
+        try:
+                test2(pop, transform)
+        except:
+                import sys
+                print
+                print "Caught an exception:"
+                print sys.exc_type, sys.exc_value
+                print