* indentations + whitespace cleanup
This commit is contained in:
Caner Candan
parent
8457e39efe
commit
56c6edab04
285 changed files with 6068 additions and 6223 deletions
|
|
@ -1,37 +1,35 @@
|
|||
# Note for however is foolish enough to attempt to build this thing
|
||||
#
|
||||
# You need:
|
||||
# You need:
|
||||
# Python 2.2
|
||||
# Boost.Python v2
|
||||
#
|
||||
|
||||
CXX = g++
|
||||
CXX = g++
|
||||
CPPFLAGS = -Wall -O2 #-g #-O2
|
||||
LDFLAGS =
|
||||
LDFLAGS =
|
||||
COMPILE = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c
|
||||
LINK = $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)
|
||||
INC=-I/usr/include/python2.6 -I.. -I../.. -ftemplate-depth-50
|
||||
LINK = $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)
|
||||
INC=-I/usr/include/python2.6 -I.. -I../.. -ftemplate-depth-50
|
||||
|
||||
OBJECTS=eoFunctorStore.o PyEO.o abstract1.o algos.o \
|
||||
random_numbers.o geneticOps.o selectOne.o continuators.o\
|
||||
reduce.o replacement.o selectors.o breeders.o\
|
||||
mergers.o valueParam.o perf2worth.o monitors.o\
|
||||
statistics.o
|
||||
random_numbers.o geneticOps.o selectOne.o continuators.o\
|
||||
reduce.o replacement.o selectors.o breeders.o\
|
||||
mergers.o valueParam.o perf2worth.o monitors.o\
|
||||
statistics.o
|
||||
|
||||
LIB=../libeo.a ../utils/libeoutils.a
|
||||
|
||||
all: PyEO/PyEO.so
|
||||
|
||||
clean:
|
||||
rm PyEO/*.so *.o test/*.pyc
|
||||
rm PyEO/*.so *.o test/*.pyc
|
||||
|
||||
PyEO/PyEO.so: $(OBJECTS)
|
||||
$(LINK) -o PyEO/PyEO.so $(OBJECTS) -lboost_python -lpython2.6 ${LIB} -shared #-lstlport
|
||||
$(LINK) -o PyEO/PyEO.so $(OBJECTS) -lboost_python -lpython2.6 ${LIB} -shared #-lstlport
|
||||
|
||||
eoFunctorStore.o: ../eoFunctorStore.h ../eoFunctorStore.cpp
|
||||
$(COMPILE) -o eoFunctorStore.o ../eoFunctorStore.cpp $(INC)
|
||||
|
||||
%.o:%.cpp PyEO.h def_abstract_functor.h
|
||||
$(COMPILE) $< $(INC)
|
||||
|
||||
$(COMPILE) -o eoFunctorStore.o ../eoFunctorStore.cpp $(INC)
|
||||
|
||||
%.o:%.cpp PyEO.h def_abstract_functor.h
|
||||
$(COMPILE) $< $(INC)
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ CXXFLAGS = #-g #-DNDEBUG
|
|||
CPPFLAGS = -Wall -O2
|
||||
LDFLAGS = -L/usr/lib/python2.2/config/
|
||||
COMPILE = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c
|
||||
LINK = $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)
|
||||
LINK = $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)
|
||||
INC=-I/usr/include/python2.2 -I/usr/include/stlport -I.. -ftemplate-depth-50
|
||||
|
||||
OBJECTS=eoFunctorStore.o PyEO.o abstract1.o algos.o \
|
||||
|
|
@ -25,7 +25,5 @@ PyEO.so: $(OBJECTS)
|
|||
eoFunctorStore.o: ../eoFunctorStore.h ../eoFunctorStore.cpp
|
||||
$(COMPILE) -o eoFunctorStore.o ../eoFunctorStore.cpp $(INC)
|
||||
|
||||
%.o:%.cpp PyEO.h def_abstract_functor.h
|
||||
%.o:%.cpp PyEO.h def_abstract_functor.h
|
||||
$(COMPILE) $< $(INC)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -21,112 +21,113 @@
|
|||
#ifndef PYEO_H
|
||||
#define PYEO_H
|
||||
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <exception>
|
||||
#include <boost/python.hpp>
|
||||
|
||||
#include <EO.h>
|
||||
struct index_error : public std::exception {
|
||||
index_error(std::string w) : what(w) {};
|
||||
|
||||
struct index_error : public std::exception
|
||||
{
|
||||
index_error(std::string w) : what(w) {};
|
||||
virtual ~index_error() throw() {}
|
||||
std::string what;
|
||||
std::string what;
|
||||
};
|
||||
|
||||
class PyFitness : public boost::python::object
|
||||
{
|
||||
public :
|
||||
|
||||
public :
|
||||
|
||||
typedef PyFitness fitness_traits; // it's its own traits class :-)
|
||||
|
||||
|
||||
PyFitness() : boost::python::object() {}
|
||||
|
||||
|
||||
template <class T>
|
||||
PyFitness(const T& o) : boost::python::object(o) {}
|
||||
|
||||
|
||||
static unsigned nObjectives() { return objective_info.size(); }
|
||||
static double tol() { return 1e-6; }
|
||||
static bool maximizing(int which) { return objective_info[which] > 0; }
|
||||
|
||||
|
||||
static void setObjectivesSize(int sz) { objective_info.resize(sz, 0); }
|
||||
static void setObjectivesValue(unsigned which, int value)
|
||||
{
|
||||
if (which >= objective_info.size())
|
||||
{
|
||||
throw index_error("Too few elements allocated, resize objectives first");
|
||||
}
|
||||
if (which >= objective_info.size())
|
||||
{
|
||||
throw index_error("Too few elements allocated, resize objectives first");
|
||||
}
|
||||
|
||||
objective_info[which] = value;
|
||||
objective_info[which] = value;
|
||||
}
|
||||
|
||||
|
||||
static std::vector<int> objective_info;
|
||||
|
||||
|
||||
bool dominates(const PyFitness& oth) const;
|
||||
|
||||
double operator[](int i) const
|
||||
{
|
||||
boost::python::extract<double> x(object::operator[](i));
|
||||
|
||||
if (!x.check())
|
||||
throw std::runtime_error("PyFitness: does not contain doubles");
|
||||
return x();
|
||||
}
|
||||
|
||||
bool operator<(const PyFitness& other) const
|
||||
{
|
||||
if (objective_info.size() == 0)
|
||||
{
|
||||
const object& self = *this;
|
||||
const object& oth = other;
|
||||
return self < oth;
|
||||
}
|
||||
// otherwise use objective_info
|
||||
|
||||
for (unsigned i = 0; i < objective_info.size(); ++i)
|
||||
{
|
||||
double a = objective_info[i] * operator[](i);
|
||||
double b = objective_info[i] * other[i];
|
||||
|
||||
if ( fabs(a - b) > tol())
|
||||
{
|
||||
if (a < b)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
double operator[](int i) const
|
||||
{
|
||||
boost::python::extract<double> x(object::operator[](i));
|
||||
|
||||
return false;
|
||||
if (!x.check())
|
||||
throw std::runtime_error("PyFitness: does not contain doubles");
|
||||
return x();
|
||||
}
|
||||
|
||||
bool operator>(const PyFitness& other) const
|
||||
{
|
||||
return other.operator<(*this);
|
||||
|
||||
bool operator<(const PyFitness& other) const
|
||||
{
|
||||
if (objective_info.size() == 0)
|
||||
{
|
||||
const object& self = *this;
|
||||
const object& oth = other;
|
||||
return self < oth;
|
||||
}
|
||||
// otherwise use objective_info
|
||||
|
||||
for (unsigned i = 0; i < objective_info.size(); ++i)
|
||||
{
|
||||
double a = objective_info[i] * operator[](i);
|
||||
double b = objective_info[i] * other[i];
|
||||
|
||||
if ( fabs(a - b) > tol())
|
||||
{
|
||||
if (a < b)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool operator>(const PyFitness& other) const
|
||||
{
|
||||
return other.operator<(*this);
|
||||
}
|
||||
|
||||
void printOn(std::ostream& os) const { const boost::python::object& o = *this; boost::python::api::operator<<(os,o); }
|
||||
friend std::ostream& operator<<(std::ostream& os, const PyFitness& p) { p.printOn(os); return os; }
|
||||
friend std::istream& operator>>(std::istream& is, PyFitness& p) { boost::python::object o; is >> o; p = o; return is; }
|
||||
};
|
||||
|
||||
struct PyEO : public EO< PyFitness >
|
||||
{
|
||||
{
|
||||
typedef PyFitness Fitness;
|
||||
|
||||
|
||||
boost::python::object getFitness() const { return invalid()? Fitness(): fitness(); }
|
||||
void setFitness(boost::python::object f) { if (f == Fitness()) invalidate(); else fitness(f); }
|
||||
|
||||
boost::python::object getGenome() const { return genome; }
|
||||
void setGenome(boost::python::object g) { genome = g; }
|
||||
boost::python::object genome;
|
||||
|
||||
|
||||
std::string to_string() const
|
||||
{
|
||||
std::string result;
|
||||
result += boost::python::extract<const char*>(boost::python::str(getFitness()));
|
||||
result += ' ';
|
||||
result += boost::python::extract<const char*>(boost::python::str(genome));
|
||||
return result;
|
||||
std::string result;
|
||||
result += boost::python::extract<const char*>(boost::python::str(getFitness()));
|
||||
result += ' ';
|
||||
result += boost::python::extract<const char*>(boost::python::str(genome));
|
||||
return result;
|
||||
}
|
||||
|
||||
bool operator<(const PyEO& other) const { return EO<Fitness>::operator<(other); }
|
||||
|
|
@ -139,17 +140,16 @@ std::ostream& operator<<(std::ostream& os, const PyEO& _eo);
|
|||
struct PyEO_pickle_suite : boost::python::pickle_suite
|
||||
{
|
||||
typedef PyEO::Fitness Fitness;
|
||||
|
||||
static
|
||||
boost::python::tuple getstate(const PyEO& _eo)
|
||||
|
||||
static boost::python::tuple getstate(const PyEO& _eo)
|
||||
{
|
||||
return boost::python::make_tuple(_eo.getFitness(), _eo.genome);
|
||||
return boost::python::make_tuple(_eo.getFitness(), _eo.genome);
|
||||
}
|
||||
static
|
||||
void setstate(PyEO& _eo, boost::python::tuple pickled)
|
||||
|
||||
static void setstate(PyEO& _eo, boost::python::tuple pickled)
|
||||
{
|
||||
_eo.setFitness( Fitness(pickled[0]) );
|
||||
_eo.genome = pickled[1];
|
||||
_eo.setFitness( Fitness(pickled[0]) );
|
||||
_eo.genome = pickled[1];
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
from PyEO import *
|
||||
|
||||
try:
|
||||
|
|
@ -8,80 +7,77 @@ except ImportError:
|
|||
else:
|
||||
|
||||
class eoGnuplot1DMonitor(eoMonitor):
|
||||
def __init__(self):
|
||||
eoMonitor.__init__(self)
|
||||
self.values = []
|
||||
self.indices = []
|
||||
self.g = Gnuplot.Gnuplot()
|
||||
self.g.reset();
|
||||
|
||||
|
||||
def handleParam(self, i, param):
|
||||
param = float(param)
|
||||
def __init__(self):
|
||||
eoMonitor.__init__(self)
|
||||
self.values = []
|
||||
self.indices = []
|
||||
self.g = Gnuplot.Gnuplot()
|
||||
self.g.reset();
|
||||
|
||||
while len(self.values) <= i:
|
||||
self.values.append( [] )
|
||||
def handleParam(self, i, param):
|
||||
param = float(param)
|
||||
|
||||
self.values[i].append(param)
|
||||
|
||||
def __call__(self):
|
||||
|
||||
l = len(self)
|
||||
while len(self.values) <= i:
|
||||
self.values.append( [] )
|
||||
|
||||
if l > 3 or l == 0:
|
||||
print 'Can only handle 1 to 3 params currently'
|
||||
|
||||
i = 0
|
||||
for param in self:
|
||||
self.handleParam(i,param)
|
||||
i += 1
|
||||
|
||||
self.indices.append( len(self.indices) )
|
||||
self.values[i].append(param)
|
||||
|
||||
def __call__(self):
|
||||
l = len(self)
|
||||
|
||||
if l > 3 or l == 0:
|
||||
print 'Can only handle 1 to 3 params currently'
|
||||
|
||||
i = 0
|
||||
for param in self:
|
||||
self.handleParam(i,param)
|
||||
i += 1
|
||||
|
||||
self.indices.append( len(self.indices) )
|
||||
|
||||
|
||||
data1 = Gnuplot.Data(self.indices, self.values[0], with = 'lines')
|
||||
|
||||
if l == 1:
|
||||
self.g.plot(data1)
|
||||
else:
|
||||
data2 = Gnuplot.Data(self.indices, self.values[1], with = 'lines')
|
||||
data1 = Gnuplot.Data(self.indices, self.values[0], with = 'lines')
|
||||
|
||||
if l == 2:
|
||||
self.g.plot(data1, data2)
|
||||
else:
|
||||
data3 = Gnuplot.Data(self.indices, self.values[2], with = 'lines')
|
||||
if l == 1:
|
||||
self.g.plot(data1)
|
||||
else:
|
||||
data2 = Gnuplot.Data(self.indices, self.values[1], with = 'lines')
|
||||
|
||||
self.g.plot(data1, data2, data3)
|
||||
if l == 2:
|
||||
self.g.plot(data1, data2)
|
||||
else:
|
||||
data3 = Gnuplot.Data(self.indices, self.values[2], with = 'lines')
|
||||
|
||||
self.g.plot(data1, data2, data3)
|
||||
|
||||
def SeperatedVolumeMonitor(eoMonitor):
|
||||
def __init__(self, file):
|
||||
eoMonitor.__init__(self)
|
||||
self.file = file
|
||||
self.initialized = None;
|
||||
eoMonitor.__init__(self)
|
||||
self.file = file
|
||||
self.initialized = None;
|
||||
|
||||
def __call__(self):
|
||||
pass
|
||||
pass
|
||||
|
||||
class eoStat(eoStatBase, eoValueParam):
|
||||
def __init__(self):
|
||||
eoStatBase.__init__(self)
|
||||
eoValueParam.__init__(self)
|
||||
|
||||
eoStatBase.__init__(self)
|
||||
eoValueParam.__init__(self)
|
||||
|
||||
class eoSortedStat(eoSortedStatBase, eoValueParam):
|
||||
def __init__(self):
|
||||
eoSortedStatBase.__init__(self)
|
||||
eoValueParam.__init__(self)
|
||||
eoSortedStatBase.__init__(self)
|
||||
eoValueParam.__init__(self)
|
||||
|
||||
class eoAverageStat(eoStat):
|
||||
def __call__(self, pop):
|
||||
sum = 0.0;
|
||||
for indy in pop:
|
||||
sum += indy.fitness
|
||||
sum = 0.0;
|
||||
for indy in pop:
|
||||
sum += indy.fitness
|
||||
|
||||
sum /= len(pop)
|
||||
self.object = sum
|
||||
sum /= len(pop)
|
||||
self.object = sum
|
||||
|
||||
class eoBestFitnessStat(eoSortedStat):
|
||||
|
||||
def __call__(self, pop):
|
||||
self.object = pop[0].fitness
|
||||
self.object = pop[0].fitness
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -34,13 +34,19 @@ void abstract1()
|
|||
/* Abstract Classes: overrideble from python */
|
||||
def_abstract_functor<eoEvalFunc<PyEO> >("eoEvalFunc");
|
||||
def_abstract_functor<eoInit< PyEO > >("eoInit");
|
||||
|
||||
|
||||
def_abstract_functor<eoTransform<PyEO> >("eoTransform");
|
||||
|
||||
class_<eoSGATransform<PyEO>, bases<eoTransform<PyEO> > >("eoSGATransform",
|
||||
init< eoQuadOp<PyEO>&, double,
|
||||
eoMonOp<PyEO>&, double>())
|
||||
.def("__call__", &eoSGATransform<PyEO>::operator());
|
||||
|
||||
|
||||
class_<eoSGATransform<PyEO>, bases<eoTransform<PyEO> > >
|
||||
("eoSGATransform",
|
||||
init<
|
||||
eoQuadOp<PyEO>&,
|
||||
double,
|
||||
eoMonOp<PyEO>&,
|
||||
double
|
||||
>()
|
||||
)
|
||||
.def("__call__", &eoSGATransform<PyEO>::operator());
|
||||
|
||||
def_abstract_functor<eoPopEvalFunc<PyEO> >("eoPopEvalFunc");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -31,76 +31,96 @@ using namespace boost::python;
|
|||
void algos()
|
||||
{
|
||||
def_abstract_functor<eoAlgo<PyEO> >("eoAlgo");
|
||||
|
||||
|
||||
/* Algorithms */
|
||||
class_<eoSGA<PyEO>, bases<eoAlgo<PyEO> >, boost::noncopyable>("eoSGA",
|
||||
init<eoSelectOne<PyEO>&,
|
||||
eoQuadOp<PyEO>&, float,
|
||||
eoMonOp<PyEO>&, float,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoContinue<PyEO>&>()
|
||||
[
|
||||
with_custodian_and_ward<1,2,
|
||||
with_custodian_and_ward<1,3,
|
||||
with_custodian_and_ward<1,5,
|
||||
with_custodian_and_ward<1,7,
|
||||
with_custodian_and_ward<1,8>
|
||||
>
|
||||
>
|
||||
>
|
||||
>()
|
||||
])
|
||||
.def("__call__", &eoSGA<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoEasyEA<PyEO>, bases<eoAlgo<PyEO> > >("eoEasyEA",
|
||||
init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoBreed<PyEO>&,
|
||||
eoReplacement<PyEO>& >() )
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoPopEvalFunc<PyEO>&,
|
||||
eoBreed<PyEO>&,
|
||||
eoReplacement<PyEO>&>() )
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoBreed<PyEO>&,
|
||||
eoMerge<PyEO>&,
|
||||
eoReduce<PyEO>& >() )
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelect<PyEO>&,
|
||||
eoTransform<PyEO>&,
|
||||
eoReplacement<PyEO>&>())
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelect<PyEO>&,
|
||||
eoTransform<PyEO>&,
|
||||
eoMerge<PyEO>&,
|
||||
eoReduce<PyEO>&>())
|
||||
.def("__call__", &eoEasyEA<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoSGA<PyEO>, bases<eoAlgo<PyEO> >, boost::noncopyable>
|
||||
("eoSGA",
|
||||
init<
|
||||
eoSelectOne<PyEO>&,
|
||||
eoQuadOp<PyEO>&,
|
||||
float,
|
||||
eoMonOp<PyEO>&,
|
||||
float,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoContinue<PyEO>&
|
||||
>()
|
||||
[
|
||||
with_custodian_and_ward<1,2,
|
||||
with_custodian_and_ward<1,3,
|
||||
with_custodian_and_ward<1,5,
|
||||
with_custodian_and_ward<1,7,
|
||||
with_custodian_and_ward<1,8>
|
||||
>
|
||||
>
|
||||
>
|
||||
>()
|
||||
]
|
||||
)
|
||||
.def("__call__", &eoSGA<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoEasyEA<PyEO>, bases<eoAlgo<PyEO> > >
|
||||
("eoEasyEA",
|
||||
init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoBreed<PyEO>&,
|
||||
eoReplacement<PyEO>&
|
||||
>()
|
||||
)
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoBreed<PyEO>&,
|
||||
eoReplacement<PyEO>&,
|
||||
unsigned
|
||||
>() )
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoPopEvalFunc<PyEO>&,
|
||||
eoBreed<PyEO>&,
|
||||
eoReplacement<PyEO>&
|
||||
>() )
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoBreed<PyEO>&,
|
||||
eoMerge<PyEO>&,
|
||||
eoReduce<PyEO>&
|
||||
>() )
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelect<PyEO>&,
|
||||
eoTransform<PyEO>&,
|
||||
eoReplacement<PyEO>&
|
||||
>() )
|
||||
.def( init<
|
||||
eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelect<PyEO>&,
|
||||
eoTransform<PyEO>&,
|
||||
eoMerge<PyEO>&,
|
||||
eoReduce<PyEO>&
|
||||
>() )
|
||||
.def("__call__", &eoEasyEA<PyEO>::operator())
|
||||
;
|
||||
|
||||
/*
|
||||
class_<eoCellularEasyEA<PyEO>, bases< eoAlgo<PyEO> > >("eoCellularEasyEA",
|
||||
init< eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelectOne<PyEO>&,
|
||||
eoBinOp<PyEO>&,
|
||||
eoMonOp<PyEO>&,
|
||||
eoSelectOne<PyEO>&>())
|
||||
.def(
|
||||
init< eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelectOne<PyEO>&,
|
||||
eoQuadOp<PyEO>&,
|
||||
eoMonOp<PyEO>&,
|
||||
eoSelectOne<PyEO>&>())
|
||||
;
|
||||
class_<eoCellularEasyEA<PyEO>, bases< eoAlgo<PyEO> > >("eoCellularEasyEA",
|
||||
init< eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelectOne<PyEO>&,
|
||||
eoBinOp<PyEO>&,
|
||||
eoMonOp<PyEO>&,
|
||||
eoSelectOne<PyEO>&>())
|
||||
.def(
|
||||
init< eoContinue<PyEO>&,
|
||||
eoEvalFunc<PyEO>&,
|
||||
eoSelectOne<PyEO>&,
|
||||
eoQuadOp<PyEO>&,
|
||||
eoMonOp<PyEO>&,
|
||||
eoSelectOne<PyEO>&>())
|
||||
;
|
||||
*/
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -27,9 +27,19 @@
|
|||
|
||||
using namespace boost::python;
|
||||
|
||||
#define DEF3(x, i1, i2) class_<x<PyEO>, bases<eoBreed<PyEO > > >(#x, \
|
||||
init<i1, i2 >()[with_custodian_and_ward<1,2,with_custodian_and_ward<1,3> >()])\
|
||||
.def("__call__", &eoBreed<PyEO>::operator())
|
||||
#define DEF3(x, i1, i2) \
|
||||
class_<x<PyEO>, bases<eoBreed<PyEO > > > \
|
||||
(#x, \
|
||||
init<i1, i2 >() \
|
||||
[ \
|
||||
with_custodian_and_ward<1,2, \
|
||||
with_custodian_and_ward<1,3 \
|
||||
> \
|
||||
> \
|
||||
() \
|
||||
] \
|
||||
) \
|
||||
.def("__call__", &eoBreed<PyEO>::operator())
|
||||
|
||||
void breeders()
|
||||
{
|
||||
|
|
@ -38,14 +48,12 @@ void breeders()
|
|||
DEF3(eoSelectTransform, eoSelect<PyEO>&, eoTransform<PyEO>&);
|
||||
|
||||
DEF3(eoGeneralBreeder, eoSelectOne<PyEO>&, eoGenOp<PyEO>&)
|
||||
.def( init<eoSelectOne<PyEO>&, eoGenOp<PyEO>&, double>()[WC2])
|
||||
.def( init<eoSelectOne<PyEO>&, eoGenOp<PyEO>&, double, bool>()[WC2] )
|
||||
.def( init<eoSelectOne<PyEO>&, eoGenOp<PyEO>&, eoHowMany>() );
|
||||
.def( init<eoSelectOne<PyEO>&, eoGenOp<PyEO>&, double>()[WC2])
|
||||
.def( init<eoSelectOne<PyEO>&, eoGenOp<PyEO>&, double, bool>()[WC2] )
|
||||
.def( init<eoSelectOne<PyEO>&, eoGenOp<PyEO>&, eoHowMany>() );
|
||||
|
||||
|
||||
DEF3(eoOneToOneBreeder, eoGenOp<PyEO>&, eoEvalFunc<PyEO>&)
|
||||
.def( init<eoGenOp<PyEO>&, eoEvalFunc<PyEO>&, double>()[WC2] )
|
||||
.def( init<eoGenOp<PyEO>&, eoEvalFunc<PyEO>&, double, eoHowMany>()[WC2] );
|
||||
|
||||
.def( init<eoGenOp<PyEO>&, eoEvalFunc<PyEO>&, double>()[WC2] )
|
||||
.def( init<eoGenOp<PyEO>&, eoEvalFunc<PyEO>&, double, eoHowMany>()[WC2] );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -40,28 +40,34 @@ void add_checkpoint();
|
|||
void continuators()
|
||||
{
|
||||
/* Counters, wrappers etc */
|
||||
|
||||
class_<eoEvalFuncCounter<PyEO>, bases<eoEvalFunc<PyEO> > >("eoEvalFuncCounter",
|
||||
init< eoEvalFunc<PyEO>&, std::string>())
|
||||
.def("__call__", &eoEvalFuncCounter<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoEvalFuncCounter<PyEO>, bases<eoEvalFunc<PyEO> > >
|
||||
("eoEvalFuncCounter",
|
||||
init< eoEvalFunc<PyEO>&, std::string>()
|
||||
)
|
||||
.def("__call__", &eoEvalFuncCounter<PyEO>::operator())
|
||||
;
|
||||
/* Continuators */
|
||||
def_abstract_functor<eoContinue<PyEO> >("eoContinue");
|
||||
|
||||
class_<eoGenContinue<PyEO>, bases<eoContinue<PyEO> >, boost::noncopyable >("eoGenContinue", init<unsigned long>() )
|
||||
.def("__call__", &eoGenContinue<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoCombinedContinue<PyEO>, bases<eoContinue<PyEO> > >("eoCombinedContinue", init<eoContinue<PyEO>&>()[WC1])
|
||||
.def( init<eoContinue<PyEO>&, eoContinue<PyEO>& >()[WC2] )
|
||||
.def("add", &eoCombinedContinue<PyEO>::add, WC1)
|
||||
.def("__call__", &eoCombinedContinue<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoEvalContinue<PyEO>, bases<eoContinue<PyEO> > >("eoEvalContinue",
|
||||
init<eoEvalFuncCounter<PyEO>&, unsigned long>()[WC1])
|
||||
.def("__call__", &eoEvalContinue<PyEO>::operator())
|
||||
;
|
||||
def_abstract_functor<eoContinue<PyEO> >("eoContinue");
|
||||
|
||||
class_<eoGenContinue<PyEO>, bases<eoContinue<PyEO> >, boost::noncopyable >
|
||||
("eoGenContinue", init<unsigned long>() )
|
||||
.def("__call__", &eoGenContinue<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoCombinedContinue<PyEO>, bases<eoContinue<PyEO> > >
|
||||
("eoCombinedContinue", init<eoContinue<PyEO>&>()[WC1])
|
||||
.def( init<eoContinue<PyEO>&, eoContinue<PyEO>& >()[WC2] )
|
||||
.def("add", &eoCombinedContinue<PyEO>::add, WC1)
|
||||
.def("__call__", &eoCombinedContinue<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoEvalContinue<PyEO>, bases<eoContinue<PyEO> > >
|
||||
("eoEvalContinue",
|
||||
init<eoEvalFuncCounter<PyEO>&, unsigned long>()[WC1]
|
||||
)
|
||||
.def("__call__", &eoEvalContinue<PyEO>::operator())
|
||||
;
|
||||
|
||||
DEF2(eoFitContinue, object); // object is the fitness type
|
||||
|
||||
|
|
@ -77,14 +83,14 @@ void addSortedStat(eoCheckPoint<PyEO>& c, eoSortedStatBase<PyEO>& s) { c.add(s);
|
|||
|
||||
void add_checkpoint()
|
||||
{
|
||||
class_<eoCheckPoint<PyEO>, bases< eoContinue<PyEO> > >("eoCheckPoint",
|
||||
|
||||
init<eoContinue<PyEO>&> ()[with_custodian_and_ward<1,2>()]
|
||||
)
|
||||
.def("add", addContinue, with_custodian_and_ward<1,2>() )
|
||||
.def("add", addMonitor, with_custodian_and_ward<1,2>() )
|
||||
.def("add", addStat, with_custodian_and_ward<1,2>())
|
||||
.def("add", addSortedStat, with_custodian_and_ward<1,2>())
|
||||
.def("__call__", &eoCheckPoint<PyEO>::operator())
|
||||
;
|
||||
class_<eoCheckPoint<PyEO>, bases< eoContinue<PyEO> > >
|
||||
("eoCheckPoint",
|
||||
init<eoContinue<PyEO>&> ()[with_custodian_and_ward<1,2>()]
|
||||
)
|
||||
.def("add", addContinue, with_custodian_and_ward<1,2>() )
|
||||
.def("add", addMonitor, with_custodian_and_ward<1,2>() )
|
||||
.def("add", addStat, with_custodian_and_ward<1,2>())
|
||||
.def("add", addSortedStat, with_custodian_and_ward<1,2>())
|
||||
.def("__call__", &eoCheckPoint<PyEO>::operator())
|
||||
;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -23,104 +23,104 @@
|
|||
|
||||
#include <eoFunctor.h>
|
||||
|
||||
// DEFINES for call
|
||||
// DEFINES for call
|
||||
#define WC1 boost::python::with_custodian_and_ward<1,2>()
|
||||
#define WC2 boost::python::with_custodian_and_ward<1,2, with_custodian_and_ward<1,3> >()
|
||||
|
||||
namespace eoutils {
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
template <class Proc>
|
||||
class ProcWrapper : public Proc
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
ProcWrapper(PyObject* s) : self(s) {}
|
||||
using namespace boost::python;
|
||||
|
||||
typename Proc::result_type operator()(void)
|
||||
template <class Proc>
|
||||
class ProcWrapper : public Proc
|
||||
{
|
||||
return boost::python::call_method<typename Proc::result_type>(self, "__call__");
|
||||
}
|
||||
};
|
||||
|
||||
template <class Proc>
|
||||
void make_abstract_functor(std::string name, typename eoFunctorBase::procedure_tag)
|
||||
{
|
||||
typedef ProcWrapper<Proc> Wrapper;
|
||||
boost::python::class_<Proc, Wrapper,boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator());
|
||||
}
|
||||
|
||||
template <class Proc>
|
||||
void make_abstract_functor_ref(std::string name, typename eoFunctorBase::procedure_tag)
|
||||
{
|
||||
typedef ProcWrapper<Proc> Wrapper;
|
||||
boost::python::class_<Proc, Wrapper,boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator(), boost::python::return_internal_reference<>());
|
||||
}
|
||||
|
||||
template <class Unary>
|
||||
class UnaryWrapper : public Unary
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
UnaryWrapper(PyObject* s) : self(s) {}
|
||||
PyObject* self;
|
||||
ProcWrapper(PyObject* s) : self(s) {}
|
||||
|
||||
typename Unary::result_type operator()(typename Unary::argument_type a)
|
||||
{
|
||||
return boost::python::call_method<typename Unary::result_type>(self, "__call__", boost::ref(a) );
|
||||
}
|
||||
};
|
||||
typename Proc::result_type operator()(void)
|
||||
{
|
||||
return boost::python::call_method<typename Proc::result_type>(self, "__call__");
|
||||
}
|
||||
};
|
||||
|
||||
template <class Unary>
|
||||
void make_abstract_functor(std::string name, typename eoFunctorBase::unary_function_tag)
|
||||
{
|
||||
typedef UnaryWrapper<Unary> Wrapper;
|
||||
|
||||
boost::python::class_<Unary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator())
|
||||
;
|
||||
}
|
||||
|
||||
template <class Unary>
|
||||
void make_abstract_functor_ref(std::string name, typename eoFunctorBase::unary_function_tag)
|
||||
{
|
||||
typedef UnaryWrapper<Unary> Wrapper;
|
||||
|
||||
boost::python::class_<Unary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator(), boost::python::return_internal_reference<>() )
|
||||
;
|
||||
}
|
||||
|
||||
template <class Binary>
|
||||
class BinaryWrapper : public Binary
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
BinaryWrapper(PyObject* s) : self(s) {}
|
||||
typename Binary::result_type operator()(typename Binary::first_argument_type a1, typename Binary::second_argument_type a2)
|
||||
template <class Proc>
|
||||
void make_abstract_functor(std::string name, typename eoFunctorBase::procedure_tag)
|
||||
{
|
||||
return boost::python::call_method<
|
||||
typename Binary::result_type>(self, "__call__", boost::ref(a1), boost::ref(a2) );
|
||||
typedef ProcWrapper<Proc> Wrapper;
|
||||
boost::python::class_<Proc, Wrapper,boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator());
|
||||
}
|
||||
};
|
||||
|
||||
template <class Binary>
|
||||
void make_abstract_functor(std::string name, typename eoFunctorBase::binary_function_tag)
|
||||
{
|
||||
typedef BinaryWrapper<Binary> Wrapper;
|
||||
boost::python::class_<Binary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator());
|
||||
}
|
||||
template <class Proc>
|
||||
void make_abstract_functor_ref(std::string name, typename eoFunctorBase::procedure_tag)
|
||||
{
|
||||
typedef ProcWrapper<Proc> Wrapper;
|
||||
boost::python::class_<Proc, Wrapper,boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator(), boost::python::return_internal_reference<>());
|
||||
}
|
||||
|
||||
template <class Binary>
|
||||
void make_abstract_functor_ref(std::string name, typename eoFunctorBase::binary_function_tag)
|
||||
{
|
||||
typedef BinaryWrapper<Binary> Wrapper;
|
||||
boost::python::class_<Binary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator(), boost::python::return_internal_reference<>() );
|
||||
}
|
||||
template <class Unary>
|
||||
class UnaryWrapper : public Unary
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
UnaryWrapper(PyObject* s) : self(s) {}
|
||||
|
||||
typename Unary::result_type operator()(typename Unary::argument_type a)
|
||||
{
|
||||
return boost::python::call_method<typename Unary::result_type>(self, "__call__", boost::ref(a) );
|
||||
}
|
||||
};
|
||||
|
||||
template <class Unary>
|
||||
void make_abstract_functor(std::string name, typename eoFunctorBase::unary_function_tag)
|
||||
{
|
||||
typedef UnaryWrapper<Unary> Wrapper;
|
||||
|
||||
boost::python::class_<Unary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator())
|
||||
;
|
||||
}
|
||||
|
||||
template <class Unary>
|
||||
void make_abstract_functor_ref(std::string name, typename eoFunctorBase::unary_function_tag)
|
||||
{
|
||||
typedef UnaryWrapper<Unary> Wrapper;
|
||||
|
||||
boost::python::class_<Unary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator(), boost::python::return_internal_reference<>() )
|
||||
;
|
||||
}
|
||||
|
||||
template <class Binary>
|
||||
class BinaryWrapper : public Binary
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
BinaryWrapper(PyObject* s) : self(s) {}
|
||||
typename Binary::result_type operator()(typename Binary::first_argument_type a1, typename Binary::second_argument_type a2)
|
||||
{
|
||||
return boost::python::call_method<
|
||||
typename Binary::result_type>(self, "__call__", boost::ref(a1), boost::ref(a2) );
|
||||
}
|
||||
};
|
||||
|
||||
template <class Binary>
|
||||
void make_abstract_functor(std::string name, typename eoFunctorBase::binary_function_tag)
|
||||
{
|
||||
typedef BinaryWrapper<Binary> Wrapper;
|
||||
boost::python::class_<Binary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator());
|
||||
}
|
||||
|
||||
template <class Binary>
|
||||
void make_abstract_functor_ref(std::string name, typename eoFunctorBase::binary_function_tag)
|
||||
{
|
||||
typedef BinaryWrapper<Binary> Wrapper;
|
||||
boost::python::class_<Binary, Wrapper, boost::noncopyable>(name.c_str(), boost::python::init<>() )
|
||||
.def("__call__", &Wrapper::operator(), boost::python::return_internal_reference<>() );
|
||||
}
|
||||
|
||||
}// namespace eoutils
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -31,22 +31,22 @@ using namespace boost::python;
|
|||
|
||||
class GenOpWrapper : public eoGenOp<PyEO>
|
||||
{
|
||||
public:
|
||||
public:
|
||||
|
||||
PyObject* self;
|
||||
GenOpWrapper(PyObject* p) : self(p) {}
|
||||
unsigned max_production(void)
|
||||
{
|
||||
return call_method<unsigned>(self,"max_production");
|
||||
return call_method<unsigned>(self,"max_production");
|
||||
}
|
||||
std::string className() const
|
||||
{
|
||||
return "GenOpDerivative"; // never saw the use of className anyway
|
||||
return "GenOpDerivative"; // never saw the use of className anyway
|
||||
}
|
||||
|
||||
|
||||
void apply(eoPopulator<PyEO>& populator )
|
||||
{
|
||||
boost::python::call_method<void>(self,"apply", boost::ref( populator ) );
|
||||
boost::python::call_method<void>(self,"apply", boost::ref( populator ) );
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -54,15 +54,15 @@ class PopulatorWrapper : public eoPopulator<PyEO>
|
|||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
PopulatorWrapper(PyObject* p, const eoPop<PyEO>& src, eoPop<PyEO>& dest)
|
||||
: eoPopulator<PyEO>(src, dest), self(p)
|
||||
{
|
||||
//throw std::runtime_error("abstract base class");
|
||||
}
|
||||
|
||||
PopulatorWrapper(PyObject* p, const eoPop<PyEO>& src, eoPop<PyEO>& dest)
|
||||
: eoPopulator<PyEO>(src, dest), self(p)
|
||||
{
|
||||
//throw std::runtime_error("abstract base class");
|
||||
}
|
||||
|
||||
const PyEO& select()
|
||||
{
|
||||
return call_method<const PyEO&>(self,"select");
|
||||
return call_method<const PyEO&>(self,"select");
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -94,62 +94,62 @@ public:
|
|||
void geneticOps()
|
||||
{
|
||||
class_<eoPopulator<PyEO>, PopulatorWrapper, boost::noncopyable>
|
||||
("eoPopulator", init<const eoPop<PyEO>&, eoPop<PyEO>&>() )
|
||||
.def("select", &PopulatorWrapper::select, return_internal_reference<>() )
|
||||
.def("get", &eoPopulator<PyEO>::operator*, return_internal_reference<>() )
|
||||
.def("next", &eoPopulator<PyEO>::operator++, return_internal_reference<>() )
|
||||
.def("insert", &eoPopulator<PyEO>::insert)
|
||||
.def("reserve", &eoPopulator<PyEO>::reserve)
|
||||
.def("source", &eoPopulator<PyEO>::source, return_internal_reference<>() )
|
||||
.def("offspring", &eoPopulator<PyEO>::offspring, return_internal_reference<>() )
|
||||
.def("tellp", &eoPopulator<PyEO>::tellp)
|
||||
.def("seekp", &eoPopulator<PyEO>::seekp)
|
||||
.def("exhausted", &eoPopulator<PyEO>::exhausted)
|
||||
;
|
||||
("eoPopulator", init<const eoPop<PyEO>&, eoPop<PyEO>&>() )
|
||||
.def("select", &PopulatorWrapper::select, return_internal_reference<>() )
|
||||
.def("get", &eoPopulator<PyEO>::operator*, return_internal_reference<>() )
|
||||
.def("next", &eoPopulator<PyEO>::operator++, return_internal_reference<>() )
|
||||
.def("insert", &eoPopulator<PyEO>::insert)
|
||||
.def("reserve", &eoPopulator<PyEO>::reserve)
|
||||
.def("source", &eoPopulator<PyEO>::source, return_internal_reference<>() )
|
||||
.def("offspring", &eoPopulator<PyEO>::offspring, return_internal_reference<>() )
|
||||
.def("tellp", &eoPopulator<PyEO>::tellp)
|
||||
.def("seekp", &eoPopulator<PyEO>::seekp)
|
||||
.def("exhausted", &eoPopulator<PyEO>::exhausted)
|
||||
;
|
||||
|
||||
class_<eoSeqPopulator<PyEO>, bases<eoPopulator<PyEO> > >
|
||||
("eoSeqPopulator", init<const eoPop<PyEO>&, eoPop<PyEO>&>() )
|
||||
.def("select", &eoSeqPopulator<PyEO>::select, return_internal_reference<>() )
|
||||
;
|
||||
|
||||
("eoSeqPopulator", init<const eoPop<PyEO>&, eoPop<PyEO>&>() )
|
||||
.def("select", &eoSeqPopulator<PyEO>::select, return_internal_reference<>() )
|
||||
;
|
||||
|
||||
class_<eoSelectivePopulator<PyEO>, bases<eoPopulator<PyEO> > >
|
||||
("eoSelectivePopulator", init<const eoPop<PyEO>&, eoPop<PyEO>&, eoSelectOne<PyEO>& >() )
|
||||
.def("select", &eoSeqPopulator<PyEO>::select, return_internal_reference<>() )
|
||||
;
|
||||
("eoSelectivePopulator", init<const eoPop<PyEO>&, eoPop<PyEO>&, eoSelectOne<PyEO>& >() )
|
||||
.def("select", &eoSeqPopulator<PyEO>::select, return_internal_reference<>() )
|
||||
;
|
||||
enum_<eoOp<PyEO>::OpType>("OpType")
|
||||
.value("unary", eoOp<PyEO>::unary)
|
||||
.value("binary", eoOp<PyEO>::binary)
|
||||
.value("quadratic", eoOp<PyEO>::quadratic)
|
||||
.value("general", eoOp<PyEO>::general)
|
||||
;
|
||||
|
||||
.value("unary", eoOp<PyEO>::unary)
|
||||
.value("binary", eoOp<PyEO>::binary)
|
||||
.value("quadratic", eoOp<PyEO>::quadratic)
|
||||
.value("general", eoOp<PyEO>::general)
|
||||
;
|
||||
|
||||
class_<eoOp<PyEO> >("eoOp", init<eoOp<PyEO>::OpType>())
|
||||
.def("getType", &eoOp<PyEO>::getType);
|
||||
|
||||
.def("getType", &eoOp<PyEO>::getType);
|
||||
|
||||
class_<eoMonOp<PyEO>, MonOpWrapper, bases<eoOp<PyEO> >, boost::noncopyable>("eoMonOp", init<>())
|
||||
.def("__call__", &MonOpWrapper::operator(), "an example docstring");
|
||||
.def("__call__", &MonOpWrapper::operator(), "an example docstring");
|
||||
class_<eoBinOp<PyEO>, BinOpWrapper, bases<eoOp<PyEO> >, boost::noncopyable>("eoBinOp", init<>())
|
||||
.def("__call__", &BinOpWrapper::operator());
|
||||
.def("__call__", &BinOpWrapper::operator());
|
||||
class_<eoQuadOp<PyEO>, QuadOpWrapper, bases<eoOp<PyEO> >, boost::noncopyable>("eoQuadOp", init<>())
|
||||
.def("__call__", &QuadOpWrapper::operator());
|
||||
|
||||
.def("__call__", &QuadOpWrapper::operator());
|
||||
|
||||
class_<eoGenOp<PyEO>, GenOpWrapper, bases<eoOp<PyEO> >, boost::noncopyable>("eoGenOp", init<>())
|
||||
.def("max_production", &GenOpWrapper::max_production)
|
||||
.def("className", &GenOpWrapper::className)
|
||||
.def("apply", &GenOpWrapper::apply)
|
||||
.def("__call__", &eoGenOp<PyEO>::operator())
|
||||
;
|
||||
|
||||
.def("max_production", &GenOpWrapper::max_production)
|
||||
.def("className", &GenOpWrapper::className)
|
||||
.def("apply", &GenOpWrapper::apply)
|
||||
.def("__call__", &eoGenOp<PyEO>::operator())
|
||||
;
|
||||
|
||||
class_<eoSequentialOp<PyEO>, bases<eoGenOp<PyEO> >, boost::noncopyable>("eoSequentialOp", init<>())
|
||||
.def("add", &eoSequentialOp<PyEO>::add, WC1)
|
||||
.def("apply", &eoSequentialOp<PyEO>::apply)
|
||||
;
|
||||
|
||||
.def("add", &eoSequentialOp<PyEO>::add, WC1)
|
||||
.def("apply", &eoSequentialOp<PyEO>::apply)
|
||||
;
|
||||
|
||||
class_<eoProportionalOp<PyEO>, bases<eoGenOp<PyEO> >, boost::noncopyable>("eoProportionalOp", init<>())
|
||||
.def("add", &eoProportionalOp<PyEO>::add, WC1)
|
||||
.def("apply", &eoProportionalOp<PyEO>::apply)
|
||||
;
|
||||
|
||||
.def("add", &eoProportionalOp<PyEO>::add, WC1)
|
||||
.def("apply", &eoProportionalOp<PyEO>::apply)
|
||||
;
|
||||
|
||||
/* Cloning */
|
||||
class_<eoMonCloneOp<PyEO>, bases<eoMonOp<PyEO> > >("eoMonCloneOp").def("__call__", &eoMonCloneOp<PyEO>::operator());
|
||||
class_<eoBinCloneOp<PyEO>, bases<eoBinOp<PyEO> > >("eoBinCloneOp").def("__call__", &eoBinCloneOp<PyEO>::operator());
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -31,11 +31,10 @@ using namespace boost::python;
|
|||
void mergers()
|
||||
{
|
||||
def_abstract_functor<eoMerge<PyEO> >("eoMerge");
|
||||
|
||||
|
||||
DEF2(eoElitism, double)
|
||||
.def( init<double, bool>() );
|
||||
.def( init<double, bool>() );
|
||||
DEF(eoNoElitism);
|
||||
DEF(eoPlus);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -26,47 +26,46 @@ using namespace boost::python;
|
|||
|
||||
class MonitorWrapper : public eoMonitor
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
list objects;
|
||||
|
||||
MonitorWrapper(PyObject* p) :self(p) {}
|
||||
public:
|
||||
PyObject* self;
|
||||
list objects;
|
||||
|
||||
eoMonitor& operator()()
|
||||
{
|
||||
call_method<void>(self, "__call__");
|
||||
return *this;
|
||||
}
|
||||
MonitorWrapper(PyObject* p) :self(p) {}
|
||||
|
||||
std::string getString(int i)
|
||||
{
|
||||
if (static_cast<unsigned>(i) >= vec.size())
|
||||
{
|
||||
throw index_error("Index out of bounds");
|
||||
}
|
||||
|
||||
return vec[i]->getValue();
|
||||
}
|
||||
eoMonitor& operator()()
|
||||
{
|
||||
call_method<void>(self, "__call__");
|
||||
return *this;
|
||||
}
|
||||
|
||||
unsigned size() { return vec.size(); }
|
||||
std::string getString(int i)
|
||||
{
|
||||
if (static_cast<unsigned>(i) >= vec.size())
|
||||
{
|
||||
throw index_error("Index out of bounds");
|
||||
}
|
||||
|
||||
return vec[i]->getValue();
|
||||
}
|
||||
|
||||
unsigned size() { return vec.size(); }
|
||||
};
|
||||
|
||||
void monitors()
|
||||
{
|
||||
/**
|
||||
* Change of interface: I encountered some difficulties with
|
||||
/**
|
||||
* Change of interface: I encountered some difficulties with
|
||||
* transferring eoParams from and to Python, so now we can
|
||||
* only get at the strings contained in the eoParams.
|
||||
* sorry
|
||||
*/
|
||||
|
||||
class_<eoMonitor, MonitorWrapper, boost::noncopyable>("eoMonitor", init<>())
|
||||
.def("lastCall", &eoMonitor::lastCall)
|
||||
.def("add", &eoMonitor::add)
|
||||
.def("__call__", &MonitorWrapper::operator(), return_internal_reference<1>() )
|
||||
.def("__getitem__", &MonitorWrapper::getString,
|
||||
"Returns the string value of the indexed Parameter")
|
||||
.def("__len__", &MonitorWrapper::size)
|
||||
;
|
||||
}
|
||||
|
||||
class_<eoMonitor, MonitorWrapper, boost::noncopyable>("eoMonitor", init<>())
|
||||
.def("lastCall", &eoMonitor::lastCall)
|
||||
.def("add", &eoMonitor::add)
|
||||
.def("__call__", &MonitorWrapper::operator(), return_internal_reference<1>() )
|
||||
.def("__getitem__", &MonitorWrapper::getString,
|
||||
"Returns the string value of the indexed Parameter")
|
||||
.def("__len__", &MonitorWrapper::size)
|
||||
;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -17,6 +17,7 @@
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoNDSorting.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
|
|
@ -30,19 +31,18 @@ struct Perf2WorthWrapper : public eoPerf2Worth<PyEO,double>
|
|||
|
||||
void operator()( const eoPop<PyEO>& pop)
|
||||
{
|
||||
call_method<void>(self, "__call__", boost::ref(pop));
|
||||
call_method<void>(self, "__call__", boost::ref(pop));
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
numeric::array get_worths(eoPerf2Worth<PyEO, double>& p)
|
||||
{
|
||||
std::vector<double>& worths = p.value();
|
||||
list result;
|
||||
|
||||
|
||||
for (unsigned i = 0; i < worths.size(); ++i)
|
||||
result.append(worths[i]);
|
||||
|
||||
result.append(worths[i]);
|
||||
|
||||
return numeric::array(result);
|
||||
}
|
||||
|
||||
|
|
@ -53,36 +53,37 @@ struct CachedPerf2WorthWrapper : public eoPerf2WorthCached<PyEO, double>
|
|||
|
||||
void calculate_worths(const eoPop<PyEO>& pop)
|
||||
{
|
||||
call_method<void>(self, "calculate_worths", boost::ref(pop));
|
||||
call_method<void>(self, "calculate_worths", boost::ref(pop));
|
||||
}
|
||||
};
|
||||
|
||||
void perf2worth()
|
||||
void perf2worth()
|
||||
{
|
||||
//numeric::array::set_module_and_type("Numeric", "ArrayType");
|
||||
|
||||
class_<
|
||||
eoPerf2Worth<PyEO, double>,
|
||||
Perf2WorthWrapper,
|
||||
bases< eoValueParam<std::vector<double> > >,
|
||||
boost::noncopyable>("eoPerf2Worth", init<>())
|
||||
|
||||
.def("__call__", &Perf2WorthWrapper::operator())
|
||||
.def("sort_pop", &eoPerf2Worth<PyEO, double>::sort_pop)
|
||||
//.def("value", get_worths)
|
||||
;
|
||||
|
||||
class_<eoPerf2WorthCached<PyEO, double>, CachedPerf2WorthWrapper, bases<eoPerf2Worth<PyEO, double> >, boost::noncopyable>
|
||||
("eoPerf2WorthCached", init<>())
|
||||
.def("__call__", &eoPerf2WorthCached<PyEO, double>::operator())
|
||||
.def("calculate_worths", &CachedPerf2WorthWrapper::calculate_worths)
|
||||
;
|
||||
|
||||
class_<eoPerf2Worth<PyEO, double>,
|
||||
Perf2WorthWrapper,
|
||||
bases< eoValueParam<std::vector<double> > >,
|
||||
boost::noncopyable>("eoPerf2Worth", init<>())
|
||||
|
||||
.def("__call__", &Perf2WorthWrapper::operator())
|
||||
.def("sort_pop", &eoPerf2Worth<PyEO, double>::sort_pop)
|
||||
//.def("value", get_worths)
|
||||
;
|
||||
|
||||
class_<eoPerf2WorthCached<PyEO, double>,
|
||||
CachedPerf2WorthWrapper,
|
||||
bases<eoPerf2Worth<PyEO, double> >,
|
||||
boost::noncopyable>("eoPerf2WorthCached", init<>())
|
||||
|
||||
.def("__call__", &eoPerf2WorthCached<PyEO, double>::operator())
|
||||
.def("calculate_worths", &CachedPerf2WorthWrapper::calculate_worths)
|
||||
;
|
||||
|
||||
//class_<eoNoPerf2Worth<PyEO>, bases<eoPerf2Worth<PyEO, double> > >("eoNoPerf2Worth")
|
||||
// .def("__call__", &eoNoPerf2Worth<PyEO>::operator());
|
||||
|
||||
class_<eoNDSorting_II<PyEO>, bases<eoPerf2WorthCached<PyEO, double> > >("eoNDSorting_II")
|
||||
.def("calculate_worths", &eoNDSorting_II<PyEO>::calculate_worths);
|
||||
// .def("__call__", &eoNoPerf2Worth<PyEO>::operator());
|
||||
|
||||
class_<eoNDSorting_II<PyEO>,
|
||||
bases<eoPerf2WorthCached<PyEO, double> > >("eoNDSorting_II")
|
||||
.def("calculate_worths", &eoNDSorting_II<PyEO>::calculate_worths);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -29,32 +29,31 @@
|
|||
#include <sstream>
|
||||
/** Implements pickle support for eoPersistent derivatives */
|
||||
|
||||
|
||||
template <class T>
|
||||
struct T_pickle_suite : boost::python::pickle_suite
|
||||
{
|
||||
static
|
||||
std::string print_to_string(const T& t)
|
||||
{
|
||||
std::ostringstream os;
|
||||
t.printOn(os);
|
||||
os << std::ends;
|
||||
return os.str();
|
||||
std::ostringstream os;
|
||||
t.printOn(os);
|
||||
os << std::ends;
|
||||
return os.str();
|
||||
}
|
||||
|
||||
static
|
||||
boost::python::tuple getstate(const T& t)
|
||||
{
|
||||
std::string s = print_to_string(t);
|
||||
return boost::python::make_tuple( boost::python::str(s));
|
||||
std::string s = print_to_string(t);
|
||||
return boost::python::make_tuple( boost::python::str(s));
|
||||
}
|
||||
|
||||
static
|
||||
void setstate(T& t, boost::python::tuple pickled)
|
||||
{
|
||||
std::string s = boost::python::extract<std::string>(pickled[0]);
|
||||
std::istringstream is(s);
|
||||
t.readFrom(is);
|
||||
std::string s = boost::python::extract<std::string>(pickled[0]);
|
||||
std::istringstream is(s);
|
||||
t.readFrom(is);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -65,7 +64,7 @@ template <class Persistent, class X1, class X2, class X3>
|
|||
boost::python::class_<Persistent, X1, X2, X3>& pickle(boost::python::class_<Persistent, X1, X2, X3>& c)
|
||||
{
|
||||
return c.def_pickle(T_pickle_suite<Persistent>())
|
||||
.def("__str__", T_pickle_suite<Persistent>::print_to_string);
|
||||
.def("__str__", T_pickle_suite<Persistent>::print_to_string);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -61,52 +61,52 @@ struct RNG_pickle_suite : boost::python::pickle_suite
|
|||
static
|
||||
boost::python::tuple getstate(const eoRng& _rng)
|
||||
{
|
||||
return boost::python::make_tuple(str(rng_to_string(_rng)));
|
||||
return boost::python::make_tuple(str(rng_to_string(_rng)));
|
||||
}
|
||||
static
|
||||
void setstate(eoRng& _rng, boost::python::tuple pickled)
|
||||
{
|
||||
std::string state = extract<std::string>(pickled[0]);
|
||||
rng_from_string(_rng, state);
|
||||
std::string state = extract<std::string>(pickled[0]);
|
||||
rng_from_string(_rng, state);
|
||||
}
|
||||
};
|
||||
|
||||
int spin(eoRng& _rng, numeric::array values, double total)
|
||||
{
|
||||
if (total == 0.0)
|
||||
{
|
||||
unsigned sz = len(values);
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
{
|
||||
total += extract<double>(values[i]); //extract?
|
||||
}
|
||||
}
|
||||
if (total == 0.0)
|
||||
{
|
||||
unsigned sz = len(values);
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
{
|
||||
total += extract<double>(values[i]); //extract?
|
||||
}
|
||||
}
|
||||
|
||||
double chance = _rng.uniform() * total;
|
||||
double chance = _rng.uniform() * total;
|
||||
|
||||
int i = 0;
|
||||
while (chance >= 0.0)
|
||||
chance -= extract<double>(values[i++]);
|
||||
int i = 0;
|
||||
while (chance >= 0.0)
|
||||
chance -= extract<double>(values[i++]);
|
||||
|
||||
return --i;
|
||||
return --i;
|
||||
}
|
||||
|
||||
void random_numbers()
|
||||
{
|
||||
class_<eoRng, boost::noncopyable>("eoRng", init<uint32_t>())
|
||||
.def("flip", &eoRng::flip)
|
||||
.def("random", &eoRng::random)
|
||||
.def("rand", &eoRng::rand)
|
||||
.def("rand_max", &eoRng::rand_max)
|
||||
.def("reseed", &eoRng::reseed)
|
||||
// .def("uniform", &eoRng::uniform)
|
||||
.def("normal", normal)
|
||||
.def("negexp", &eoRng::negexp)
|
||||
.def("to_string", rng_to_string)
|
||||
.def("from_string", rng_from_string)
|
||||
.def("roulette_wheel", spin)
|
||||
.def_pickle(RNG_pickle_suite())
|
||||
;
|
||||
.def("flip", &eoRng::flip)
|
||||
.def("random", &eoRng::random)
|
||||
.def("rand", &eoRng::rand)
|
||||
.def("rand_max", &eoRng::rand_max)
|
||||
.def("reseed", &eoRng::reseed)
|
||||
// .def("uniform", &eoRng::uniform)
|
||||
.def("normal", normal)
|
||||
.def("negexp", &eoRng::negexp)
|
||||
.def("to_string", rng_to_string)
|
||||
.def("from_string", rng_from_string)
|
||||
.def("roulette_wheel", spin)
|
||||
.def_pickle(RNG_pickle_suite())
|
||||
;
|
||||
|
||||
def("rng", get_rng, return_value_policy<reference_existing_object>());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -27,7 +27,7 @@ using namespace boost::python;
|
|||
// unfortunately have to define it specially
|
||||
class eoReduceWrapper : public eoReduce<PyEO>
|
||||
{
|
||||
public:
|
||||
public:
|
||||
PyObject* self;
|
||||
eoReduceWrapper(PyObject* s) : self(s) {}
|
||||
void operator()(eoPop<PyEO>& pop, unsigned i)
|
||||
|
|
@ -38,7 +38,6 @@ class eoReduceWrapper : public eoReduce<PyEO>
|
|||
|
||||
void reduce()
|
||||
{
|
||||
|
||||
// ref trick in def_abstract_functor does not work for unsigned int :-(
|
||||
class_<eoReduce<PyEO>, eoReduceWrapper, boost::noncopyable>("eoReduce", init<>())
|
||||
.def("__call__", &eoReduceWrapper::operator());
|
||||
|
|
@ -62,4 +61,3 @@ void reduce()
|
|||
.def("__call__", &eoReduce<PyEO>::operator())
|
||||
;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -31,8 +31,9 @@ using namespace boost::python;
|
|||
|
||||
#define DEF(x) class_<x<PyEO>, bases<eoReplacement<PyEO > > >(#x).def("__call__", &eoReplacement<PyEO>::operator())
|
||||
#define DEF2(x, i1) class_<x<PyEO>, bases<eoReplacement<PyEO > > >(#x, init<i1>() ).def("__call__", &eoReplacement<PyEO>::operator())
|
||||
#define DEF3(x, i1, i2) class_<x<PyEO>, bases<eoReplacement<PyEO > > >(#x, \
|
||||
init<i1, i2 >() [WC2])\
|
||||
#define DEF3(x, i1, i2) class_<x<PyEO>, bases<eoReplacement<PyEO > > > \
|
||||
(#x, \
|
||||
init<i1, i2 >() [WC2]) \
|
||||
.def("__call__", &eoReplacement<PyEO>::operator())
|
||||
|
||||
void replacement()
|
||||
|
|
@ -40,12 +41,12 @@ void replacement()
|
|||
def_abstract_functor<eoReplacement<PyEO> >("eoReplacement");
|
||||
|
||||
// eoReplacement.h
|
||||
DEF(eoGenerationalReplacement);
|
||||
|
||||
class_<eoWeakElitistReplacement<PyEO>, bases<eoReplacement<PyEO> > >
|
||||
DEF(eoGenerationalReplacement);
|
||||
|
||||
class_<eoWeakElitistReplacement<PyEO>, bases<eoReplacement<PyEO> > >
|
||||
("eoWeakElitistReplacement",
|
||||
init< eoReplacement<PyEO>& >()[WC1]);
|
||||
|
||||
|
||||
// eoMergeReduce.h
|
||||
DEF3(eoMergeReduce, eoMerge<PyEO>&, eoReduce<PyEO>& );
|
||||
DEF(eoPlusReplacement);
|
||||
|
|
@ -60,13 +61,12 @@ void replacement()
|
|||
|
||||
// eoReduceMergeReduce.h
|
||||
//class_<eoReduceMergeReduce<PyEO>, bases<eoReplacement<PyEO> > >("eoReplacement",
|
||||
// init<eoHowMany, bool, eoHowMany, eoReduce<PyEO>&,
|
||||
// eoHowMany, eoReduce<PyEO>&, eoReduce<PyEO>&>())
|
||||
// .def("__call__", &eoReplacement<PyEO>::operator());
|
||||
|
||||
// init<eoHowMany, bool, eoHowMany, eoReduce<PyEO>&,
|
||||
// eoHowMany, eoReduce<PyEO>&, eoReduce<PyEO>&>())
|
||||
// .def("__call__", &eoReplacement<PyEO>::operator());
|
||||
|
||||
//eoMGGReplacement
|
||||
DEF(eoMGGReplacement)
|
||||
.def( init<eoHowMany>() )
|
||||
.def( init<eoHowMany, unsigned>() );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -33,10 +33,10 @@ using namespace boost::python;
|
|||
|
||||
class eoSelectOneWrapper : public eoSelectOne<PyEO>
|
||||
{
|
||||
public:
|
||||
public:
|
||||
PyObject* self;
|
||||
eoSelectOneWrapper(PyObject* p) : self(p) {}
|
||||
const PyEO& operator()(const eoPop<PyEO>& pop)
|
||||
const PyEO& operator()(const eoPop<PyEO>& pop)
|
||||
{
|
||||
return boost::python::call_method< const PyEO& >(self, "__call__", boost::ref(pop));
|
||||
}
|
||||
|
|
@ -57,7 +57,7 @@ void add_select(std::string name, Init init)
|
|||
.def("__call__", &Select::operator(), return_internal_reference<>() )
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
template <class Select, class Init1, class Init2>
|
||||
void add_select(std::string name, Init1 init1, Init2 init2)
|
||||
{
|
||||
|
|
@ -70,38 +70,39 @@ void add_select(std::string name, Init1 init1, Init2 init2)
|
|||
void selectOne()
|
||||
{
|
||||
/* Concrete classes */
|
||||
|
||||
|
||||
pickle(class_<eoHowMany>("eoHowMany", init<>())
|
||||
.def( init<double>() )
|
||||
.def( init<double, bool>() )
|
||||
.def( init<int>() )
|
||||
.def("__call__", &eoHowMany::operator())
|
||||
.def("__neg__", &eoHowMany::operator-)
|
||||
);
|
||||
|
||||
.def( init<double>() )
|
||||
.def( init<double, bool>() )
|
||||
.def( init<int>() )
|
||||
.def("__call__", &eoHowMany::operator())
|
||||
.def("__neg__", &eoHowMany::operator-)
|
||||
);
|
||||
|
||||
class_<eoSelectOne<PyEO>, eoSelectOneWrapper, boost::noncopyable>("eoSelectOne", init<>())
|
||||
.def("__call__", &eoSelectOneWrapper::operator(), return_internal_reference<>() )
|
||||
.def("setup", &eoSelectOne<PyEO>::setup);
|
||||
|
||||
|
||||
/* SelectOne derived classes */
|
||||
|
||||
|
||||
add_select<eoDetTournamentSelect<PyEO> >("eoDetTournamentSelect", init<>(), init<unsigned>() );
|
||||
add_select<eoStochTournamentSelect<PyEO> >("eoStochTournamentSelect", init<>(), init<double>() );
|
||||
add_select<eoTruncatedSelectOne<PyEO> >("eoTruncatedSelectOne",
|
||||
init<eoSelectOne<PyEO>&, double>()[WC1], init<eoSelectOne<PyEO>&, eoHowMany >()[WC1] );
|
||||
|
||||
add_select<eoTruncatedSelectOne<PyEO> >("eoTruncatedSelectOne",
|
||||
init<eoSelectOne<PyEO>&, double>()[WC1],
|
||||
init<eoSelectOne<PyEO>&, eoHowMany >()[WC1]
|
||||
);
|
||||
|
||||
// eoProportionalSelect is not feasible to implement at this point as fitness is not recognizable as a float
|
||||
// use eoDetTournament instead: with a t-size of 2 it is equivalent to eoProportional with linear scaling
|
||||
//add_select<eoProportionalSelect<PyEO> >("eoProportionalSelect", init<eoPop<PyEO>&>() );
|
||||
|
||||
|
||||
add_select<eoRandomSelect<PyEO> >("eoRandomSelect");
|
||||
add_select<eoBestSelect<PyEO> >("eoBestSelect");
|
||||
add_select<eoNoSelect<PyEO> >("eoNoSelect");
|
||||
|
||||
|
||||
add_select<eoSequentialSelect<PyEO> >("eoSequentialSelect", init<>(), init<bool>());
|
||||
add_select<eoEliteSequentialSelect<PyEO> >("eoEliteSequentialSelect");
|
||||
/*
|
||||
* eoSelectFromWorth.h:class eoSelectFromWorth : public eoSelectOne<EOT>
|
||||
|
||||
*/
|
||||
*/
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -53,9 +53,8 @@ void selectors()
|
|||
DEF3(eoTruncSelect, eoSelectOne<PyEO>&, eoHowMany);
|
||||
|
||||
class_<eoTruncatedSelectMany<PyEO>, bases<eoSelect<PyEO> > >("eoTruncatedSelectMany",
|
||||
init<eoSelectOne<PyEO>&, double, double>()[WC1])
|
||||
init<eoSelectOne<PyEO>&, double, double>()[WC1])
|
||||
.def(init<eoSelectOne<PyEO>&, double, double, bool> ()[WC1])
|
||||
.def(init<eoSelectOne<PyEO>&, double, double, bool, bool> ()[WC1])
|
||||
.def(init<eoSelectOne<PyEO>&, eoHowMany, eoHowMany> ()[WC1]);
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,9 +5,9 @@
|
|||
|
||||
using namespace boost::python;
|
||||
|
||||
class StatBaseWrapper : public eoStatBase<PyEO>
|
||||
class StatBaseWrapper : public eoStatBase<PyEO>
|
||||
{
|
||||
public:
|
||||
public:
|
||||
PyObject* self;
|
||||
StatBaseWrapper(PyObject* p) : self(p) {}
|
||||
|
||||
|
|
@ -17,9 +17,9 @@ class StatBaseWrapper : public eoStatBase<PyEO>
|
|||
}
|
||||
};
|
||||
|
||||
class SortedStatBaseWrapper : public eoSortedStatBase<PyEO>
|
||||
class SortedStatBaseWrapper : public eoSortedStatBase<PyEO>
|
||||
{
|
||||
public:
|
||||
public:
|
||||
PyObject* self;
|
||||
SortedStatBaseWrapper(PyObject* p) : self(p) {}
|
||||
|
||||
|
|
@ -31,13 +31,13 @@ class SortedStatBaseWrapper : public eoSortedStatBase<PyEO>
|
|||
|
||||
typedef std::vector<const PyEO*> eoPopView;
|
||||
|
||||
const PyEO& popview_getitem(const std::vector<const PyEO*>& pop, int it)
|
||||
{
|
||||
const PyEO& popview_getitem(const std::vector<const PyEO*>& pop, int it)
|
||||
{
|
||||
unsigned item = unsigned(it);
|
||||
if (item > pop.size())
|
||||
throw index_error("too much");
|
||||
|
||||
return *pop[item];
|
||||
|
||||
return *pop[item];
|
||||
}
|
||||
|
||||
void statistics()
|
||||
|
|
@ -52,7 +52,7 @@ void statistics()
|
|||
.def("__getitem__", popview_getitem, return_internal_reference<>() )
|
||||
.def("__len__", &eoPopView::size)
|
||||
;
|
||||
|
||||
|
||||
class_<eoSortedStatBase<PyEO>, SortedStatBaseWrapper, boost::noncopyable>
|
||||
("eoSortedStatBase", init<>())
|
||||
.def("lastCall", &eoSortedStatBase<PyEO>::lastCall)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
import sys
|
||||
sys.path.append('..')
|
||||
|
||||
|
|
@ -10,47 +9,47 @@ 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)
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
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
|
||||
eoInit.__init__(self)
|
||||
self.length = genome_length
|
||||
def __call__(self, eo):
|
||||
eo.genome = [rng().flip(0.5) for x in range(self.length)]
|
||||
|
||||
eo.genome = [rng().flip(0.5) for x in range(self.length)]
|
||||
|
||||
class Mutate(eoMonOp):
|
||||
def __call__(self, eo):
|
||||
eo.genome = copy(eo.genome)
|
||||
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
|
||||
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);
|
||||
eo1.genome = copy(eo1.genome);
|
||||
eo2.genome = copy(eo2.genome);
|
||||
|
||||
point = rng().random( len(eo1.genome) );
|
||||
point = rng().random( len(eo1.genome) );
|
||||
|
||||
eo1.genome[:point] = eo2.genome[:point];
|
||||
eo2.genome[point:] = eo1.genome[point:];
|
||||
|
||||
return 1
|
||||
eo1.genome[:point] = eo2.genome[:point];
|
||||
eo2.genome[point:] = eo1.genome[point:];
|
||||
|
||||
return 1
|
||||
|
||||
evaluate = EvalFunc()
|
||||
init = Init(3)
|
||||
|
|
@ -58,34 +57,32 @@ 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
|
||||
|
||||
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
|
||||
|
||||
|
||||
print pop[0], eo
|
||||
|
|
|
|||
|
|
@ -1,18 +1,16 @@
|
|||
from maxone import *
|
||||
import unittest
|
||||
|
||||
|
||||
class TestBreeders(unittest.TestCase):
|
||||
|
||||
def runtest(self, breed):
|
||||
|
||||
pop = eoPop(50, Init(20))
|
||||
evaluate = EvalFunc()
|
||||
print 'HERE'
|
||||
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()
|
||||
|
|
@ -28,6 +26,5 @@ class TestBreeders(unittest.TestCase):
|
|||
def suite():
|
||||
return unittest.makeSuite(TestSGA,'test')
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
unittest.main()
|
||||
|
|
|
|||
|
|
@ -2,35 +2,33 @@ 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
|
||||
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
|
||||
|
|
@ -47,71 +45,65 @@ def do_plot(pop):
|
|||
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()
|
||||
newpop = eoPop()
|
||||
populator = eoSelectivePopulator(pop, newpop, self.selectOne);
|
||||
|
||||
while len(newpop) < sz:
|
||||
self.seq(populator)
|
||||
|
||||
for indy in newpop:
|
||||
|
||||
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
|
||||
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);
|
||||
|
|
@ -133,12 +125,12 @@ class TestNSGA_II(unittest.TestCase):
|
|||
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)
|
||||
|
||||
|
|
@ -157,20 +149,18 @@ class TestNSGA_II(unittest.TestCase):
|
|||
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()
|
||||
|
|
|
|||
|
|
@ -5,9 +5,7 @@ import tempfile
|
|||
import os
|
||||
|
||||
class TestPickling(unittest.TestCase):
|
||||
|
||||
def do_pickle(self, object):
|
||||
|
||||
filename = tempfile.mktemp()
|
||||
file = open(filename, 'wb')
|
||||
pickler = cPickle.Pickler(file)
|
||||
|
|
@ -15,9 +13,9 @@ class TestPickling(unittest.TestCase):
|
|||
pickler.dump(object);
|
||||
del pickler
|
||||
file.close()
|
||||
|
||||
|
||||
file = open(filename)
|
||||
|
||||
|
||||
unpickler = cPickle.Unpickler(file)
|
||||
|
||||
object2 = unpickler.load()
|
||||
|
|
@ -29,15 +27,13 @@ class TestPickling(unittest.TestCase):
|
|||
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
|
||||
|
|
@ -45,19 +41,17 @@ class TestPickling(unittest.TestCase):
|
|||
eo2 = self.do_pickle(eo)
|
||||
|
||||
self.failUnlessEqual( str(eo), str(eo2) )
|
||||
|
||||
|
||||
def testPop(self):
|
||||
|
||||
pop = eoPop(40, init)
|
||||
for indy in pop:
|
||||
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)
|
||||
|
||||
|
|
@ -65,36 +59,33 @@ class TestPickling(unittest.TestCase):
|
|||
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(eoValueParamInt(42,'int'))
|
||||
self.vParam(eoValueParamFloat(4.2,'float'))
|
||||
|
||||
|
||||
v = eoValueParamVec()
|
||||
v.value = Numeric.arange(10)
|
||||
self.vParam(v)
|
||||
self.vParam(v)
|
||||
|
||||
v = eoValueParamPair()
|
||||
v.value = (0.3,0.5)
|
||||
self.vParam(v)
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
unittest.main()
|
||||
|
|
|
|||
|
|
@ -20,36 +20,34 @@ class Xover(Crossover):
|
|||
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()
|
||||
|
||||
|
|
@ -58,29 +56,27 @@ class TestPopulator(unittest.TestCase):
|
|||
|
||||
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
|
||||
print '*'*20, "SequentialOp", '*'*20
|
||||
self.runOpContainer(eoSequentialOp)
|
||||
|
||||
|
||||
def test_proportionalOp(self):
|
||||
print '*'*20, "ProportionalOp", '*'*20
|
||||
print '*'*20, "ProportionalOp", '*'*20
|
||||
self.runOpContainer(eoProportionalOp)
|
||||
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
unittest.main()
|
||||
|
|
|
|||
|
|
@ -2,11 +2,10 @@ 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:
|
||||
|
|
@ -14,8 +13,8 @@ class TestReduce(unittest.TestCase):
|
|||
|
||||
red(pop, 5);
|
||||
|
||||
self.failUnlessEqual( len(pop), 5)
|
||||
|
||||
self.failUnlessEqual( len(pop), 5)
|
||||
|
||||
def test_eoTruncate(self):
|
||||
self.run_test(eoTruncate)
|
||||
def test_eoRandomeReduce(self):
|
||||
|
|
@ -28,7 +27,6 @@ class TestReduce(unittest.TestCase):
|
|||
self.run_test(eoDetTournamentTruncate, 2)
|
||||
def test_eoStochTournamentTruncate(self):
|
||||
self.run_test(eoStochTournamentTruncate, 0.9)
|
||||
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
unittest.main()
|
||||
|
|
|
|||
|
|
@ -3,64 +3,60 @@ import unittest
|
|||
|
||||
class Init(eoInit):
|
||||
def __call__(self, eo):
|
||||
pass
|
||||
pass
|
||||
|
||||
class TestSGA(unittest.TestCase):
|
||||
|
||||
def __init__(self, a):
|
||||
unittest.TestCase.__init__(self, a)
|
||||
self.pop = eoPop(4, Init())
|
||||
unittest.TestCase.__init__(self, a)
|
||||
self.pop = eoPop(4, Init())
|
||||
|
||||
for i in range(len(self.pop)):
|
||||
self.pop[i].fitness = i;
|
||||
|
||||
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))]
|
||||
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
|
||||
|
||||
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)
|
||||
|
||||
selectOne = eoDetTournamentSelect(2)
|
||||
self.do_test(selectOne)
|
||||
|
||||
def test_eoRandomSelect(self):
|
||||
selectOne = eoRandomSelect()
|
||||
self.do_test(selectOne)
|
||||
selectOne = eoRandomSelect()
|
||||
self.do_test(selectOne)
|
||||
|
||||
def test_eoBestSelect(self):
|
||||
selectOne = eoBestSelect()
|
||||
(sel, nTries) = self.do_test(selectOne)
|
||||
selectOne = eoBestSelect()
|
||||
(sel, nTries) = self.do_test(selectOne)
|
||||
|
||||
self.failUnlessEqual(sel[0], 0);
|
||||
self.failUnlessEqual(sel[-1], nTries);
|
||||
self.failUnlessEqual(sel[0], 0);
|
||||
self.failUnlessEqual(sel[-1], nTries);
|
||||
|
||||
def test_eoNoSelect(self):
|
||||
selectOne = eoNoSelect()
|
||||
self.do_test(selectOne)
|
||||
selectOne = eoNoSelect()
|
||||
self.do_test(selectOne)
|
||||
|
||||
def test_eoStochTournament(self):
|
||||
selectOne = eoStochTournamentSelect(0.75)
|
||||
self.do_test(selectOne)
|
||||
selectOne = eoStochTournamentSelect(0.75)
|
||||
self.do_test(selectOne)
|
||||
|
||||
def test_eoSequentialSelect(self):
|
||||
selectOne = eoSequentialSelect();
|
||||
self.do_test(selectOne)
|
||||
|
||||
selectOne = eoSequentialSelect();
|
||||
self.do_test(selectOne)
|
||||
|
||||
def test_eoEliteSequentialSelect(self):
|
||||
selectOne = eoEliteSequentialSelect();
|
||||
self.do_test(selectOne)
|
||||
|
||||
selectOne = eoEliteSequentialSelect();
|
||||
self.do_test(selectOne)
|
||||
|
||||
if __name__=='__main__':
|
||||
unittest.main()
|
||||
|
|
|
|||
|
|
@ -2,43 +2,44 @@ from maxone import *
|
|||
import unittest
|
||||
|
||||
class TestSGA(unittest.TestCase):
|
||||
|
||||
def dotestSGA(self, evaluate):
|
||||
init = Init(20)
|
||||
mutate = Mutate()
|
||||
xover = Crossover()
|
||||
init = Init(20)
|
||||
mutate = Mutate()
|
||||
xover = Crossover()
|
||||
|
||||
pop = eoPop(50, init)
|
||||
for indy in pop: evaluate(indy)
|
||||
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);
|
||||
select = eoDetTournamentSelect(3);
|
||||
cont1 = eoGenContinue(20);
|
||||
|
||||
sga(pop)
|
||||
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()
|
||||
|
||||
print pop.best()
|
||||
def testSGA_Max(self):
|
||||
evaluate = EvalFunc()
|
||||
self.dotestSGA(evaluate)
|
||||
evaluate = EvalFunc()
|
||||
self.dotestSGA(evaluate)
|
||||
|
||||
def testSGA_Min(self):
|
||||
evaluate = MinEvalFunc()
|
||||
self.dotestSGA(evaluate)
|
||||
evaluate = MinEvalFunc()
|
||||
self.dotestSGA(evaluate)
|
||||
|
||||
if __name__=='__main__':
|
||||
unittest.main()
|
||||
|
|
|
|||
|
|
@ -1,61 +1,62 @@
|
|||
"""Test script for the eoSGATranform class"""
|
||||
|
||||
from copy import deepcopy
|
||||
from PyEO import *
|
||||
from PyEO import *
|
||||
from maxone import *
|
||||
|
||||
pop = eoPop()
|
||||
|
||||
for i in range(10):
|
||||
eo = EO()
|
||||
init(eo)
|
||||
evaluate(eo)
|
||||
pop.push_back(eo)
|
||||
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
|
||||
pop = deepcopy(pop)
|
||||
print "test 1"
|
||||
print "Initial population:"
|
||||
print pop
|
||||
|
||||
transform(pop)
|
||||
transform(pop)
|
||||
|
||||
print "GM pop:"
|
||||
print pop
|
||||
print "GM pop:"
|
||||
print pop
|
||||
|
||||
def test2(pop, transform):
|
||||
pop = deepcopy(pop)
|
||||
pop = deepcopy(pop)
|
||||
|
||||
print "test 2"
|
||||
print "Initial population"
|
||||
print 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)
|
||||
checkpoint = eoCheckPoint(eoGenContinue(50))
|
||||
select = eoSelectNumber(eoDetTournamentSelect(3), 10)
|
||||
replace = eoGenerationalReplacement()
|
||||
|
||||
print "Evoluated pop:"
|
||||
print pop
|
||||
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:
|
||||
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
|
||||
try:
|
||||
test2(pop, transform)
|
||||
except:
|
||||
import sys
|
||||
print
|
||||
print "Caught an exception:"
|
||||
print sys.exc_type, sys.exc_value
|
||||
print
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
|
@ -33,13 +33,12 @@ public:
|
|||
PyObject* self;
|
||||
ParamWrapper(PyObject* p) : self(p) {}
|
||||
ParamWrapper(PyObject* p,
|
||||
std::string a,
|
||||
std::string b,
|
||||
std::string c,
|
||||
char d,
|
||||
bool e) : eoParam(a,b,c,d,e), self(p) {}
|
||||
std::string a,
|
||||
std::string b,
|
||||
std::string c,
|
||||
char d,
|
||||
bool e) : eoParam(a,b,c,d,e), self(p) {}
|
||||
|
||||
|
||||
std::string getValue() const
|
||||
{
|
||||
return call_method<std::string>(self, "getValueAsString");
|
||||
|
|
@ -49,7 +48,6 @@ public:
|
|||
{
|
||||
call_method<void>(self, "setValueAsString", s);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -63,7 +61,7 @@ struct ValueParam_pickle_suite : boost::python::pickle_suite
|
|||
str def(_param.defValue());
|
||||
str l(_param.longName());
|
||||
object s(_param.shortName());
|
||||
object r(_param.required());
|
||||
object r(_param.required());
|
||||
return make_tuple(v,d,def,l,s,r);
|
||||
}
|
||||
static
|
||||
|
|
@ -90,31 +88,31 @@ void setv(eoValueParam<T>& v, U val) { v.value() = val; }
|
|||
|
||||
template <>
|
||||
numeric::array getv< std::vector<double>, numeric::array >
|
||||
(const eoValueParam< std::vector<double> >& param)
|
||||
(const eoValueParam< std::vector<double> >& param)
|
||||
{
|
||||
const std::vector<double>& v = param.value();
|
||||
list result;
|
||||
|
||||
for (unsigned i =0; i < v.size(); ++i)
|
||||
result.append(v[i]);
|
||||
|
||||
|
||||
return numeric::array(result);
|
||||
}
|
||||
|
||||
template <>
|
||||
void setv< std::vector<double>, numeric::array >
|
||||
(eoValueParam< std::vector<double> >& param, numeric::array val)
|
||||
(eoValueParam< std::vector<double> >& param, numeric::array val)
|
||||
{
|
||||
std::vector<double>& v = param.value();
|
||||
v.resize( boost::python::len(val) );
|
||||
for (unsigned i = 0; i < v.size(); ++i)
|
||||
{
|
||||
extract<double> x(val[i]);
|
||||
if (!x.check())
|
||||
throw std::runtime_error("double expected");
|
||||
|
||||
v[i] = x();
|
||||
}
|
||||
{
|
||||
extract<double> x(val[i]);
|
||||
if (!x.check())
|
||||
throw std::runtime_error("double expected");
|
||||
|
||||
v[i] = x();
|
||||
}
|
||||
}
|
||||
|
||||
template <>
|
||||
|
|
@ -126,7 +124,7 @@ tuple getv<std::pair<double, double>, tuple >
|
|||
|
||||
template <>
|
||||
void setv< std::pair<double, double>, tuple >
|
||||
(eoValueParam< std::pair<double,double> >& p, tuple val)
|
||||
(eoValueParam< std::pair<double,double> >& p, tuple val)
|
||||
{
|
||||
extract<double> first(val[0]);
|
||||
extract<double> second(val[1]);
|
||||
|
|
@ -145,7 +143,7 @@ void define_valueParam(std::string prefix)
|
|||
{
|
||||
std::string name = "eoValueParam";
|
||||
name += prefix;
|
||||
|
||||
|
||||
class_<eoValueParam<T>, bases<eoParam> >(name.c_str(), init<>())
|
||||
.def(init<T, std::string, std::string, char, bool>())
|
||||
.def(init<T, std::string, std::string, char>())
|
||||
|
|
@ -173,7 +171,7 @@ void valueParam()
|
|||
.def("shortName", &eoParam::shortName)
|
||||
.def("required", &eoParam::required)
|
||||
;
|
||||
|
||||
|
||||
define_valueParam<int, int>("Int");
|
||||
define_valueParam<double, double>("Float");
|
||||
define_valueParam<std::vector<double>, numeric::array >("Vec");
|
||||
|
|
@ -191,4 +189,3 @@ void valueParam()
|
|||
.add_property("object", &ValueParam::getObj, &ValueParam::setObj)
|
||||
;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,23 +7,22 @@
|
|||
class ValueParam : public eoParam // ValueParam containing python object
|
||||
{
|
||||
boost::python::object obj;
|
||||
|
||||
public:
|
||||
|
||||
ValueParam() : eoParam(), obj() {}
|
||||
|
||||
ValueParam(boost::python::object o,
|
||||
std::string longName,
|
||||
std::string d = "No Description",
|
||||
char s = 0,
|
||||
bool r = false) : eoParam(longName, "", d, s, r)
|
||||
{
|
||||
std::cerr << "HI" << std::endl;
|
||||
obj = o;
|
||||
eoParam::defValue(getValue());
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
|
||||
ValueParam() : eoParam(), obj() {}
|
||||
|
||||
ValueParam(boost::python::object o,
|
||||
std::string longName,
|
||||
std::string d = "No Description",
|
||||
char s = 0,
|
||||
bool r = false) : eoParam(longName, "", d, s, r)
|
||||
{
|
||||
std::cerr << "HI" << std::endl;
|
||||
obj = o;
|
||||
eoParam::defValue(getValue());
|
||||
}
|
||||
|
||||
std::string getValue() const
|
||||
{
|
||||
boost::python::str s = boost::python::str(obj);
|
||||
|
|
@ -37,7 +36,6 @@ class ValueParam : public eoParam // ValueParam containing python object
|
|||
|
||||
boost::python::object getObj() const { return obj;}
|
||||
void setObj(boost::python::object o) { obj = o; }
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Reference in a new issue