move paradiseo/eo to deprecated/ before merge with eodev
This commit is contained in:
Johann Dreo
parent
948da627ea
commit
0c5120f675
717 changed files with 0 additions and 0 deletions
3
deprecated/eo/src/pyeo/AUTHORS
Normal file
3
deprecated/eo/src/pyeo/AUTHORS
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
|
||||
Maarten Keijzer (mkeijzer@cs.vu.nl)
|
||||
|
||||
174
deprecated/eo/src/pyeo/BUILDING
Normal file
174
deprecated/eo/src/pyeo/BUILDING
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
|
||||
|
||||
To build PyEO, a number of steps are neccessary. PyEO depends on Boost.Python v2,
|
||||
which in turn expects the presence of python2.2. As we can't expect people to have
|
||||
this installed some instructions are in order to help people build PyEO.so
|
||||
|
||||
First of all, currently Windows is not supported. I don't develop on windows and
|
||||
don't have access to a compiler on it.
|
||||
|
||||
PyEO has been developed on Debian, using gcc 2.95-4.
|
||||
|
||||
My primary platform is debian, so the default Makefile provides for that. Below you
|
||||
will also find instructions for rpm-based distributions. As far as I know this includes
|
||||
RedHat, Mandrake, Suse, Yellowdog, and probably a lot more. If I recall correctly, the RPM
|
||||
format is the LSB default.
|
||||
|
||||
===== Building PyEO on Debian =====
|
||||
|
||||
Point your /etc/apt/sources.list to the unstable distribution (if it's not there already),
|
||||
and install:
|
||||
|
||||
for Python:
|
||||
|
||||
$ apt-get install python2.2
|
||||
$ apt-get install python2.2-dev
|
||||
|
||||
It might also be a good idea to install the numeric library
|
||||
|
||||
$ apt-get install python2.2-numeric
|
||||
|
||||
|
||||
For Boost.Python:
|
||||
|
||||
$ apt-get install libboost-python1.29.0
|
||||
$ apt-get install libboost-python-dev
|
||||
|
||||
If all goes well, this will also install libstlport. If it doesn't,
|
||||
|
||||
$ apt-get install libstlport4.5
|
||||
|
||||
and maybe
|
||||
|
||||
$ apt-get install libstlport4.5-dev
|
||||
|
||||
but I'm not sure about the latter.
|
||||
|
||||
Now you can type
|
||||
|
||||
$ make
|
||||
|
||||
And after (a long) wait, a file called PyEO.so will be produced.
|
||||
|
||||
===== Building PyEO on an RPM-based Distro =====
|
||||
|
||||
The following recipe has only been tested on a RedHat 7.1 installation, on other
|
||||
systems some stuff might be different.
|
||||
|
||||
== Getting Python2.2 ==
|
||||
|
||||
If you don't have python2.2 installed (newer distro's install this by default),
|
||||
you can either install it from a binary specifically build for your distro, or
|
||||
you can build it from source by going to:
|
||||
|
||||
http://www.python.org/2.2.1/rpms.html
|
||||
|
||||
and getting the source by clicking the link to python2-2.2.1-2.src.rpm
|
||||
|
||||
This actually links to:
|
||||
|
||||
http://www.python.org/ftp/python/2.2.1/rpms/python2-2.2.1-2.src.rpm
|
||||
|
||||
for your convenience I mirrored this file at:
|
||||
|
||||
http://www.cs.vu.nl/~mkeijzer/PyEO/python2-2.2.1-2.src.rpm
|
||||
|
||||
by usuing the command:
|
||||
|
||||
$ rpm --rebuild python2-2.2.1-2.src.rpm
|
||||
|
||||
or with newer versions of rpm
|
||||
|
||||
$ rpmbuild python2-2.2.1-2.src.rpm
|
||||
|
||||
It will build a binary rpm for your computer. On this Redhat 7.1 box it put the
|
||||
RPMS it build in
|
||||
|
||||
/usr/src/redhat/RPMS/i386/
|
||||
|
||||
The ones you need to install are:
|
||||
|
||||
python2-2.2.1-2.i386.rpm
|
||||
python2-devel-2.2.1-2.i386.rpm
|
||||
|
||||
But you might want to install the rest as well.
|
||||
|
||||
== Getting Boost.Python ==
|
||||
|
||||
First of all, do a quick check. At the prompt type:
|
||||
|
||||
$ python
|
||||
|
||||
If you see something like:
|
||||
|
||||
Python 2.2.2 (#4, Oct 15 2002, 04:21:28)
|
||||
[GCC 2.95.4 20011002 (Debian prerelease)] on linux2
|
||||
Type "help", "copyright", "credits" or "license" for more information.
|
||||
|
||||
(don't mind the second line, It's the version info we're interested in)
|
||||
|
||||
You're set to go. Unfortunately, on this Redhat 7.1 box I tested things on, /usr/bin/python
|
||||
insisted on pointing to /usr/bin/python1.5 . Unfortunately, the boost source rpm depends
|
||||
on python to provide 2.2. If this is the case on your machine as well, there are two
|
||||
possible fixes (of which one I tested).
|
||||
|
||||
/usr/bin/python is a symlink, let it point to /usr/bin/python2.2 (this one I tested)
|
||||
|
||||
DON'T forget to repoint /usr/bin/python to /usr/bin/python1.5 after you build the boost libraries: Redhat tools
|
||||
depend on this!
|
||||
|
||||
or
|
||||
|
||||
alias python=/usr/bin/python2.2 (which would be better if it works, but untested.)
|
||||
|
||||
So given that you are in a shell that uses python2.2 if you issue
|
||||
the command 'python', get two boost source rpms at:
|
||||
|
||||
http://www.starostik.de/malte/boost/
|
||||
|
||||
namely
|
||||
|
||||
boost-jam-3.1.3-1.src.rpm
|
||||
boost-1.29.0-2.src.rpm
|
||||
|
||||
Which I also mirrored at
|
||||
|
||||
http://www.cs.vu.nl/~mkeijzer/PyEO/boost-jam-3.1.3-1.src.rpm
|
||||
http://www.cs.vu.nl/~mkeijzer/PyEO/boost-1.29.0-2.src.rpm
|
||||
|
||||
First build and install jam using either rpm --rebuild or rpmbuild.
|
||||
|
||||
The file you have to install is:
|
||||
|
||||
boost-jam-3.1.3-1.i386.rpm
|
||||
|
||||
This is the 'make' replacement that is used by boost.
|
||||
|
||||
Next, build boost-1.29.0.src.rpm using 'rpm --rebuild' or 'rpmbuild'
|
||||
|
||||
The only rpm's that this procedure produces that you need to install is:
|
||||
|
||||
boost-python-1.29.0-2.i386.rpm
|
||||
boost-python-devel-1.29.0-2.i386.rpm
|
||||
|
||||
|
||||
When installing boost-python-devel, I got a dependency problem with libpython-dev,
|
||||
this was probably caused by the same problem I had with python2.2, python1.5. I ignored
|
||||
it by using:
|
||||
|
||||
$ rpm -i --nodep boost-python-devel-1.29.0-2.i386.rpm
|
||||
|
||||
and you're all set to type
|
||||
|
||||
$ make -fMakefile.rpm
|
||||
|
||||
in the PyEO build directory
|
||||
|
||||
==== Testing PyEO==========
|
||||
|
||||
After building go to the test directory and type
|
||||
|
||||
$ ./run_tests.sh
|
||||
|
||||
If you don't see errors, all is well and you're ready to go
|
||||
|
||||
63
deprecated/eo/src/pyeo/CMakeLists.txt
Normal file
63
deprecated/eo/src/pyeo/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
# --------------------------------------------------------------------------
|
||||
#
|
||||
# PyEO - cmake version
|
||||
#
|
||||
# --------------------------------------------------------------------------
|
||||
#
|
||||
# Hochschule fuer Gestaltung und Kunst Zuerich
|
||||
# Studienberreich Interaction Design
|
||||
# http://interaction.hgkz.ch
|
||||
#
|
||||
# --------------------------------------------------------------------------
|
||||
#
|
||||
# prog: max rheiner;xohm@users.sourceforge.net
|
||||
# date: 7/27/2007 (m/d/y)
|
||||
#
|
||||
# ----------------------------------------------------------------------------
|
||||
|
||||
CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
|
||||
|
||||
PROJECT(PyEO)
|
||||
|
||||
FIND_PACKAGE(Boost 1.42 COMPONENTS python)
|
||||
FIND_PACKAGE(PythonLibs)
|
||||
|
||||
INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})
|
||||
INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH})
|
||||
|
||||
LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
|
||||
|
||||
IF(APPLE)
|
||||
# osx internal
|
||||
FIND_LIBRARY(APPLE_CARBON Carbon)
|
||||
ENDIF(APPLE)
|
||||
|
||||
# includes
|
||||
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
|
||||
#INCLUDE_DIRECTORIES(../)
|
||||
|
||||
# source
|
||||
FILE(GLOB SOURCES *.cpp)
|
||||
|
||||
# EO dependencies
|
||||
SET(EO_SOURCES
|
||||
${EO_SOURCE_DIR}/src/eoFunctorStore.cpp
|
||||
${EO_SOURCE_DIR}/src/utils/eoLogger.cpp
|
||||
${EO_SOURCE_DIR}/src/utils/eoParallel.cpp
|
||||
)
|
||||
|
||||
# shared library
|
||||
ADD_LIBRARY(PyEO MODULE ${SOURCES} ${EO_SOURCES})
|
||||
INSTALL(TARGETS PyEO LIBRARY DESTINATION local/${LIB} COMPONENT libraries)
|
||||
|
||||
# python 2.5 must have pyd
|
||||
IF(WIN32 AND NOT CYGWIN)
|
||||
SET_TARGET_PROPERTIES(PyEO PROPERTIES SUFFIX ".pyd")
|
||||
ENDIF(WIN32 AND NOT CYGWIN)
|
||||
|
||||
# add the libs
|
||||
IF(APPLE)
|
||||
TARGET_LINK_LIBRARIES(PyEO ${APPLE_CARBON} ${PYTHON_LIBRARY} ${Boost_LIBRARIES})
|
||||
ELSE(APPLE)
|
||||
TARGET_LINK_LIBRARIES(PyEO ${PYTHON_LIBRARY} ${Boost_LIBRARIES})
|
||||
ENDIF(APPLE)
|
||||
340
deprecated/eo/src/pyeo/COPYING
Normal file
340
deprecated/eo/src/pyeo/COPYING
Normal file
|
|
@ -0,0 +1,340 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
|
||||
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
License is intended to guarantee your freedom to share and change free
|
||||
software--to make sure the software is free for all its users. This
|
||||
General Public License applies to most of the Free Software
|
||||
Foundation's software and to any other program whose authors commit to
|
||||
using it. (Some other Free Software Foundation software is covered by
|
||||
the GNU Library General Public License instead.) You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if you
|
||||
distribute copies of the software, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must give the recipients all the rights that
|
||||
you have. You must make sure that they, too, receive or can get the
|
||||
source code. And you must show them these terms so they know their
|
||||
rights.
|
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and
|
||||
(2) offer you this license which gives you legal permission to copy,
|
||||
distribute and/or modify the software.
|
||||
|
||||
Also, for each author's protection and ours, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
software. If the software is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original, so
|
||||
that any problems introduced by others will not reflect on the original
|
||||
authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that redistributors of a free
|
||||
program will individually obtain patent licenses, in effect making the
|
||||
program proprietary. To prevent this, we have made it clear that any
|
||||
patent must be licensed for everyone's free use or not licensed at all.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License applies to any program or other work which contains
|
||||
a notice placed by the copyright holder saying it may be distributed
|
||||
under the terms of this General Public License. The "Program", below,
|
||||
refers to any such program or work, and a "work based on the Program"
|
||||
means either the Program or any derivative work under copyright law:
|
||||
that is to say, a work containing the Program or a portion of it,
|
||||
either verbatim or with modifications and/or translated into another
|
||||
language. (Hereinafter, translation is included without limitation in
|
||||
the term "modification".) Each licensee is addressed as "you".
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running the Program is not restricted, and the output from the Program
|
||||
is covered only if its contents constitute a work based on the
|
||||
Program (independent of having been made by running the Program).
|
||||
Whether that is true depends on what the Program does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's
|
||||
source code as you receive it, in any medium, provided that you
|
||||
conspicuously and appropriately publish on each copy an appropriate
|
||||
copyright notice and disclaimer of warranty; keep intact all the
|
||||
notices that refer to this License and to the absence of any warranty;
|
||||
and give any other recipients of the Program a copy of this License
|
||||
along with the Program.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and
|
||||
you may at your option offer warranty protection in exchange for a fee.
|
||||
|
||||
2. You may modify your copy or copies of the Program or any portion
|
||||
of it, thus forming a work based on the Program, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) You must cause the modified files to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
b) You must cause any work that you distribute or publish, that in
|
||||
whole or in part contains or is derived from the Program or any
|
||||
part thereof, to be licensed as a whole at no charge to all third
|
||||
parties under the terms of this License.
|
||||
|
||||
c) If the modified program normally reads commands interactively
|
||||
when run, you must cause it, when started running for such
|
||||
interactive use in the most ordinary way, to print or display an
|
||||
announcement including an appropriate copyright notice and a
|
||||
notice that there is no warranty (or else, saying that you provide
|
||||
a warranty) and that users may redistribute the program under
|
||||
these conditions, and telling the user how to view a copy of this
|
||||
License. (Exception: if the Program itself is interactive but
|
||||
does not normally print such an announcement, your work based on
|
||||
the Program is not required to print an announcement.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Program,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Program, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Program.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Program
|
||||
with the Program (or with a work based on the Program) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may copy and distribute the Program (or a work based on it,
|
||||
under Section 2) in object code or executable form under the terms of
|
||||
Sections 1 and 2 above provided that you also do one of the following:
|
||||
|
||||
a) Accompany it with the complete corresponding machine-readable
|
||||
source code, which must be distributed under the terms of Sections
|
||||
1 and 2 above on a medium customarily used for software interchange; or,
|
||||
|
||||
b) Accompany it with a written offer, valid for at least three
|
||||
years, to give any third party, for a charge no more than your
|
||||
cost of physically performing source distribution, a complete
|
||||
machine-readable copy of the corresponding source code, to be
|
||||
distributed under the terms of Sections 1 and 2 above on a medium
|
||||
customarily used for software interchange; or,
|
||||
|
||||
c) Accompany it with the information you received as to the offer
|
||||
to distribute corresponding source code. (This alternative is
|
||||
allowed only for noncommercial distribution and only if you
|
||||
received the program in object code or executable form with such
|
||||
an offer, in accord with Subsection b above.)
|
||||
|
||||
The source code for a work means the preferred form of the work for
|
||||
making modifications to it. For an executable work, complete source
|
||||
code means all the source code for all modules it contains, plus any
|
||||
associated interface definition files, plus the scripts used to
|
||||
control compilation and installation of the executable. However, as a
|
||||
special exception, the source code distributed need not include
|
||||
anything that is normally distributed (in either source or binary
|
||||
form) with the major components (compiler, kernel, and so on) of the
|
||||
operating system on which the executable runs, unless that component
|
||||
itself accompanies the executable.
|
||||
|
||||
If distribution of executable or object code is made by offering
|
||||
access to copy from a designated place, then offering equivalent
|
||||
access to copy the source code from the same place counts as
|
||||
distribution of the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program
|
||||
except as expressly provided under this License. Any attempt
|
||||
otherwise to copy, modify, sublicense or distribute the Program is
|
||||
void, and will automatically terminate your rights under this License.
|
||||
However, parties who have received copies, or rights, from you under
|
||||
this License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
|
||||
5. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Program or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Program (or any work based on the
|
||||
Program), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Program or works based on it.
|
||||
|
||||
6. Each time you redistribute the Program (or any work based on the
|
||||
Program), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute or modify the Program subject to
|
||||
these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Program at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Program by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Program.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system, which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
8. If the distribution and/or use of the Program is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Program under this License
|
||||
may add an explicit geographical distribution limitation excluding
|
||||
those countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions
|
||||
of the General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies a version number of this License which applies to it and "any
|
||||
later version", you have the option of following the terms and conditions
|
||||
either of that version or of any later version published by the Free
|
||||
Software Foundation. If the Program does not specify a version number of
|
||||
this License, you may choose any version ever published by the Free Software
|
||||
Foundation.
|
||||
|
||||
10. If you wish to incorporate parts of the Program into other free
|
||||
programs whose distribution conditions are different, write to the author
|
||||
to ask for permission. For software which is copyrighted by the Free
|
||||
Software Foundation, write to the Free Software Foundation; we sometimes
|
||||
make exceptions for this. Our decision will be guided by the two goals
|
||||
of preserving the free status of all derivatives of our free software and
|
||||
of promoting the sharing and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
||||
REPAIR OR CORRECTION.
|
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program is interactive, make it output a short notice like this
|
||||
when it starts in an interactive mode:
|
||||
|
||||
Gnomovision version 69, Copyright (C) year name of author
|
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, the commands you use may
|
||||
be called something other than `show w' and `show c'; they could even be
|
||||
mouse-clicks or menu items--whatever suits your program.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1989
|
||||
Ty Coon, President of Vice
|
||||
|
||||
This General Public License does not permit incorporating your program into
|
||||
proprietary programs. If your program is a subroutine library, you may
|
||||
consider it more useful to permit linking proprietary applications with the
|
||||
library. If this is what you want to do, use the GNU Library General
|
||||
Public License instead of this License.
|
||||
35
deprecated/eo/src/pyeo/Makefile
Normal file
35
deprecated/eo/src/pyeo/Makefile
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
# Note for however is foolish enough to attempt to build this thing
|
||||
#
|
||||
# You need:
|
||||
# Python 2.2
|
||||
# Boost.Python v2
|
||||
#
|
||||
|
||||
CXX = g++
|
||||
CPPFLAGS = -Wall -O2 #-g #-O2
|
||||
LDFLAGS =
|
||||
COMPILE = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c
|
||||
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
|
||||
|
||||
LIB=../libeo.a ../utils/libeoutils.a
|
||||
|
||||
all: PyEO/PyEO.so
|
||||
|
||||
clean:
|
||||
rm PyEO/*.so *.o test/*.pyc
|
||||
|
||||
PyEO/PyEO.so: $(OBJECTS)
|
||||
$(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)
|
||||
29
deprecated/eo/src/pyeo/Makefile.rpm
Normal file
29
deprecated/eo/src/pyeo/Makefile.rpm
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
# Makefile for people that build boost using the rpm-recipe
|
||||
|
||||
CXX = g++ #-3.2
|
||||
CXXFLAGS = #-g #-DNDEBUG
|
||||
CPPFLAGS = -Wall -O2
|
||||
LDFLAGS = -L/usr/lib/python2.2/config/
|
||||
COMPILE = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c
|
||||
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 \
|
||||
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
|
||||
|
||||
all: PyEO.so
|
||||
|
||||
clean:
|
||||
rm *.so *.o test/*.pyc
|
||||
|
||||
PyEO.so: $(OBJECTS)
|
||||
$(LINK) -o PyEO.so $(OBJECTS) -lboost_python -lpython2.2 -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)
|
||||
0
deprecated/eo/src/pyeo/NEWS
Normal file
0
deprecated/eo/src/pyeo/NEWS
Normal file
231
deprecated/eo/src/pyeo/PyEO.cpp
Normal file
231
deprecated/eo/src/pyeo/PyEO.cpp
Normal file
|
|
@ -0,0 +1,231 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <sstream>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include <eoPop.h>
|
||||
|
||||
using namespace std;
|
||||
//using namespace boost::python;
|
||||
|
||||
// static member, needs to be instantiated somewhere
|
||||
std::vector<int> PyFitness::objective_info;
|
||||
|
||||
bool PyFitness::dominates(const PyFitness& oth) const
|
||||
{
|
||||
bool dom = false;
|
||||
|
||||
for (unsigned i = 0; i < nObjectives(); ++i)
|
||||
{
|
||||
int objective = objective_info[i];
|
||||
|
||||
if (objective == 0) // ignore
|
||||
continue;
|
||||
|
||||
bool maxim = objective > 0;
|
||||
|
||||
double aval = maxim? (*this)[i] : -(*this)[i];
|
||||
double bval = maxim? oth[i] : -oth[i];
|
||||
|
||||
if (fabs(aval - bval) > tol())
|
||||
{
|
||||
if (aval < bval)
|
||||
{
|
||||
return false; // cannot dominate
|
||||
}
|
||||
// else aval < bval
|
||||
dom = true; // for the moment: goto next objective
|
||||
}
|
||||
//else they're equal in this objective, goto next
|
||||
}
|
||||
|
||||
return dom;
|
||||
}
|
||||
|
||||
bool dominates(const PyEO& a, const PyEO& b)
|
||||
{
|
||||
return PyFitness(a.fitness()).dominates(b.fitness());
|
||||
}
|
||||
|
||||
ostream& operator<<(ostream& os, const PyEO& _eo)
|
||||
{
|
||||
os << _eo.to_string();
|
||||
return os;
|
||||
}
|
||||
|
||||
struct pyPop_pickle_suite : boost::python::pickle_suite
|
||||
{
|
||||
static boost::python::tuple getstate(const eoPop<PyEO>& _pop)
|
||||
{
|
||||
boost::python::list entries;
|
||||
for (unsigned i = 0; i != _pop.size(); ++i)
|
||||
entries.append( PyEO_pickle_suite::getstate(_pop[i]) );
|
||||
|
||||
return boost::python::make_tuple(boost::python::object(_pop.size()), entries);
|
||||
}
|
||||
|
||||
static void setstate( eoPop<PyEO>& _pop, boost::python::tuple pickled)
|
||||
{
|
||||
int sz = boost::python::extract<int>(pickled[0]);
|
||||
boost::python::list entries = boost::python::list(pickled[1]);
|
||||
_pop.resize(sz);
|
||||
for (unsigned i = 0; i != _pop.size(); ++i)
|
||||
{
|
||||
PyEO_pickle_suite::setstate(_pop[i], boost::python::tuple(entries[i]) );
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class T>
|
||||
boost::python::str to_string(T& _p)
|
||||
{
|
||||
std::ostringstream os;
|
||||
_p.printOn(os);
|
||||
return boost::python::str(os.str().c_str());
|
||||
}
|
||||
|
||||
void pop_sort(eoPop<PyEO>& pop) { pop.sort(); }
|
||||
void pop_shuffle(eoPop<PyEO>& pop) { pop.shuffle(); }
|
||||
|
||||
void translate_index_error(index_error const& e)
|
||||
{
|
||||
PyErr_SetString(PyExc_IndexError, e.what.c_str());
|
||||
}
|
||||
|
||||
PyEO& pop_getitem(eoPop<PyEO>& pop, boost::python::object key)
|
||||
{
|
||||
boost::python::extract<int> x(key);
|
||||
if (!x.check())
|
||||
throw index_error("Slicing not allowed");
|
||||
|
||||
int i = x();
|
||||
|
||||
if (static_cast<unsigned>(i) >= pop.size())
|
||||
{
|
||||
throw index_error("Index out of bounds");
|
||||
}
|
||||
return pop[i];
|
||||
}
|
||||
|
||||
void pop_setitem(eoPop<PyEO>& pop, boost::python::object key, PyEO& value)
|
||||
{
|
||||
boost::python::extract<int> x(key);
|
||||
if (!x.check())
|
||||
throw index_error("Slicing not allowed");
|
||||
|
||||
int i = x();
|
||||
|
||||
if (static_cast<unsigned>(i) >= pop.size())
|
||||
{
|
||||
throw index_error("Index out of bounds");
|
||||
}
|
||||
|
||||
pop[i] = value;
|
||||
}
|
||||
|
||||
void pop_push_back(eoPop<PyEO>& pop, PyEO& p) { pop.push_back(p); }
|
||||
void pop_resize( eoPop<PyEO>& pop, unsigned i) { pop.resize(i); }
|
||||
int pop_size( eoPop<PyEO>& pop) { return pop.size(); }
|
||||
|
||||
extern void abstract1();
|
||||
extern void algos();
|
||||
extern void random_numbers();
|
||||
extern void geneticOps();
|
||||
extern void selectOne();
|
||||
extern void continuators();
|
||||
extern void reduce();
|
||||
extern void replacement();
|
||||
extern void selectors();
|
||||
extern void breeders();
|
||||
extern void mergers();
|
||||
extern void valueParam();
|
||||
extern void perf2worth();
|
||||
extern void monitors();
|
||||
extern void statistics();
|
||||
|
||||
BOOST_PYTHON_MODULE(libPyEO)
|
||||
{
|
||||
using namespace boost::python;
|
||||
|
||||
boost::python::register_exception_translator<index_error>(&translate_index_error);
|
||||
|
||||
boost::python::class_<PyEO>("EO")
|
||||
.add_property("fitness", &PyEO::getFitness, &PyEO::setFitness)
|
||||
.add_property("genome", &PyEO::getGenome, &PyEO::setGenome)
|
||||
.def_pickle(PyEO_pickle_suite())
|
||||
.def("invalidate", &PyEO::invalidate)
|
||||
.def("invalid", &PyEO::invalid)
|
||||
.def("__str__", &PyEO::to_string)
|
||||
;
|
||||
|
||||
boost::python::class_<eoPop<PyEO> >("eoPop", init<>() )
|
||||
.def( init< unsigned, eoInit<PyEO>& >()[with_custodian_and_ward<1,3>()] )
|
||||
.def("append", &eoPop<PyEO>::append, "docstring?")
|
||||
.def("__str__", to_string<eoPop<PyEO> >)
|
||||
.def("__len__", pop_size)
|
||||
.def("sort", pop_sort )
|
||||
.def("shuffle", pop_shuffle)
|
||||
.def("__getitem__", pop_getitem, return_internal_reference<>() )
|
||||
.def("__setitem__", pop_setitem)
|
||||
.def("best", &eoPop<PyEO>::best_element, return_internal_reference<>() )
|
||||
.def("push_back", pop_push_back)
|
||||
.def("resize", pop_resize)
|
||||
.def_pickle(pyPop_pickle_suite())
|
||||
;
|
||||
|
||||
|
||||
// Other definitions in different compilation units,
|
||||
// this to avoid having g++ to choke on the load
|
||||
random_numbers();
|
||||
valueParam();
|
||||
abstract1();
|
||||
geneticOps();
|
||||
selectOne();
|
||||
selectors();
|
||||
perf2worth();
|
||||
monitors();
|
||||
statistics();
|
||||
continuators();
|
||||
reduce();
|
||||
replacement();
|
||||
breeders();
|
||||
mergers();
|
||||
algos();
|
||||
|
||||
// The traits class
|
||||
class_<PyFitness>("PyFitness");
|
||||
|
||||
def("nObjectives", &PyFitness::nObjectives);
|
||||
def("tol", &PyFitness::tol);
|
||||
def("maximizing", &PyFitness::maximizing);
|
||||
def("setObjectivesSize", &PyFitness::setObjectivesSize);
|
||||
def("setObjectivesValue", &PyFitness::setObjectivesValue);
|
||||
def("dominates", dominates);
|
||||
}
|
||||
|
||||
|
||||
// to avoid having to build with libeo.a
|
||||
ostream & operator << ( ostream& _os, const eoPrintable& _o )
|
||||
{
|
||||
_o.printOn(_os);
|
||||
return _os;
|
||||
};
|
||||
156
deprecated/eo/src/pyeo/PyEO.h
Normal file
156
deprecated/eo/src/pyeo/PyEO.h
Normal file
|
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#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) {};
|
||||
virtual ~index_error() throw() {}
|
||||
std::string what;
|
||||
};
|
||||
|
||||
class PyFitness : public boost::python::object
|
||||
{
|
||||
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");
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
bool operator<(const PyEO& other) const { return EO<Fitness>::operator<(other); }
|
||||
bool operator>(const PyEO& other) const { return EO<Fitness>::operator>(other); }
|
||||
|
||||
};
|
||||
|
||||
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)
|
||||
{
|
||||
return boost::python::make_tuple(_eo.getFitness(), _eo.genome);
|
||||
}
|
||||
|
||||
static void setstate(PyEO& _eo, boost::python::tuple pickled)
|
||||
{
|
||||
_eo.setFitness( Fitness(pickled[0]) );
|
||||
_eo.genome = pickled[1];
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
83
deprecated/eo/src/pyeo/PyEO/__init__.py
Normal file
83
deprecated/eo/src/pyeo/PyEO/__init__.py
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
from PyEO import *
|
||||
|
||||
try:
|
||||
import Gnuplot
|
||||
except ImportError:
|
||||
print "Python support for Gnuplot not found"
|
||||
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)
|
||||
|
||||
while len(self.values) <= i:
|
||||
self.values.append( [] )
|
||||
|
||||
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')
|
||||
|
||||
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;
|
||||
|
||||
def __call__(self):
|
||||
pass
|
||||
|
||||
class eoStat(eoStatBase, eoValueParam):
|
||||
def __init__(self):
|
||||
eoStatBase.__init__(self)
|
||||
eoValueParam.__init__(self)
|
||||
|
||||
class eoSortedStat(eoSortedStatBase, eoValueParam):
|
||||
def __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 /= len(pop)
|
||||
self.object = sum
|
||||
|
||||
class eoBestFitnessStat(eoSortedStat):
|
||||
def __call__(self, pop):
|
||||
self.object = pop[0].fitness
|
||||
4
deprecated/eo/src/pyeo/README
Normal file
4
deprecated/eo/src/pyeo/README
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
|
||||
See BUILDING for details on how to build this thing
|
||||
|
||||
|
||||
52
deprecated/eo/src/pyeo/abstract1.cpp
Normal file
52
deprecated/eo/src/pyeo/abstract1.cpp
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoInit.h>
|
||||
#include <eoTransform.h>
|
||||
#include <eoSGATransform.h>
|
||||
#include <eoPopEvalFunc.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
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());
|
||||
|
||||
def_abstract_functor<eoPopEvalFunc<PyEO> >("eoPopEvalFunc");
|
||||
}
|
||||
126
deprecated/eo/src/pyeo/algos.cpp
Normal file
126
deprecated/eo/src/pyeo/algos.cpp
Normal file
|
|
@ -0,0 +1,126 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoSGA.h>
|
||||
#include <eoEasyEA.h>
|
||||
#include <eoDetSelect.h>
|
||||
#include <eoCellularEasyEA.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
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>&,
|
||||
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>&>())
|
||||
;
|
||||
*/
|
||||
}
|
||||
59
deprecated/eo/src/pyeo/breeders.cpp
Normal file
59
deprecated/eo/src/pyeo/breeders.cpp
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoBreed.h>
|
||||
#include <eoGeneralBreeder.h>
|
||||
#include <eoOneToOneBreeder.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
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())
|
||||
|
||||
void breeders()
|
||||
{
|
||||
def_abstract_functor<eoBreed<PyEO> >("eoBreed");
|
||||
|
||||
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>() );
|
||||
|
||||
|
||||
DEF3(eoOneToOneBreeder, eoGenOp<PyEO>&, eoEvalFunc<PyEO>&)
|
||||
.def( init<eoGenOp<PyEO>&, eoEvalFunc<PyEO>&, double>()[WC2] )
|
||||
.def( init<eoGenOp<PyEO>&, eoEvalFunc<PyEO>&, double, eoHowMany>()[WC2] );
|
||||
}
|
||||
96
deprecated/eo/src/pyeo/continuators.cpp
Normal file
96
deprecated/eo/src/pyeo/continuators.cpp
Normal file
|
|
@ -0,0 +1,96 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoGenContinue.h>
|
||||
#include <eoCombinedContinue.h>
|
||||
#include <eoEvalContinue.h>
|
||||
#include <eoFitContinue.h>
|
||||
#include <eoSteadyFitContinue.h>
|
||||
#include <utils/eoCheckPoint.h>
|
||||
#include <utils/eoStat.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
#define DEF(x) class_<x<PyEO>, bases<eoContinue<PyEO > > >(#x).def("__call__", &eoContinue<PyEO>::operator())
|
||||
#define DEF2(x, i1) class_<x<PyEO>, bases<eoContinue<PyEO > > >(#x, init<i1>() ).def("__call__", &eoContinue<PyEO>::operator())
|
||||
#define DEF3(x, i1, i2) class_<x<PyEO>, bases<eoContinue<PyEO > > >(#x, init<i1, i2 >() ).def("__call__", &eoContinue<PyEO>::operator())
|
||||
|
||||
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())
|
||||
;
|
||||
/* 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())
|
||||
;
|
||||
|
||||
DEF2(eoFitContinue, object); // object is the fitness type
|
||||
|
||||
DEF3(eoSteadyFitContinue, unsigned long, unsigned long);
|
||||
|
||||
add_checkpoint();
|
||||
}
|
||||
|
||||
void addContinue(eoCheckPoint<PyEO>& c, eoContinue<PyEO>& cc) { c.add(cc); }
|
||||
void addMonitor(eoCheckPoint<PyEO>& c, eoMonitor& m) { c.add(m);}
|
||||
void addStat(eoCheckPoint<PyEO>& c, eoStatBase<PyEO>& s) { c.add(s);}
|
||||
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())
|
||||
;
|
||||
}
|
||||
139
deprecated/eo/src/pyeo/def_abstract_functor.h
Normal file
139
deprecated/eo/src/pyeo/def_abstract_functor.h
Normal file
|
|
@ -0,0 +1,139 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef MAKE_ABSTRACT_FUNCTOR_H
|
||||
#define MAKE_ABSTRACT_FUNCTOR_H
|
||||
|
||||
#include <eoFunctor.h>
|
||||
|
||||
// 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) {}
|
||||
|
||||
typename Proc::result_type operator()(void)
|
||||
{
|
||||
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) {}
|
||||
|
||||
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
|
||||
|
||||
template <class Functor>
|
||||
void def_abstract_functor(std::string name)
|
||||
{
|
||||
eoutils::make_abstract_functor<Functor>(name, Functor::functor_category());
|
||||
}
|
||||
|
||||
template <class Functor>
|
||||
void def_abstract_functor_ref(std::string name)
|
||||
{
|
||||
eoutils::make_abstract_functor_ref<Functor>(name, Functor::functor_category());
|
||||
}
|
||||
|
||||
#endif
|
||||
158
deprecated/eo/src/pyeo/geneticOps.cpp
Normal file
158
deprecated/eo/src/pyeo/geneticOps.cpp
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoGenOp.h>
|
||||
#include <eoOp.h>
|
||||
#include <eoCloneOps.h>
|
||||
#include <eoPopulator.h>
|
||||
#include <eoOpContainer.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
class GenOpWrapper : public eoGenOp<PyEO>
|
||||
{
|
||||
public:
|
||||
|
||||
PyObject* self;
|
||||
GenOpWrapper(PyObject* p) : self(p) {}
|
||||
unsigned max_production(void)
|
||||
{
|
||||
return call_method<unsigned>(self,"max_production");
|
||||
}
|
||||
std::string className() const
|
||||
{
|
||||
return "GenOpDerivative"; // never saw the use of className anyway
|
||||
}
|
||||
|
||||
void apply(eoPopulator<PyEO>& populator )
|
||||
{
|
||||
boost::python::call_method<void>(self,"apply", boost::ref( populator ) );
|
||||
}
|
||||
};
|
||||
|
||||
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");
|
||||
}
|
||||
|
||||
const PyEO& select()
|
||||
{
|
||||
return call_method<const PyEO&>(self,"select");
|
||||
}
|
||||
};
|
||||
|
||||
class MonOpWrapper : public eoMonOp<PyEO>
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
MonOpWrapper(PyObject* p) : self(p) {}
|
||||
bool operator()(PyEO& _eo)
|
||||
{ return boost::python::call_method<bool>(self, "__call__", boost::ref( _eo )); }
|
||||
};
|
||||
class BinOpWrapper : public eoBinOp<PyEO>
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
BinOpWrapper(PyObject* p) : self(p) {}
|
||||
bool operator()(PyEO& _eo, const PyEO& _eo2)
|
||||
{ return boost::python::call_method<bool>(self, "__call__", boost::ref( _eo ), boost::ref(_eo2)); }
|
||||
};
|
||||
class QuadOpWrapper : public eoQuadOp<PyEO>
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
QuadOpWrapper(PyObject* p) : self(p) {}
|
||||
bool operator()(PyEO& _eo, PyEO& _eo2)
|
||||
{ return boost::python::call_method<bool>(self, "__call__", boost::ref( _eo ), boost::ref(_eo2)); }
|
||||
};
|
||||
|
||||
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)
|
||||
;
|
||||
|
||||
class_<eoSeqPopulator<PyEO>, bases<eoPopulator<PyEO> > >
|
||||
("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<>() )
|
||||
;
|
||||
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)
|
||||
;
|
||||
|
||||
class_<eoOp<PyEO> >("eoOp", init<eoOp<PyEO>::OpType>())
|
||||
.def("getType", &eoOp<PyEO>::getType);
|
||||
|
||||
class_<eoMonOp<PyEO>, MonOpWrapper, bases<eoOp<PyEO> >, boost::noncopyable>("eoMonOp", init<>())
|
||||
.def("__call__", &MonOpWrapper::operator(), "an example docstring");
|
||||
class_<eoBinOp<PyEO>, BinOpWrapper, bases<eoOp<PyEO> >, boost::noncopyable>("eoBinOp", init<>())
|
||||
.def("__call__", &BinOpWrapper::operator());
|
||||
class_<eoQuadOp<PyEO>, QuadOpWrapper, bases<eoOp<PyEO> >, boost::noncopyable>("eoQuadOp", init<>())
|
||||
.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())
|
||||
;
|
||||
|
||||
class_<eoSequentialOp<PyEO>, bases<eoGenOp<PyEO> >, boost::noncopyable>("eoSequentialOp", init<>())
|
||||
.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)
|
||||
;
|
||||
|
||||
/* 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());
|
||||
class_<eoQuadCloneOp<PyEO>, bases<eoQuadOp<PyEO> > >("eoQuadCloneOp").def("__call__", &eoQuadCloneOp<PyEO>::operator());
|
||||
|
||||
}
|
||||
40
deprecated/eo/src/pyeo/mergers.cpp
Normal file
40
deprecated/eo/src/pyeo/mergers.cpp
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoMerge.h>
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
#define DEF(x) class_<x<PyEO>, bases<eoMerge<PyEO > > >(#x).def("__call__", &eoMerge<PyEO>::operator())
|
||||
#define DEF2(x, i1) class_<x<PyEO>, bases<eoMerge<PyEO > > >(#x, init<i1>() ).def("__call__", &eoMerge<PyEO>::operator())
|
||||
#define DEF3(x, i1, i2) class_<x<PyEO>, bases<eoMerge<PyEO > > >(#x, init<i1, i2 >() ).def("__call__", &eoMerge<PyEO>::operator())
|
||||
|
||||
void mergers()
|
||||
{
|
||||
def_abstract_functor<eoMerge<PyEO> >("eoMerge");
|
||||
|
||||
DEF2(eoElitism, double)
|
||||
.def( init<double, bool>() );
|
||||
DEF(eoNoElitism);
|
||||
DEF(eoPlus);
|
||||
|
||||
}
|
||||
71
deprecated/eo/src/pyeo/monitors.cpp
Normal file
71
deprecated/eo/src/pyeo/monitors.cpp
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <utils/eoParam.h>
|
||||
#include <utils/eoMonitor.h>
|
||||
#include "PyEO.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
class MonitorWrapper : public eoMonitor
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
list objects;
|
||||
|
||||
MonitorWrapper(PyObject* p) :self(p) {}
|
||||
|
||||
eoMonitor& operator()()
|
||||
{
|
||||
call_method<void>(self, "__call__");
|
||||
return *this;
|
||||
}
|
||||
|
||||
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
|
||||
* 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)
|
||||
;
|
||||
}
|
||||
89
deprecated/eo/src/pyeo/perf2worth.cpp
Normal file
89
deprecated/eo/src/pyeo/perf2worth.cpp
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
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"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
struct Perf2WorthWrapper : public eoPerf2Worth<PyEO,double>
|
||||
{
|
||||
PyObject* self;
|
||||
Perf2WorthWrapper(PyObject* p) : self(p) {}
|
||||
|
||||
void operator()( const eoPop<PyEO>& 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]);
|
||||
|
||||
return numeric::array(result);
|
||||
}
|
||||
|
||||
struct CachedPerf2WorthWrapper : public eoPerf2WorthCached<PyEO, double>
|
||||
{
|
||||
PyObject* self;
|
||||
CachedPerf2WorthWrapper(PyObject* p) : self(p) {}
|
||||
|
||||
void calculate_worths(const eoPop<PyEO>& pop)
|
||||
{
|
||||
call_method<void>(self, "calculate_worths", boost::ref(pop));
|
||||
}
|
||||
};
|
||||
|
||||
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_<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);
|
||||
}
|
||||
70
deprecated/eo/src/pyeo/pickle.h
Normal file
70
deprecated/eo/src/pyeo/pickle.h
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef PICKLE_H
|
||||
#define PICKLE_h
|
||||
|
||||
// #ifndef WIN32
|
||||
// #include <config.h>
|
||||
// #endif
|
||||
|
||||
#include <boost/python.hpp>
|
||||
#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();
|
||||
}
|
||||
|
||||
static
|
||||
boost::python::tuple getstate(const T& t)
|
||||
{
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
/** Defines persistency through pickle support by using std::strings
|
||||
* so while we're at it, we will .def("__str__") as well
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
#endif
|
||||
112
deprecated/eo/src/pyeo/random_numbers.cpp
Normal file
112
deprecated/eo/src/pyeo/random_numbers.cpp
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <utils/eoRNG.h>
|
||||
#include <boost/python.hpp>
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
#include <sstream>
|
||||
#include <boost/python/detail/api_placeholder.hpp>
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
// initialize static constants
|
||||
const uint32_t eoRng::K(0x9908B0DFU);
|
||||
const int eoRng::M(397);
|
||||
const int eoRng::N(624);
|
||||
|
||||
namespace eo
|
||||
{
|
||||
eoRng rng(time(0));
|
||||
}
|
||||
|
||||
eoRng& get_rng() { return rng; }
|
||||
double normal(eoRng& rng) { return rng.normal(); }
|
||||
|
||||
std::string rng_to_string(const eoRng& _rng)
|
||||
{
|
||||
std::ostringstream os;
|
||||
_rng.printOn(os);
|
||||
os << std::ends;
|
||||
return os.str();
|
||||
}
|
||||
|
||||
|
||||
void rng_from_string(eoRng& _rng, std::string s)
|
||||
{
|
||||
std::istringstream is(s);
|
||||
_rng.readFrom(is);
|
||||
}
|
||||
|
||||
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)));
|
||||
}
|
||||
static
|
||||
void setstate(eoRng& _rng, boost::python::tuple pickled)
|
||||
{
|
||||
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?
|
||||
}
|
||||
}
|
||||
|
||||
double chance = _rng.uniform() * total;
|
||||
|
||||
int i = 0;
|
||||
while (chance >= 0.0)
|
||||
chance -= extract<double>(values[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("rng", get_rng, return_value_policy<reference_existing_object>());
|
||||
}
|
||||
63
deprecated/eo/src/pyeo/reduce.cpp
Normal file
63
deprecated/eo/src/pyeo/reduce.cpp
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoReduce.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
// unfortunately have to define it specially
|
||||
class eoReduceWrapper : public eoReduce<PyEO>
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
eoReduceWrapper(PyObject* s) : self(s) {}
|
||||
void operator()(eoPop<PyEO>& pop, unsigned i)
|
||||
{
|
||||
boost::python::call_method<void>(self, "__call__", pop, i );
|
||||
}
|
||||
};
|
||||
|
||||
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());
|
||||
|
||||
class_<eoTruncate<PyEO>, bases<eoReduce<PyEO> > >("eoTruncate", init<>() )
|
||||
.def("__call__", &eoReduce<PyEO>::operator())
|
||||
;
|
||||
class_<eoRandomReduce<PyEO>, bases<eoReduce<PyEO> > >("eoRandomReduce")
|
||||
.def("__call__", &eoReduce<PyEO>::operator())
|
||||
;
|
||||
class_<eoEPReduce<PyEO>, bases<eoReduce<PyEO> > >("eoEPReduce", init<unsigned>())
|
||||
.def("__call__", &eoReduce<PyEO>::operator())
|
||||
;
|
||||
class_<eoLinearTruncate<PyEO>, bases<eoReduce<PyEO> > >("eoLinearTruncate")
|
||||
.def("__call__", &eoReduce<PyEO>::operator())
|
||||
;
|
||||
class_<eoDetTournamentTruncate<PyEO>, bases<eoReduce<PyEO> > >("eoDetTournamentTruncate", init<unsigned>())
|
||||
.def("__call__", &eoReduce<PyEO>::operator())
|
||||
;
|
||||
class_<eoStochTournamentTruncate<PyEO>, bases<eoReduce<PyEO> > >("eoStochTournamentTruncate", init<double>())
|
||||
.def("__call__", &eoReduce<PyEO>::operator())
|
||||
;
|
||||
}
|
||||
72
deprecated/eo/src/pyeo/replacement.cpp
Normal file
72
deprecated/eo/src/pyeo/replacement.cpp
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoReplacement.h>
|
||||
#include <eoMergeReduce.h>
|
||||
#include <eoReduceMerge.h>
|
||||
#include <eoReduceMergeReduce.h>
|
||||
#include <eoMGGReplacement.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
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]) \
|
||||
.def("__call__", &eoReplacement<PyEO>::operator())
|
||||
|
||||
void replacement()
|
||||
{
|
||||
def_abstract_functor<eoReplacement<PyEO> >("eoReplacement");
|
||||
|
||||
// eoReplacement.h
|
||||
DEF(eoGenerationalReplacement);
|
||||
|
||||
class_<eoWeakElitistReplacement<PyEO>, bases<eoReplacement<PyEO> > >
|
||||
("eoWeakElitistReplacement",
|
||||
init< eoReplacement<PyEO>& >()[WC1]);
|
||||
|
||||
// eoMergeReduce.h
|
||||
DEF3(eoMergeReduce, eoMerge<PyEO>&, eoReduce<PyEO>& );
|
||||
DEF(eoPlusReplacement);
|
||||
DEF(eoCommaReplacement);
|
||||
DEF2(eoEPReplacement, unsigned);
|
||||
|
||||
// eoReduceMerge.h
|
||||
DEF3(eoReduceMerge, eoReduce<PyEO>&, eoMerge<PyEO>& );
|
||||
DEF(eoSSGAWorseReplacement);
|
||||
DEF2(eoSSGADetTournamentReplacement, unsigned);
|
||||
DEF2(eoSSGAStochTournamentReplacement, double);
|
||||
|
||||
// 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());
|
||||
|
||||
//eoMGGReplacement
|
||||
DEF(eoMGGReplacement)
|
||||
.def( init<eoHowMany>() )
|
||||
.def( init<eoHowMany, unsigned>() );
|
||||
}
|
||||
108
deprecated/eo/src/pyeo/selectOne.cpp
Normal file
108
deprecated/eo/src/pyeo/selectOne.cpp
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoSelectOne.h>
|
||||
#include <eoDetTournamentSelect.h>
|
||||
#include <eoRandomSelect.h>
|
||||
#include <eoStochTournamentSelect.h>
|
||||
#include <eoTruncatedSelectOne.h>
|
||||
#include <eoSequentialSelect.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "pickle.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
class eoSelectOneWrapper : public eoSelectOne<PyEO>
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
eoSelectOneWrapper(PyObject* p) : self(p) {}
|
||||
const PyEO& operator()(const eoPop<PyEO>& pop)
|
||||
{
|
||||
return boost::python::call_method< const PyEO& >(self, "__call__", boost::ref(pop));
|
||||
}
|
||||
};
|
||||
|
||||
template <class Select>
|
||||
void add_select(std::string name)
|
||||
{
|
||||
class_<Select, bases<eoSelectOne<PyEO> > >(name.c_str(), init<>() )
|
||||
.def("__call__", &Select::operator(), return_internal_reference<>() )
|
||||
;
|
||||
}
|
||||
|
||||
template <class Select, class Init>
|
||||
void add_select(std::string name, Init init)
|
||||
{
|
||||
class_<Select, bases<eoSelectOne<PyEO> > >(name.c_str(), 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)
|
||||
{
|
||||
class_<Select, bases<eoSelectOne<PyEO> > >(name.c_str(), init1)
|
||||
.def( init2 )
|
||||
.def("__call__", &Select::operator(), return_internal_reference<>() )
|
||||
.def("setup", &Select::setup);
|
||||
}
|
||||
|
||||
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-)
|
||||
);
|
||||
|
||||
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]
|
||||
);
|
||||
|
||||
// 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>
|
||||
*/
|
||||
}
|
||||
60
deprecated/eo/src/pyeo/selectors.cpp
Normal file
60
deprecated/eo/src/pyeo/selectors.cpp
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <eoSelect.h>
|
||||
#include <eoDetSelect.h>
|
||||
#include <eoSelectMany.h>
|
||||
#include <eoSelectNumber.h>
|
||||
#include <eoSelectPerc.h>
|
||||
#include <eoTruncSelect.h>
|
||||
#include <eoTruncatedSelectMany.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "def_abstract_functor.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
#define DEF(x) class_<x<PyEO>, bases<eoSelect<PyEO > > >(#x).def("__call__", &eoSelect<PyEO>::operator())
|
||||
#define DEF2(x, i1) class_<x<PyEO>, bases<eoSelect<PyEO > > >(#x, init<i1>()[WC1] ).def("__call__", &eoSelect<PyEO>::operator())
|
||||
#define DEF3(x, i1, i2) class_<x<PyEO>, bases<eoSelect<PyEO > > >(#x, init<i1, i2 >()[WC1] ).def("__call__", &eoSelect<PyEO>::operator())
|
||||
|
||||
void selectors()
|
||||
{
|
||||
def_abstract_functor<eoSelect<PyEO> >("eoSelect");
|
||||
|
||||
DEF(eoDetSelect).def( init<double>() ).def( init<double, bool>() );
|
||||
DEF3(eoSelectMany, eoSelectOne<PyEO>&, double)
|
||||
.def( init< eoSelectOne<PyEO>&, double, bool>()[WC1] )
|
||||
.def( init< eoSelectOne<PyEO>&, eoHowMany>()[WC1] );
|
||||
|
||||
DEF2(eoSelectNumber, eoSelectOne<PyEO>&)
|
||||
.def( init< eoSelectOne<PyEO>&, unsigned>()[WC1]);
|
||||
|
||||
DEF2(eoSelectPerc, eoSelectOne<PyEO>&)
|
||||
.def( init<eoSelectOne<PyEO>&, float>()[WC1] );
|
||||
|
||||
DEF3(eoTruncSelect, eoSelectOne<PyEO>&, eoHowMany);
|
||||
|
||||
class_<eoTruncatedSelectMany<PyEO>, bases<eoSelect<PyEO> > >("eoTruncatedSelectMany",
|
||||
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]);
|
||||
}
|
||||
61
deprecated/eo/src/pyeo/statistics.cpp
Normal file
61
deprecated/eo/src/pyeo/statistics.cpp
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
#include <utils/eoStat.h>
|
||||
|
||||
#include "PyEO.h"
|
||||
#include "valueParam.h"
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
class StatBaseWrapper : public eoStatBase<PyEO>
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
StatBaseWrapper(PyObject* p) : self(p) {}
|
||||
|
||||
void operator()(const eoPop<PyEO>& pop)
|
||||
{
|
||||
call_method<void>(self, "__call__", boost::ref(pop));
|
||||
}
|
||||
};
|
||||
|
||||
class SortedStatBaseWrapper : public eoSortedStatBase<PyEO>
|
||||
{
|
||||
public:
|
||||
PyObject* self;
|
||||
SortedStatBaseWrapper(PyObject* p) : self(p) {}
|
||||
|
||||
void operator()(const std::vector<const PyEO*>& pop)
|
||||
{
|
||||
call_method<void>(self, "__call__", boost::ref(pop));
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::vector<const PyEO*> eoPopView;
|
||||
|
||||
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];
|
||||
}
|
||||
|
||||
void statistics()
|
||||
{
|
||||
class_<eoStatBase<PyEO>, StatBaseWrapper, boost::noncopyable>
|
||||
("eoStatBase", init<>())
|
||||
.def("lastCall", &eoStatBase<PyEO>::lastCall)
|
||||
.def("__call__", &StatBaseWrapper::operator())
|
||||
;
|
||||
|
||||
class_< eoPopView >("eoPopView")
|
||||
.def("__getitem__", popview_getitem, return_internal_reference<>() )
|
||||
.def("__len__", &eoPopView::size)
|
||||
;
|
||||
|
||||
class_<eoSortedStatBase<PyEO>, SortedStatBaseWrapper, boost::noncopyable>
|
||||
("eoSortedStatBase", init<>())
|
||||
.def("lastCall", &eoSortedStatBase<PyEO>::lastCall)
|
||||
.def("__call__", &SortedStatBaseWrapper::operator())
|
||||
;
|
||||
}
|
||||
88
deprecated/eo/src/pyeo/test/maxone.py
Normal file
88
deprecated/eo/src/pyeo/test/maxone.py
Normal file
|
|
@ -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
|
||||
7
deprecated/eo/src/pyeo/test/run_tests.sh
Executable file
7
deprecated/eo/src/pyeo/test/run_tests.sh
Executable file
|
|
@ -0,0 +1,7 @@
|
|||
#!/bin/sh
|
||||
|
||||
for i in *.py
|
||||
do
|
||||
python2 $i > /dev/null
|
||||
|
||||
done
|
||||
30
deprecated/eo/src/pyeo/test/test_breeders.py
Normal file
30
deprecated/eo/src/pyeo/test/test_breeders.py
Normal file
|
|
@ -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()
|
||||
166
deprecated/eo/src/pyeo/test/test_mo.py
Normal file
166
deprecated/eo/src/pyeo/test/test_mo.py
Normal file
|
|
@ -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()
|
||||
91
deprecated/eo/src/pyeo/test/test_pickling.py
Normal file
91
deprecated/eo/src/pyeo/test/test_pickling.py
Normal file
|
|
@ -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()
|
||||
82
deprecated/eo/src/pyeo/test/test_populator.py
Normal file
82
deprecated/eo/src/pyeo/test/test_populator.py
Normal file
|
|
@ -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()
|
||||
32
deprecated/eo/src/pyeo/test/test_reduce.py
Normal file
32
deprecated/eo/src/pyeo/test/test_reduce.py
Normal file
|
|
@ -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()
|
||||
62
deprecated/eo/src/pyeo/test/test_selectone.py
Normal file
62
deprecated/eo/src/pyeo/test/test_selectone.py
Normal file
|
|
@ -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()
|
||||
45
deprecated/eo/src/pyeo/test/test_sga.py
Normal file
45
deprecated/eo/src/pyeo/test/test_sga.py
Normal file
|
|
@ -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()
|
||||
62
deprecated/eo/src/pyeo/test/test_transform.py
Normal file
62
deprecated/eo/src/pyeo/test/test_transform.py
Normal file
|
|
@ -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
|
||||
191
deprecated/eo/src/pyeo/valueParam.cpp
Normal file
191
deprecated/eo/src/pyeo/valueParam.cpp
Normal file
|
|
@ -0,0 +1,191 @@
|
|||
/*
|
||||
PyEO
|
||||
|
||||
Copyright (C) 2003 Maarten Keijzer
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <utils/eoParam.h>
|
||||
#include <stdexcept>
|
||||
|
||||
// Here's 'len'. Why? dunno
|
||||
#include "valueParam.h"
|
||||
#include <boost/python/detail/api_placeholder.hpp>
|
||||
|
||||
using namespace boost::python;
|
||||
|
||||
class ParamWrapper : public eoParam
|
||||
{
|
||||
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 getValue() const
|
||||
{
|
||||
return call_method<std::string>(self, "getValueAsString");
|
||||
}
|
||||
|
||||
void setValue(const std::string& s)
|
||||
{
|
||||
call_method<void>(self, "setValueAsString", s);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct ValueParam_pickle_suite : boost::python::pickle_suite
|
||||
{
|
||||
static
|
||||
boost::python::tuple getstate(const eoValueParam<T>& _param)
|
||||
{
|
||||
str v(_param.getValue());
|
||||
str d(_param.description());
|
||||
str def(_param.defValue());
|
||||
str l(_param.longName());
|
||||
object s(_param.shortName());
|
||||
object r(_param.required());
|
||||
return make_tuple(v,d,def,l,s,r);
|
||||
}
|
||||
static
|
||||
void setstate(eoValueParam<T>& _param, boost::python::tuple pickled)
|
||||
{
|
||||
std::string v = extract<std::string>(pickled[0]);
|
||||
std::string d = extract<std::string>(pickled[1]);
|
||||
std::string def = extract<std::string>(pickled[2]);
|
||||
std::string l = extract<std::string>(pickled[3]);
|
||||
char s = extract<char>(pickled[4]);
|
||||
bool r = extract<bool>(pickled[5]);
|
||||
|
||||
_param = eoValueParam<T>(T(), l, d, s, r);
|
||||
_param.defValue(d);
|
||||
_param.setValue(v);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T, class U>
|
||||
U getv(const eoValueParam<T>& v) { return v.value(); }
|
||||
|
||||
template <class T, class U>
|
||||
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 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)
|
||||
{
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
template <>
|
||||
tuple getv<std::pair<double, double>, tuple >
|
||||
(const eoValueParam< std::pair<double,double> >& p)
|
||||
{
|
||||
return make_tuple(p.value().first, p.value().second);
|
||||
}
|
||||
|
||||
template <>
|
||||
void setv< std::pair<double, double>, tuple >
|
||||
(eoValueParam< std::pair<double,double> >& p, tuple val)
|
||||
{
|
||||
extract<double> first(val[0]);
|
||||
extract<double> second(val[1]);
|
||||
|
||||
if (!first.check())
|
||||
throw std::runtime_error("doubles expected");
|
||||
if (!second.check())
|
||||
throw std::runtime_error("doubles expected");
|
||||
|
||||
p.value().first = first();
|
||||
p.value().second = second();
|
||||
}
|
||||
|
||||
template <class T, class U>
|
||||
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>())
|
||||
.def(init<T, std::string, std::string>())
|
||||
.def(init<T, std::string>())
|
||||
.def("getValueAsString", &eoValueParam<T>::getValue)
|
||||
.def("__str__", &eoValueParam<T>::getValue)
|
||||
.def("setValueAsString", &eoValueParam<T>::setValue)
|
||||
.def("getValue", getv<T, U>)
|
||||
.def("setValue", setv<T, U>)
|
||||
.add_property("value", getv<T, U>, setv<T, U>)
|
||||
.def_pickle(ValueParam_pickle_suite<T>())
|
||||
;
|
||||
}
|
||||
|
||||
void valueParam()
|
||||
{
|
||||
class_<eoParam, ParamWrapper, boost::noncopyable>("eoParam", init<>())
|
||||
.def(init< std::string, std::string, std::string, char, bool>())
|
||||
.def("getValueAsString", &ParamWrapper::getValue)
|
||||
.def("setValueAsString", &ParamWrapper::setValue)
|
||||
.def("longName", &eoParam::longName, return_value_policy<copy_const_reference>())
|
||||
//.def("defValue", &eoParam::defValue, return_value_policy<copy_const_reference>())
|
||||
.def("description", &eoParam::description, return_value_policy<copy_const_reference>())
|
||||
.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");
|
||||
define_valueParam< std::pair<double, double>, tuple >("Pair");
|
||||
//define_valueParam< object, object >("Py");
|
||||
|
||||
class_<ValueParam, bases<eoParam> >("eoValueParam", init<>())
|
||||
//.def(init<object, std::string, std::string, char, bool>())
|
||||
//.def(init<object, std::string, std::string, char>())
|
||||
//.def(init<object, std::string, std::string>())
|
||||
.def(init<object, std::string>())
|
||||
.def("getValueAsString", &ValueParam::getValue)
|
||||
.def("__str__", &ValueParam::getValue)
|
||||
.def("setValueAsString", &ValueParam::setValue)
|
||||
.add_property("object", &ValueParam::getObj, &ValueParam::setObj)
|
||||
;
|
||||
}
|
||||
41
deprecated/eo/src/pyeo/valueParam.h
Normal file
41
deprecated/eo/src/pyeo/valueParam.h
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
#ifndef VALUEPARAM_H
|
||||
#define VALUEPARAM_H
|
||||
|
||||
#include <string>
|
||||
#include <boost/python.hpp>
|
||||
|
||||
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());
|
||||
}
|
||||
|
||||
std::string getValue() const
|
||||
{
|
||||
boost::python::str s = boost::python::str(obj);
|
||||
return std::string(boost::python::extract<const char*>(s));
|
||||
}
|
||||
|
||||
void setValue(const std::string& v)
|
||||
{
|
||||
std::cerr << "not implemented yet" << std::endl;
|
||||
}
|
||||
|
||||
boost::python::object getObj() const { return obj;}
|
||||
void setObj(boost::python::object o) { obj = o; }
|
||||
};
|
||||
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue