delete tag
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@398 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
liefooga
parent
b1d6dd41c0
commit
dde0756c97
129 changed files with 0 additions and 11745 deletions
|
|
@ -1,4 +0,0 @@
|
|||
Arnaud Liefooghe
|
||||
Thomas Legrand
|
||||
Sébastien Cahon
|
||||
Abdelhakim Deneche
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
SUBDIRS = doc src tutorial
|
||||
|
||||
clean_all: clean_aux clean_doc
|
||||
-@make clean
|
||||
-@(rm -rf aclocal.m4 autom4te.cache configure config.* CO* dep* INST* install-sh miss* mkins* Makefile Makefile.in;\
|
||||
cd doc; rm -rf Makefile Makefile.in *.doxytag; cd ../src ; rm -rf Makefile Makefile.in; cd core ; rm -rf Makefile Makefile.in;\
|
||||
cd ../../tutorial; rm -rf Makefile Makefile.in; cd Lesson1; rm -rf .deps/ Makefile Makefile.in *.status;\
|
||||
cd flowshop; rm -rf .deps/ Makefile Makefile.in; cd ../../Lesson2; rm -rf .deps/ Makefile Makefile.in)
|
||||
|
||||
clean_aux:
|
||||
-@find . \( -name "*~" -o -name "*.old" -o -name "#*" -o -name "*.bak" \) -print -exec rm -rf \{\} \;
|
||||
|
||||
doc:
|
||||
-@(cd doc; make doc)
|
||||
|
||||
clean_doc:
|
||||
-@(cd doc; make clean-local)
|
||||
|
|
@ -1 +0,0 @@
|
|||
* release 1.0
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
PARADISEO-MOEO README FILE
|
||||
=======================================================================
|
||||
check latest news at http://paradiseo.gforge.inria.fr/
|
||||
=======================================================================
|
||||
|
||||
Welcome to ParadisEO-MOEO, the Multi-Objective Evolving Objects library.
|
||||
The latest news about ParadisEO-MOEO can be found on the gforge repository at
|
||||
http://paradiseo.gforge.inria.fr/
|
||||
In case of any problem, please e-mail us at
|
||||
paradiseo-help@lists.gforge.inria.fr
|
||||
|
||||
|
||||
==================================================================
|
||||
BUILDING PARADISEO-MOEO
|
||||
==================================================================
|
||||
The basic installation procedure goes the following:
|
||||
|
||||
Go to your build-directory and run
|
||||
> ./autogen.sh --with-EOdir=$(EO_SRC)
|
||||
> make
|
||||
> make doc
|
||||
|
||||
where $(EO_SRC) is the top-level source directory of PARADISEO-EO.
|
||||
|
||||
In case of problems, you can read the INSTALL file - but remember this
|
||||
is a standard installation file from GNU and that it contains nothing
|
||||
specific about PARADISEO-MOEO.
|
||||
|
||||
To clean everything, the simply run
|
||||
> make clean_all
|
||||
|
||||
===================================================================
|
||||
DIRECTORY STRUCTURE
|
||||
===================================================================
|
||||
After unpacking the archive file, you should end up with the following
|
||||
structure:
|
||||
|
||||
.../ The main PARADISEO-MOEO directory, created when unpacking.
|
||||
|
|
||||
+-- src SOURCE directory Contains most PARADISEO-MOEO .h files.
|
||||
|
|
||||
+-- docs DOCUMENTATION directory (generated by Doxygen).
|
||||
| |
|
||||
| +- html HTML files - start at index.html.
|
||||
| |
|
||||
| +- latex latex files - use to generate Postcript doc.
|
||||
| |
|
||||
| +- man Unix man format documentation.
|
||||
|
|
||||
|
|
||||
+-- tutorials APPLICATIONS - one directory per separate application.
|
||||
|
|
||||
+-- lesson1 A bi-objective flow-shop problem example with main algorithms.
|
||||
| |
|
||||
| +- flowshop Flow-shop source files
|
||||
| |
|
||||
| +- benchmarks Instance files for testing.
|
||||
|
|
||||
|-- lesson2 Implement NSGA-II for the SCH1 problem.
|
||||
|
||||
===================================================================
|
||||
NOTES
|
||||
===================================================================
|
||||
|
||||
Mailing list : paradiseo-help@lists.gforge.inria.fr
|
||||
|
|
@ -1,148 +0,0 @@
|
|||
#!/bin/sh
|
||||
# Run this to generate all the initial makefiles, etc.
|
||||
|
||||
srcdir=`dirname $0`
|
||||
PKG_NAME="the package."
|
||||
|
||||
DIE=0
|
||||
|
||||
(autoconf --version) < /dev/null > /dev/null 2>&1 || {
|
||||
echo
|
||||
echo "**Error**: You must have \`autoconf' installed to."
|
||||
echo "Download the appropriate package for your distribution,"
|
||||
echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/"
|
||||
DIE=1
|
||||
}
|
||||
|
||||
(grep "^AM_PROG_LIBTOOL" $srcdir/configure.in >/dev/null) && {
|
||||
(libtool --version) < /dev/null > /dev/null 2>&1 || {
|
||||
echo
|
||||
echo "**Error**: You must have \`libtool' installed."
|
||||
echo "Get ftp://ftp.gnu.org/pub/gnu/libtool-1.2d.tar.gz"
|
||||
echo "(or a newer version if it is available)"
|
||||
DIE=1
|
||||
}
|
||||
}
|
||||
|
||||
grep "^AM_GNU_GETTEXT" $srcdir/configure.in >/dev/null && {
|
||||
grep "sed.*POTFILES" $srcdir/configure.in >/dev/null || \
|
||||
(gettext --version) < /dev/null > /dev/null 2>&1 || {
|
||||
echo
|
||||
echo "**Error**: You must have \`gettext' installed."
|
||||
echo "Get ftp://alpha.gnu.org/gnu/gettext-0.10.35.tar.gz"
|
||||
echo "(or a newer version if it is available)"
|
||||
DIE=1
|
||||
}
|
||||
}
|
||||
|
||||
grep "^AM_GNOME_GETTEXT" $srcdir/configure.in >/dev/null && {
|
||||
grep "sed.*POTFILES" $srcdir/configure.in >/dev/null || \
|
||||
(gettext --version) < /dev/null > /dev/null 2>&1 || {
|
||||
echo
|
||||
echo "**Error**: You must have \`gettext' installed."
|
||||
echo "Get ftp://alpha.gnu.org/gnu/gettext-0.10.35.tar.gz"
|
||||
echo "(or a newer version if it is available)"
|
||||
DIE=1
|
||||
}
|
||||
}
|
||||
|
||||
(automake --version) < /dev/null > /dev/null 2>&1 || {
|
||||
echo
|
||||
echo "**Error**: You must have \`automake' installed."
|
||||
echo "Get ftp://ftp.gnu.org/pub/gnu/automake-1.3.tar.gz"
|
||||
echo "(or a newer version if it is available)"
|
||||
DIE=1
|
||||
NO_AUTOMAKE=yes
|
||||
}
|
||||
|
||||
|
||||
# if no automake, don't bother testing for aclocal
|
||||
test -n "$NO_AUTOMAKE" || (aclocal --version) < /dev/null > /dev/null 2>&1 || {
|
||||
echo
|
||||
echo "**Error**: Missing \`aclocal'. The version of \`automake'"
|
||||
echo "installed doesn't appear recent enough."
|
||||
echo "Get ftp://ftp.gnu.org/pub/gnu/automake-1.3.tar.gz"
|
||||
echo "(or a newer version if it is available)"
|
||||
DIE=1
|
||||
}
|
||||
|
||||
if test "$DIE" -eq 1; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if test -z "$*"; then
|
||||
echo "**Warning**: I am going to run \`configure' with no arguments."
|
||||
echo "If you wish to pass any to it, please specify them on the"
|
||||
echo \`$0\'" command line."
|
||||
echo
|
||||
fi
|
||||
|
||||
case $CC in
|
||||
xlc )
|
||||
am_opt=--include-deps;;
|
||||
esac
|
||||
|
||||
for coin in `find $srcdir -name configure.in -print`
|
||||
do
|
||||
dr=`dirname $coin`
|
||||
if test -f $dr/NO-AUTO-GEN; then
|
||||
echo skipping $dr -- flagged as no auto-gen
|
||||
else
|
||||
echo processing $dr
|
||||
macrodirs=`sed -n -e 's,AM_ACLOCAL_INCLUDE(\(.*\)),\1,gp' < $coin`
|
||||
( cd $dr
|
||||
aclocalinclude="$ACLOCAL_FLAGS"
|
||||
for k in $macrodirs; do
|
||||
if test -d $k; then
|
||||
aclocalinclude="$aclocalinclude -I $k"
|
||||
##else
|
||||
## echo "**Warning**: No such directory \`$k'. Ignored."
|
||||
fi
|
||||
done
|
||||
if grep "^AM_GNU_GETTEXT" configure.in >/dev/null; then
|
||||
if grep "sed.*POTFILES" configure.in >/dev/null; then
|
||||
: do nothing -- we still have an old unmodified configure.in
|
||||
else
|
||||
echo "Creating $dr/aclocal.m4 ..."
|
||||
test -r $dr/aclocal.m4 || touch $dr/aclocal.m4
|
||||
echo "Running gettextize... Ignore non-fatal messages."
|
||||
echo "no" | gettextize --force --copy
|
||||
echo "Making $dr/aclocal.m4 writable ..."
|
||||
test -r $dr/aclocal.m4 && chmod u+w $dr/aclocal.m4
|
||||
fi
|
||||
fi
|
||||
if grep "^AM_GNOME_GETTEXT" configure.in >/dev/null; then
|
||||
echo "Creating $dr/aclocal.m4 ..."
|
||||
test -r $dr/aclocal.m4 || touch $dr/aclocal.m4
|
||||
echo "Running gettextize... Ignore non-fatal messages."
|
||||
echo "no" | gettextize --force --copy
|
||||
echo "Making $dr/aclocal.m4 writable ..."
|
||||
test -r $dr/aclocal.m4 && chmod u+w $dr/aclocal.m4
|
||||
fi
|
||||
if grep "^AM_PROG_LIBTOOL" configure.in >/dev/null; then
|
||||
echo "Running libtoolize..."
|
||||
libtoolize --force --copy
|
||||
fi
|
||||
echo "Running aclocal $aclocalinclude ..."
|
||||
aclocal $aclocalinclude
|
||||
if grep "^AM_CONFIG_HEADER" configure.in >/dev/null; then
|
||||
echo "Running autoheader..."
|
||||
autoheader
|
||||
fi
|
||||
echo "Running automake --gnu $am_opt ..."
|
||||
automake --add-missing --gnu $am_opt
|
||||
echo "Running autoconf ..."
|
||||
autoconf
|
||||
)
|
||||
fi
|
||||
done
|
||||
|
||||
#conf_flags="--enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
|
||||
|
||||
if test x$NOCONFIGURE = x; then
|
||||
echo Running $srcdir/configure $conf_flags "$@" ...
|
||||
$srcdir/configure $conf_flags "$@" \
|
||||
&& echo Now type \`make\' to compile $PKG_NAME
|
||||
else
|
||||
echo Skipping configure process.
|
||||
fi
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
AC_INIT(configure.in)
|
||||
AM_INIT_AUTOMAKE(moeo, 0.1)
|
||||
|
||||
AC_ISC_POSIX
|
||||
AC_PROG_CXX
|
||||
AM_PROG_CC_STDC
|
||||
AC_HEADER_STDC
|
||||
AC_PROG_RANLIB
|
||||
|
||||
AC_PROG_INSTALL
|
||||
AC_PROG_LN_S
|
||||
AC_PROG_MAKE_SET
|
||||
|
||||
AC_C_CONST
|
||||
AC_C_INLINE
|
||||
AC_TYPE_SIZE_T
|
||||
|
||||
AC_SUBST(EO_DIR)
|
||||
|
||||
dnl EO
|
||||
AC_ARG_WITH(EOdir,
|
||||
--with-EOdir : Giving the path of the EO tree.,
|
||||
EO_DIR="$withval"
|
||||
if test ! -d $EO_DIR
|
||||
then
|
||||
echo ""
|
||||
echo "# --with-EOdir Invalid directory $withval"
|
||||
exit 1
|
||||
fi,
|
||||
echo ""
|
||||
echo "# You forgot to give the path of the EO tree !"
|
||||
echo "# Please write something like ... './configure --with-EOdir=\$HOME/eo'"
|
||||
exit 1
|
||||
)
|
||||
|
||||
AC_OUTPUT([
|
||||
Makefile
|
||||
src/Makefile
|
||||
src/core/Makefile
|
||||
doc/Makefile
|
||||
tutorial/Makefile
|
||||
tutorial/Lesson1/Makefile
|
||||
tutorial/Lesson1/flowshop/Makefile
|
||||
tutorial/Lesson2/Makefile
|
||||
])
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
doc:
|
||||
-@doxygen moeo.doxyfile
|
||||
|
||||
clean-local:
|
||||
rm -rf html latex man
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
/** @mainpage Welcome to ParadisEO-MOEO
|
||||
|
||||
@section intro Introduction
|
||||
|
||||
ParadisEO-MOEO is a white-box object-oriented generic framework dedicated to the flexible design of evolutionary multi-objective algorithms.
|
||||
This paradigm-free software embeds some features and techniques for Pareto-based resolution and
|
||||
aims to provide a set of classes allowing to ease and speed up the development of computationally efficient programs.
|
||||
It is based on a clear conceptual distinction between the solution methods and the multi-objective problems they are intended to solve.
|
||||
This separation confers a maximum design and code reuse.
|
||||
ParadisEO-MOEO provides a broad range of archive-related features (such as elitism or performance metrics)
|
||||
and the most common Pareto-based fitness assignment strategies (MOGA, NSGA, SPEA, IBEA and more).
|
||||
Furthermore, parallel and distributed models as well as hybridization mechanisms can be applied to an algorithm designed within ParadisEO-MOEO
|
||||
using the whole version of ParadisEO.
|
||||
|
||||
|
||||
|
||||
@section tutorials Tutorials
|
||||
|
||||
Tutorials for ParadisEO-MOEO are available <a href="http://paradiseo.gforge.inria.fr/index.php?n=Paradiseo.UsersGuides">here</a>.
|
||||
|
||||
|
||||
|
||||
@section install Installation
|
||||
|
||||
The installation procedure of the package is detailed in the <a
|
||||
href="../../README">README</a> file in the top-directory of the source-tree.
|
||||
|
||||
|
||||
|
||||
@section design Overall Design
|
||||
|
||||
For an introduction to the design of ParadisEO-MOEO,
|
||||
you can look at the <a href="http://paradiseo.gforge.inria.fr">ParadisEO website</a>.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/** @page webpages Related webpages
|
||||
|
||||
- ParadisEO <a href="http://paradiseo.gforge.inria.fr">homepage</a>
|
||||
- INRIA GForge <a href="http://gforge.inria.fr/projects/paradiseo/">project page</a>
|
||||
- <a href="../../README">README</a>
|
||||
- <a href="../../NEWS">NEWS</a>
|
||||
*/
|
||||
|
|
@ -1,237 +0,0 @@
|
|||
# Doxyfile 1.5.1
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
# Project related configuration options
|
||||
#---------------------------------------------------------------------------
|
||||
PROJECT_NAME = ParadisEO-MOEO
|
||||
PROJECT_NUMBER = 1.0
|
||||
OUTPUT_DIRECTORY =
|
||||
CREATE_SUBDIRS = NO
|
||||
OUTPUT_LANGUAGE = English
|
||||
USE_WINDOWS_ENCODING = NO
|
||||
BRIEF_MEMBER_DESC = YES
|
||||
REPEAT_BRIEF = YES
|
||||
ABBREVIATE_BRIEF = "The $name class" \
|
||||
"The $name widget" \
|
||||
"The $name file" \
|
||||
is \
|
||||
provides \
|
||||
specifies \
|
||||
contains \
|
||||
represents \
|
||||
a \
|
||||
an \
|
||||
the
|
||||
ALWAYS_DETAILED_SEC = NO
|
||||
INLINE_INHERITED_MEMB = NO
|
||||
FULL_PATH_NAMES = NO
|
||||
STRIP_FROM_PATH =
|
||||
STRIP_FROM_INC_PATH =
|
||||
SHORT_NAMES = NO
|
||||
JAVADOC_AUTOBRIEF = YES
|
||||
MULTILINE_CPP_IS_BRIEF = NO
|
||||
DETAILS_AT_TOP = NO
|
||||
INHERIT_DOCS = YES
|
||||
SEPARATE_MEMBER_PAGES = NO
|
||||
TAB_SIZE = 8
|
||||
ALIASES =
|
||||
OPTIMIZE_OUTPUT_FOR_C = NO
|
||||
OPTIMIZE_OUTPUT_JAVA = NO
|
||||
BUILTIN_STL_SUPPORT = NO
|
||||
DISTRIBUTE_GROUP_DOC = NO
|
||||
SUBGROUPING = YES
|
||||
#---------------------------------------------------------------------------
|
||||
# Build related configuration options
|
||||
#---------------------------------------------------------------------------
|
||||
EXTRACT_ALL = NO
|
||||
EXTRACT_PRIVATE = YES
|
||||
EXTRACT_STATIC = YES
|
||||
EXTRACT_LOCAL_CLASSES = YES
|
||||
EXTRACT_LOCAL_METHODS = NO
|
||||
HIDE_UNDOC_MEMBERS = YES
|
||||
HIDE_UNDOC_CLASSES = YES
|
||||
HIDE_FRIEND_COMPOUNDS = NO
|
||||
HIDE_IN_BODY_DOCS = NO
|
||||
INTERNAL_DOCS = NO
|
||||
CASE_SENSE_NAMES = YES
|
||||
HIDE_SCOPE_NAMES = NO
|
||||
SHOW_INCLUDE_FILES = YES
|
||||
INLINE_INFO = YES
|
||||
SORT_MEMBER_DOCS = NO
|
||||
SORT_BRIEF_DOCS = NO
|
||||
SORT_BY_SCOPE_NAME = NO
|
||||
GENERATE_TODOLIST = YES
|
||||
GENERATE_TESTLIST = YES
|
||||
GENERATE_BUGLIST = YES
|
||||
GENERATE_DEPRECATEDLIST= YES
|
||||
ENABLED_SECTIONS =
|
||||
MAX_INITIALIZER_LINES = 30
|
||||
SHOW_USED_FILES = YES
|
||||
SHOW_DIRECTORIES = NO
|
||||
FILE_VERSION_FILTER =
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to warning and progress messages
|
||||
#---------------------------------------------------------------------------
|
||||
QUIET = YES
|
||||
WARNINGS = YES
|
||||
WARN_IF_UNDOCUMENTED = YES
|
||||
WARN_IF_DOC_ERROR = YES
|
||||
WARN_NO_PARAMDOC = NO
|
||||
WARN_FORMAT = "$file:$line: $text"
|
||||
WARN_LOGFILE =
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the input files
|
||||
#---------------------------------------------------------------------------
|
||||
INPUT = . ../src
|
||||
FILE_PATTERNS = *.cpp \
|
||||
*.h \
|
||||
NEWS README
|
||||
RECURSIVE = YES
|
||||
EXCLUDE =
|
||||
EXCLUDE_SYMLINKS = NO
|
||||
EXCLUDE_PATTERNS =
|
||||
EXAMPLE_PATH =
|
||||
EXAMPLE_PATTERNS = *
|
||||
EXAMPLE_RECURSIVE = NO
|
||||
IMAGE_PATH =
|
||||
INPUT_FILTER =
|
||||
FILTER_PATTERNS =
|
||||
FILTER_SOURCE_FILES = NO
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to source browsing
|
||||
#---------------------------------------------------------------------------
|
||||
SOURCE_BROWSER = YES
|
||||
INLINE_SOURCES = NO
|
||||
STRIP_CODE_COMMENTS = YES
|
||||
REFERENCED_BY_RELATION = YES
|
||||
REFERENCES_RELATION = YES
|
||||
REFERENCES_LINK_SOURCE = YES
|
||||
USE_HTAGS = NO
|
||||
VERBATIM_HEADERS = YES
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the alphabetical class index
|
||||
#---------------------------------------------------------------------------
|
||||
ALPHABETICAL_INDEX = YES
|
||||
COLS_IN_ALPHA_INDEX = 3
|
||||
IGNORE_PREFIX = moeo
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the HTML output
|
||||
#---------------------------------------------------------------------------
|
||||
GENERATE_HTML = YES
|
||||
HTML_OUTPUT = html
|
||||
HTML_FILE_EXTENSION = .html
|
||||
HTML_HEADER =
|
||||
HTML_FOOTER =
|
||||
HTML_STYLESHEET =
|
||||
HTML_ALIGN_MEMBERS = YES
|
||||
GENERATE_HTMLHELP = NO
|
||||
CHM_FILE =
|
||||
HHC_LOCATION =
|
||||
GENERATE_CHI = NO
|
||||
BINARY_TOC = NO
|
||||
TOC_EXPAND = NO
|
||||
DISABLE_INDEX = NO
|
||||
ENUM_VALUES_PER_LINE = 4
|
||||
GENERATE_TREEVIEW = YES
|
||||
TREEVIEW_WIDTH = 250
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the LaTeX output
|
||||
#---------------------------------------------------------------------------
|
||||
GENERATE_LATEX = YES
|
||||
LATEX_OUTPUT = latex
|
||||
LATEX_CMD_NAME = latex
|
||||
MAKEINDEX_CMD_NAME = makeindex
|
||||
COMPACT_LATEX = NO
|
||||
PAPER_TYPE = a4wide
|
||||
EXTRA_PACKAGES =
|
||||
LATEX_HEADER =
|
||||
PDF_HYPERLINKS = NO
|
||||
USE_PDFLATEX = NO
|
||||
LATEX_BATCHMODE = NO
|
||||
LATEX_HIDE_INDICES = NO
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the RTF output
|
||||
#---------------------------------------------------------------------------
|
||||
GENERATE_RTF = NO
|
||||
RTF_OUTPUT = rtf
|
||||
COMPACT_RTF = NO
|
||||
RTF_HYPERLINKS = NO
|
||||
RTF_STYLESHEET_FILE =
|
||||
RTF_EXTENSIONS_FILE =
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the man page output
|
||||
#---------------------------------------------------------------------------
|
||||
GENERATE_MAN = YES
|
||||
MAN_OUTPUT = man
|
||||
MAN_EXTENSION = .3
|
||||
MAN_LINKS = NO
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the XML output
|
||||
#---------------------------------------------------------------------------
|
||||
GENERATE_XML = NO
|
||||
XML_OUTPUT = xml
|
||||
XML_SCHEMA =
|
||||
XML_DTD =
|
||||
XML_PROGRAMLISTING = YES
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options for the AutoGen Definitions output
|
||||
#---------------------------------------------------------------------------
|
||||
GENERATE_AUTOGEN_DEF = NO
|
||||
#---------------------------------------------------------------------------
|
||||
# configuration options related to the Perl module output
|
||||
#---------------------------------------------------------------------------
|
||||
GENERATE_PERLMOD = NO
|
||||
PERLMOD_LATEX = NO
|
||||
PERLMOD_PRETTY = YES
|
||||
PERLMOD_MAKEVAR_PREFIX =
|
||||
#---------------------------------------------------------------------------
|
||||
# Configuration options related to the preprocessor
|
||||
#---------------------------------------------------------------------------
|
||||
ENABLE_PREPROCESSING = YES
|
||||
MACRO_EXPANSION = NO
|
||||
EXPAND_ONLY_PREDEF = NO
|
||||
SEARCH_INCLUDES = YES
|
||||
INCLUDE_PATH =
|
||||
INCLUDE_FILE_PATTERNS =
|
||||
PREDEFINED =
|
||||
EXPAND_AS_DEFINED =
|
||||
SKIP_FUNCTION_MACROS = YES
|
||||
#---------------------------------------------------------------------------
|
||||
# Configuration::additions related to external references
|
||||
#---------------------------------------------------------------------------
|
||||
TAGFILES = ../../paradiseo-eo/doc/eo.doxytag=../../../paradiseo-eo/doc/html
|
||||
GENERATE_TAGFILE = moeo.doxytag
|
||||
ALLEXTERNALS = NO
|
||||
EXTERNAL_GROUPS = YES
|
||||
PERL_PATH = /usr/bin/perl
|
||||
#---------------------------------------------------------------------------
|
||||
# Configuration options related to the dot tool
|
||||
#---------------------------------------------------------------------------
|
||||
CLASS_DIAGRAMS = YES
|
||||
HIDE_UNDOC_RELATIONS = YES
|
||||
HAVE_DOT = NO
|
||||
CLASS_GRAPH = YES
|
||||
COLLABORATION_GRAPH = YES
|
||||
GROUP_GRAPHS = YES
|
||||
UML_LOOK = NO
|
||||
TEMPLATE_RELATIONS = NO
|
||||
INCLUDE_GRAPH = YES
|
||||
INCLUDED_BY_GRAPH = YES
|
||||
CALL_GRAPH = NO
|
||||
CALLER_GRAPH = NO
|
||||
GRAPHICAL_HIERARCHY = YES
|
||||
DIRECTORY_GRAPH = YES
|
||||
DOT_IMAGE_FORMAT = png
|
||||
DOT_PATH =
|
||||
DOTFILE_DIRS =
|
||||
MAX_DOT_GRAPH_WIDTH = 1024
|
||||
MAX_DOT_GRAPH_HEIGHT = 1024
|
||||
MAX_DOT_GRAPH_DEPTH = 0
|
||||
DOT_TRANSPARENT = NO
|
||||
DOT_MULTI_TARGETS = NO
|
||||
GENERATE_LEGEND = YES
|
||||
DOT_CLEANUP = YES
|
||||
#---------------------------------------------------------------------------
|
||||
# Configuration::additions related to the search engine
|
||||
#---------------------------------------------------------------------------
|
||||
SEARCHENGINE = YES
|
||||
|
|
@ -1 +0,0 @@
|
|||
SUBDIRS = core
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoAlgo.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOALGO_H_
|
||||
#define MOEOALGO_H_
|
||||
|
||||
/**
|
||||
* Abstract class for multi-objective algorithms.
|
||||
*/
|
||||
class moeoAlgo {};
|
||||
|
||||
#endif /*MOEOALGO_H_*/
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoCombinedLS.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOCOMBINEDLS_H_
|
||||
#define MOEOCOMBINEDLS_H_
|
||||
|
||||
#include <vector>
|
||||
#include <algo/moeoLS.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
|
||||
/**
|
||||
* This class allows to embed a set of local searches that are sequentially applied,
|
||||
* and so working and updating the same archive of non-dominated solutions.
|
||||
*/
|
||||
template < class MOEOT, class Type >
|
||||
class moeoCombinedLS : public moeoLS < MOEOT, Type >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _first_mols the first multi-objective local search to add
|
||||
*/
|
||||
moeoCombinedLS(moeoLS < MOEOT, Type > & _first_mols)
|
||||
{
|
||||
combinedLS.push_back (& _first_mols);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a new local search to combine
|
||||
* @param _mols the multi-objective local search to add
|
||||
*/
|
||||
void add(moeoLS < MOEOT, Type > & _mols)
|
||||
{
|
||||
combinedLS.push_back(& _mols);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gives a new solution in order to explore the neigborhood.
|
||||
* The new non-dominated solutions are added to the archive
|
||||
* @param _type the object to apply the local search to
|
||||
* @param _arch the archive of non-dominated solutions
|
||||
*/
|
||||
void operator () (Type _type, moeoArchive < MOEOT > & _arch)
|
||||
{
|
||||
for (unsigned int i=0; i<combinedLS.size(); i++)
|
||||
combinedLS[i] -> operator()(_type, _arch);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the vector that contains the combined LS */
|
||||
std::vector< moeoLS < MOEOT, Type > * > combinedLS;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOCOMBINEDLS_H_*/
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoEA.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOEA_H_
|
||||
#define MOEOEA_H_
|
||||
|
||||
#include <eoAlgo.h>
|
||||
#include <algo/moeoAlgo.h>
|
||||
|
||||
/**
|
||||
* Abstract class for multi-objective evolutionary algorithms.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoEA : public moeoAlgo, public eoAlgo < MOEOT > {};
|
||||
|
||||
#endif /*MOEOEA_H_*/
|
||||
|
|
@ -1,218 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoEasyEA.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef _MOEOEASYEA_H
|
||||
#define _MOEOEASYEA_H
|
||||
|
||||
#include <apply.h>
|
||||
#include <eoBreed.h>
|
||||
#include <eoContinue.h>
|
||||
#include <eoMergeReduce.h>
|
||||
#include <eoPopEvalFunc.h>
|
||||
#include <eoSelect.h>
|
||||
#include <eoTransform.h>
|
||||
#include <algo/moeoEA.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
#include <diversity/moeoDummyDiversityAssignment.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <replacement/moeoReplacement.h>
|
||||
|
||||
/**
|
||||
* An easy class to design multi-objective evolutionary algorithms.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoEasyEA: public moeoEA < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor taking a breed and merge.
|
||||
* @param _continuator the stopping criteria
|
||||
* @param _eval the evaluation functions
|
||||
* @param _breed the breeder
|
||||
* @param _replace the replacement strategy
|
||||
* @param _fitnessEval the fitness evaluation scheme
|
||||
* @param _diversityEval the diversity evaluation scheme
|
||||
* @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process
|
||||
*/
|
||||
moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoBreed < MOEOT > & _breed, moeoReplacement < MOEOT > & _replace,
|
||||
moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false)
|
||||
:
|
||||
continuator(_continuator), eval (_eval), loopEval(_eval), popEval(loopEval), selectTransform(dummySelect, dummyTransform), breed(_breed), mergeReduce(dummyMerge, dummyReduce), replace(_replace),
|
||||
fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor taking a breed, a merge and a eoPopEval.
|
||||
* @param _continuator the stopping criteria
|
||||
* @param _popEval the evaluation functions for the whole population
|
||||
* @param _breed the breeder
|
||||
* @param _replace the replacement strategy
|
||||
* @param _fitnessEval the fitness evaluation scheme
|
||||
* @param _diversityEval the diversity evaluation scheme
|
||||
* @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process
|
||||
*/
|
||||
moeoEasyEA(eoContinue < MOEOT > & _continuator, eoPopEvalFunc < MOEOT > & _popEval, eoBreed < MOEOT > & _breed, moeoReplacement < MOEOT > & _replace,
|
||||
moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false)
|
||||
:
|
||||
continuator(_continuator), eval (dummyEval), loopEval(dummyEval), popEval(_popEval), selectTransform(dummySelect, dummyTransform), breed(_breed), mergeReduce(dummyMerge, dummyReduce), replace(_replace),
|
||||
fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor taking a breed, a merge and a reduce.
|
||||
* @param _continuator the stopping criteria
|
||||
* @param _eval the evaluation functions
|
||||
* @param _breed the breeder
|
||||
* @param _merge the merge scheme
|
||||
* @param _reduce the reduce scheme
|
||||
* @param _fitnessEval the fitness evaluation scheme
|
||||
* @param _diversityEval the diversity evaluation scheme
|
||||
* @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process
|
||||
*/
|
||||
moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoBreed < MOEOT > & _breed, eoMerge < MOEOT > & _merge, eoReduce< MOEOT > & _reduce,
|
||||
moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false)
|
||||
:
|
||||
continuator(_continuator), eval(_eval), loopEval(_eval), popEval(loopEval), selectTransform(dummySelect, dummyTransform), breed(_breed), mergeReduce(_merge,_reduce), replace(mergeReduce),
|
||||
fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor taking a select, a transform and a replacement.
|
||||
* @param _continuator the stopping criteria
|
||||
* @param _eval the evaluation functions
|
||||
* @param _select the selection scheme
|
||||
* @param _transform the tranformation scheme
|
||||
* @param _replace the replacement strategy
|
||||
* @param _fitnessEval the fitness evaluation scheme
|
||||
* @param _diversityEval the diversity evaluation scheme
|
||||
* @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process
|
||||
*/
|
||||
moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoSelect < MOEOT > & _select, eoTransform < MOEOT > & _transform, moeoReplacement < MOEOT > & _replace,
|
||||
moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false)
|
||||
:
|
||||
continuator(_continuator), eval(_eval), loopEval(_eval), popEval(loopEval), selectTransform(_select, _transform), breed(selectTransform), mergeReduce(dummyMerge, dummyReduce), replace(_replace),
|
||||
fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor taking a select, a transform, a merge and a reduce.
|
||||
* @param _continuator the stopping criteria
|
||||
* @param _eval the evaluation functions
|
||||
* @param _select the selection scheme
|
||||
* @param _transform the tranformation scheme
|
||||
* @param _merge the merge scheme
|
||||
* @param _reduce the reduce scheme
|
||||
* @param _fitnessEval the fitness evaluation scheme
|
||||
* @param _diversityEval the diversity evaluation scheme
|
||||
* @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process
|
||||
*/
|
||||
moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoSelect < MOEOT > & _select, eoTransform < MOEOT > & _transform, eoMerge < MOEOT > & _merge, eoReduce< MOEOT > & _reduce,
|
||||
moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false)
|
||||
:
|
||||
continuator(_continuator), eval(_eval), loopEval(_eval), popEval(loopEval), selectTransform(_select, _transform), breed(selectTransform), mergeReduce(_merge,_reduce), replace(mergeReduce),
|
||||
fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Applies a few generation of evolution to the population _pop.
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void operator()(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
eoPop < MOEOT > offspring, empty_pop;
|
||||
popEval(empty_pop, _pop); // A first eval of pop.
|
||||
bool firstTime = true;
|
||||
do
|
||||
{
|
||||
try
|
||||
{
|
||||
unsigned int pSize = _pop.size();
|
||||
offspring.clear(); // new offspring
|
||||
// fitness and diversity assignment (if you want to or if it is the first generation)
|
||||
if (evalFitAndDivBeforeSelection || firstTime)
|
||||
{
|
||||
firstTime = false;
|
||||
fitnessEval(_pop);
|
||||
diversityEval(_pop);
|
||||
}
|
||||
breed(_pop, offspring);
|
||||
popEval(_pop, offspring); // eval of parents + offspring if necessary
|
||||
replace(_pop, offspring); // after replace, the new pop. is in _pop
|
||||
if (pSize > _pop.size())
|
||||
{
|
||||
throw std::runtime_error("Population shrinking!");
|
||||
}
|
||||
else if (pSize < _pop.size())
|
||||
{
|
||||
throw std::runtime_error("Population growing!");
|
||||
}
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
std::string s = e.what();
|
||||
s.append( " in moeoEasyEA");
|
||||
throw std::runtime_error( s );
|
||||
}
|
||||
} while (continuator(_pop));
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the stopping criteria */
|
||||
eoContinue < MOEOT > & continuator;
|
||||
/** the evaluation functions */
|
||||
eoEvalFunc < MOEOT > & eval;
|
||||
/** to evaluate the whole population */
|
||||
eoPopLoopEval < MOEOT > loopEval;
|
||||
/** to evaluate the whole population */
|
||||
eoPopEvalFunc < MOEOT > & popEval;
|
||||
/** breed: a select followed by a transform */
|
||||
eoSelectTransform < MOEOT > selectTransform;
|
||||
/** the breeder */
|
||||
eoBreed < MOEOT > & breed;
|
||||
/** replacement: a merge followed by a reduce */
|
||||
eoMergeReduce < MOEOT > mergeReduce;
|
||||
/** the replacment strategy */
|
||||
moeoReplacement < MOEOT > & replace;
|
||||
/** the fitness assignment strategy */
|
||||
moeoFitnessAssignment < MOEOT > & fitnessEval;
|
||||
/** the diversity assignment strategy */
|
||||
moeoDiversityAssignment < MOEOT > & diversityEval;
|
||||
/** if this parameter is set to 'true', the fitness and the diversity of the whole population will be re-evaluated before the selection process */
|
||||
bool evalFitAndDivBeforeSelection;
|
||||
/** a dummy eval */
|
||||
class eoDummyEval : public eoEvalFunc < MOEOT >
|
||||
{ public: /** the dummy functor */
|
||||
void operator()(MOEOT &) {}} dummyEval;
|
||||
/** a dummy select */
|
||||
class eoDummySelect : public eoSelect < MOEOT >
|
||||
{ public: /** the dummy functor */
|
||||
void operator()(const eoPop < MOEOT > &, eoPop < MOEOT > &) {} } dummySelect;
|
||||
/** a dummy transform */
|
||||
class eoDummyTransform : public eoTransform < MOEOT >
|
||||
{ public: /** the dummy functor */
|
||||
void operator()(eoPop < MOEOT > &) {} } dummyTransform;
|
||||
/** a dummy merge */
|
||||
eoNoElitism < MOEOT > dummyMerge;
|
||||
/** a dummy reduce */
|
||||
eoTruncate < MOEOT > dummyReduce;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOEASYEA_H_*/
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoHybridLS.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOHYBRIDLS_H_
|
||||
#define MOEOHYBRIDLS_H_
|
||||
|
||||
#include <eoContinue.h>
|
||||
#include <eoPop.h>
|
||||
#include <eoSelect.h>
|
||||
#include <utils/eoUpdater.h>
|
||||
#include <algo/moeoLS.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
|
||||
/**
|
||||
* This class allows to apply a multi-objective local search to a number of selected individuals contained in the archive
|
||||
* at every generation until a stopping criteria is verified.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoHybridLS : public eoUpdater
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _term stopping criteria
|
||||
* @param _select selector
|
||||
* @param _mols a multi-objective local search
|
||||
* @param _arch the archive
|
||||
*/
|
||||
moeoHybridLS (eoContinue < MOEOT > & _term, eoSelect < MOEOT > & _select, moeoLS < MOEOT, MOEOT > & _mols, moeoArchive < MOEOT > & _arch) :
|
||||
term(_term), select(_select), mols(_mols), arch(_arch)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Applies the multi-objective local search to selected individuals contained in the archive if the stopping criteria is not verified
|
||||
*/
|
||||
void operator () ()
|
||||
{
|
||||
if (! term (arch))
|
||||
{
|
||||
// selection of solutions
|
||||
eoPop < MOEOT > selectedSolutions;
|
||||
select(arch, selectedSolutions);
|
||||
// apply the local search to every selected solution
|
||||
for (unsigned int i=0; i<selectedSolutions.size(); i++)
|
||||
{
|
||||
mols(selectedSolutions[i], arch);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** stopping criteria */
|
||||
eoContinue < MOEOT > & term;
|
||||
/** selector */
|
||||
eoSelect < MOEOT > & select;
|
||||
/** multi-objective local search */
|
||||
moeoLS < MOEOT, MOEOT > & mols;
|
||||
/** archive */
|
||||
moeoArchive < MOEOT > & arch;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOHYBRIDLS_H_*/
|
||||
|
|
@ -1,168 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoIBEA.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOIBEA_H_
|
||||
#define MOEOIBEA_H_
|
||||
|
||||
|
||||
#include <eoBreed.h>
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoGenContinue.h>
|
||||
#include <eoGeneralBreeder.h>
|
||||
#include <eoGenOp.h>
|
||||
#include <eoPopEvalFunc.h>
|
||||
#include <eoSGAGenOp.h>
|
||||
#include <algo/moeoEA.h>
|
||||
#include <diversity/moeoDummyDiversityAssignment.h>
|
||||
#include <fitness/moeoIndicatorBasedFitnessAssignment.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
#include <replacement/moeoEnvironmentalReplacement.h>
|
||||
#include <selection/moeoDetTournamentSelect.h>
|
||||
|
||||
/**
|
||||
* IBEA (Indicator-Based Evolutionary Algorithm) as described in:
|
||||
* E. Zitzler, S. Künzli, "Indicator-Based Selection in Multiobjective Search", Proc. 8th International Conference on Parallel Problem Solving from Nature (PPSN VIII), pp. 832-842, Birmingham, UK (2004).
|
||||
* This class builds the IBEA algorithm only by using the fine-grained components of the ParadisEO-MOEO framework.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoIBEA : public moeoEA < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type of objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Simple ctor with a eoGenOp.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _metric metric
|
||||
* @param _kappa scaling factor kappa
|
||||
*/
|
||||
moeoIBEA (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2),
|
||||
fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Simple ctor with a eoTransform.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _metric metric
|
||||
* @param _kappa scaling factor kappa
|
||||
*/
|
||||
moeoIBEA (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2),
|
||||
fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a crossover, a mutation and their corresponding rates.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _crossover crossover
|
||||
* @param _pCross crossover probability
|
||||
* @param _mutation mutation
|
||||
* @param _pMut mutation probability
|
||||
* @param _metric metric
|
||||
* @param _kappa scaling factor kappa
|
||||
*/
|
||||
moeoIBEA (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoQuadOp < MOEOT > & _crossover, double _pCross, eoMonOp < MOEOT > & _mutation, double _pMut, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select (2),
|
||||
fitnessAssignment(_metric, _kappa), replace (fitnessAssignment, dummyDiversityAssignment), defaultSGAGenOp(_crossover, _pCross, _mutation, _pMut),
|
||||
genBreed (select, defaultSGAGenOp), breed (genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a continuator (instead of _maxGen) and a eoGenOp.
|
||||
* @param _continuator stopping criteria
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _metric metric
|
||||
* @param _kappa scaling factor kappa
|
||||
*/
|
||||
moeoIBEA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) :
|
||||
continuator(_continuator), popEval(_eval), select(2),
|
||||
fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a continuator (instead of _maxGen) and a eoTransform.
|
||||
* @param _continuator stopping criteria
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _metric metric
|
||||
* @param _kappa scaling factor kappa
|
||||
*/
|
||||
moeoIBEA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) :
|
||||
continuator(_continuator), popEval(_eval), select(2),
|
||||
fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Apply a few generation of evolution to the population _pop until the stopping criteria is verified.
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void operator () (eoPop < MOEOT > &_pop)
|
||||
{
|
||||
eoPop < MOEOT > offspring, empty_pop;
|
||||
popEval (empty_pop, _pop); // a first eval of _pop
|
||||
// evaluate fitness and diversity
|
||||
fitnessAssignment(_pop);
|
||||
dummyDiversityAssignment(_pop);
|
||||
do
|
||||
{
|
||||
// generate offspring, worths are recalculated if necessary
|
||||
breed (_pop, offspring);
|
||||
// eval of offspring
|
||||
popEval (_pop, offspring);
|
||||
// after replace, the new pop is in _pop. Worths are recalculated if necessary
|
||||
replace (_pop, offspring);
|
||||
} while (continuator (_pop));
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** a continuator based on the number of generations (used as default) */
|
||||
eoGenContinue < MOEOT > defaultGenContinuator;
|
||||
/** stopping criteria */
|
||||
eoContinue < MOEOT > & continuator;
|
||||
/** evaluation function used to evaluate the whole population */
|
||||
eoPopLoopEval < MOEOT > popEval;
|
||||
/** binary tournament selection */
|
||||
moeoDetTournamentSelect < MOEOT > select;
|
||||
/** fitness assignment used in IBEA */
|
||||
moeoIndicatorBasedFitnessAssignment < MOEOT > fitnessAssignment;
|
||||
/** dummy diversity assignment */
|
||||
moeoDummyDiversityAssignment < MOEOT > dummyDiversityAssignment;
|
||||
/** elitist replacement */
|
||||
moeoEnvironmentalReplacement < MOEOT > replace;
|
||||
/** an object for genetic operators (used as default) */
|
||||
eoSGAGenOp < MOEOT > defaultSGAGenOp;
|
||||
/** general breeder */
|
||||
eoGeneralBreeder < MOEOT > genBreed;
|
||||
/** breeder */
|
||||
eoBreed < MOEOT > & breed;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOIBEA_H_*/
|
||||
|
|
@ -1,280 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoIBMOLS.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOIBMOLS_H_
|
||||
#define MOEOIBMOLS_H_
|
||||
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoPop.h>
|
||||
#include <moMove.h>
|
||||
#include <moMoveInit.h>
|
||||
#include <moNextMove.h>
|
||||
#include <algo/moeoLS.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <fitness/moeoIndicatorBasedFitnessAssignment.h>
|
||||
#include <move/moeoMoveIncrEval.h>
|
||||
|
||||
/**
|
||||
* Indicator-Based Multi-Objective Local Search (IBMOLS) as described in
|
||||
* Basseur M., Burke K. : "Indicator-Based Multi-Objective Local Search" (2007).
|
||||
*/
|
||||
template < class MOEOT, class Move >
|
||||
class moeoIBMOLS : public moeoLS < MOEOT, eoPop < MOEOT > & >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type of objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _moveInit the move initializer
|
||||
* @param _nextMove the neighborhood explorer
|
||||
* @param _eval the full evaluation
|
||||
* @param _moveIncrEval the incremental evaluation
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _continuator the stopping criteria
|
||||
*/
|
||||
moeoIBMOLS(
|
||||
moMoveInit < Move > & _moveInit,
|
||||
moNextMove < Move > & _nextMove,
|
||||
eoEvalFunc < MOEOT > & _eval,
|
||||
moeoMoveIncrEval < Move > & _moveIncrEval,
|
||||
moeoIndicatorBasedFitnessAssignment < MOEOT > & _fitnessAssignment,
|
||||
eoContinue < MOEOT > & _continuator
|
||||
) :
|
||||
moveInit(_moveInit),
|
||||
nextMove(_nextMove),
|
||||
eval(_eval),
|
||||
moveIncrEval(_moveIncrEval),
|
||||
fitnessAssignment (_fitnessAssignment),
|
||||
continuator (_continuator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Apply the local search until a local archive does not change or
|
||||
* another stopping criteria is met and update the archive _arch with new non-dominated solutions.
|
||||
* @param _pop the initial population
|
||||
* @param _arch the (updated) archive
|
||||
*/
|
||||
void operator() (eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _arch)
|
||||
{
|
||||
// evaluation of the objective values
|
||||
/*
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
eval(_pop[i]);
|
||||
}
|
||||
*/
|
||||
// fitness assignment for the whole population
|
||||
fitnessAssignment(_pop);
|
||||
// creation of a local archive
|
||||
moeoArchive < MOEOT > archive;
|
||||
// creation of another local archive (for the stopping criteria)
|
||||
moeoArchive < MOEOT > previousArchive;
|
||||
// update the archive with the initial population
|
||||
archive.update(_pop);
|
||||
do
|
||||
{
|
||||
previousArchive.update(archive);
|
||||
oneStep(_pop);
|
||||
archive.update(_pop);
|
||||
} while ( (! archive.equals(previousArchive)) && (continuator(_arch)) );
|
||||
_arch.update(archive);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the move initializer */
|
||||
moMoveInit < Move > & moveInit;
|
||||
/** the neighborhood explorer */
|
||||
moNextMove < Move > & nextMove;
|
||||
/** the full evaluation */
|
||||
eoEvalFunc < MOEOT > & eval;
|
||||
/** the incremental evaluation */
|
||||
moeoMoveIncrEval < Move > & moveIncrEval;
|
||||
/** the fitness assignment strategy */
|
||||
moeoIndicatorBasedFitnessAssignment < MOEOT > & fitnessAssignment;
|
||||
/** the stopping criteria */
|
||||
eoContinue < MOEOT > & continuator;
|
||||
|
||||
|
||||
/**
|
||||
* Apply one step of the local search to the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void oneStep (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
////////////////////////////////////////////
|
||||
int ext_0_idx, ext_1_idx;
|
||||
ObjectiveVector ext_0_objVec, ext_1_objVec;
|
||||
///////////////////////////////////////////
|
||||
// the move
|
||||
Move move;
|
||||
// the objective vector and the fitness of the current solution
|
||||
ObjectiveVector x_objVec;
|
||||
double x_fitness;
|
||||
// the index, the objective vector and the fitness of the worst solution in the population (-1 implies that the worst is the newly created one)
|
||||
int worst_idx;
|
||||
ObjectiveVector worst_objVec;
|
||||
double worst_fitness;
|
||||
// the index current of the current solution to be explored
|
||||
unsigned int i=0;
|
||||
// initilization of the move for the first individual
|
||||
moveInit(move, _pop[i]);
|
||||
while (i<_pop.size() && continuator(_pop))
|
||||
{
|
||||
// x = one neigbour of pop[i]
|
||||
// evaluate x in the objective space
|
||||
x_objVec = moveIncrEval(move, _pop[i]);
|
||||
// update every fitness values to take x into account and compute the fitness of x
|
||||
x_fitness = fitnessAssignment.updateByAdding(_pop, x_objVec);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// qui sont les extremes ? (=> min only !!!)
|
||||
ext_0_idx = -1;
|
||||
ext_0_objVec = x_objVec;
|
||||
ext_1_idx = -1;
|
||||
ext_1_objVec = x_objVec;
|
||||
for (unsigned int k=0; k<_pop.size(); k++)
|
||||
{
|
||||
// ext_0
|
||||
if (_pop[k].objectiveVector()[0] < ext_0_objVec[0])
|
||||
{
|
||||
ext_0_idx = k;
|
||||
ext_0_objVec = _pop[k].objectiveVector();
|
||||
}
|
||||
else if ( (_pop[k].objectiveVector()[0] == ext_0_objVec[0]) && (_pop[k].objectiveVector()[1] < ext_0_objVec[1]) )
|
||||
{
|
||||
ext_0_idx = k;
|
||||
ext_0_objVec = _pop[k].objectiveVector();
|
||||
}
|
||||
// ext_1
|
||||
else if (_pop[k].objectiveVector()[1] < ext_1_objVec[1])
|
||||
{
|
||||
ext_1_idx = k;
|
||||
ext_1_objVec = _pop[k].objectiveVector();
|
||||
}
|
||||
else if ( (_pop[k].objectiveVector()[1] == ext_1_objVec[1]) && (_pop[k].objectiveVector()[0] < ext_1_objVec[0]) )
|
||||
{
|
||||
ext_1_idx = k;
|
||||
ext_1_objVec = _pop[k].objectiveVector();
|
||||
}
|
||||
}
|
||||
// worst init
|
||||
if (ext_0_idx == -1)
|
||||
{
|
||||
unsigned int ind = 0;
|
||||
while (ind == ext_1_idx)
|
||||
{
|
||||
ind++;
|
||||
}
|
||||
worst_idx = ind;
|
||||
worst_objVec = _pop[ind].objectiveVector();
|
||||
worst_fitness = _pop[ind].fitness();
|
||||
}
|
||||
else if (ext_1_idx == -1)
|
||||
{
|
||||
unsigned int ind = 0;
|
||||
while (ind == ext_0_idx)
|
||||
{
|
||||
ind++;
|
||||
}
|
||||
worst_idx = ind;
|
||||
worst_objVec = _pop[ind].objectiveVector();
|
||||
worst_fitness = _pop[ind].fitness();
|
||||
}
|
||||
else
|
||||
{
|
||||
worst_idx = -1;
|
||||
worst_objVec = x_objVec;
|
||||
worst_fitness = x_fitness;
|
||||
}
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// who is the worst ?
|
||||
for (unsigned int j=0; j<_pop.size(); j++)
|
||||
{
|
||||
if ( (j!=ext_0_idx) && (j!=ext_1_idx) )
|
||||
{
|
||||
if (_pop[j].fitness() < worst_fitness)
|
||||
{
|
||||
worst_idx = j;
|
||||
worst_objVec = _pop[j].objectiveVector();
|
||||
worst_fitness = _pop[j].fitness();
|
||||
}
|
||||
}
|
||||
}
|
||||
// if the worst solution is the new one
|
||||
if (worst_idx == -1)
|
||||
{
|
||||
// if all its neighbours have been explored,
|
||||
// let's explore the neighborhoud of the next individual
|
||||
if (! nextMove(move, _pop[i]))
|
||||
{
|
||||
i++;
|
||||
if (i<_pop.size())
|
||||
{
|
||||
// initilization of the move for the next individual
|
||||
moveInit(move, _pop[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
// if the worst solution is located before _pop[i]
|
||||
else if (worst_idx <= i)
|
||||
{
|
||||
// the new solution takes place insteed of _pop[worst_idx]
|
||||
_pop[worst_idx] = _pop[i];
|
||||
move(_pop[worst_idx]);
|
||||
_pop[worst_idx].objectiveVector(x_objVec);
|
||||
_pop[worst_idx].fitness(x_fitness);
|
||||
// let's explore the neighborhoud of the next individual
|
||||
i++;
|
||||
if (i<_pop.size())
|
||||
{
|
||||
// initilization of the move for the next individual
|
||||
moveInit(move, _pop[i]);
|
||||
}
|
||||
}
|
||||
// if the worst solution is located after _pop[i]
|
||||
else if (worst_idx > i)
|
||||
{
|
||||
// the new solution takes place insteed of _pop[i+1] and _pop[worst_idx] is deleted
|
||||
_pop[worst_idx] = _pop[i+1];
|
||||
_pop[i+1] = _pop[i];
|
||||
move(_pop[i+1]);
|
||||
_pop[i+1].objectiveVector(x_objVec);
|
||||
_pop[i+1].fitness(x_fitness);
|
||||
// let's explore the neighborhoud of the individual _pop[i+2]
|
||||
i += 2;
|
||||
if (i<_pop.size())
|
||||
{
|
||||
// initilization of the move for the next individual
|
||||
moveInit(move, _pop[i]);
|
||||
}
|
||||
}
|
||||
// update fitness values
|
||||
fitnessAssignment.updateByDeleting(_pop, worst_objVec);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOIBMOLS_H_*/
|
||||
|
|
@ -1,215 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoIteratedIBMOLS.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOITERATEDIBMOLS_H_
|
||||
#define MOEOITERATEDIBMOLS_H_
|
||||
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoOp.h>
|
||||
#include <eoPop.h>
|
||||
#include <utils/rnd_generators.h>
|
||||
#include <moMove.h>
|
||||
#include <moMoveInit.h>
|
||||
#include <moNextMove.h>
|
||||
#include <algo/moeoIBMOLS.h>
|
||||
#include <algo/moeoLS.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <fitness/moeoIndicatorBasedFitnessAssignment.h>
|
||||
#include <move/moeoMoveIncrEval.h>
|
||||
|
||||
|
||||
|
||||
//#include <rsCrossQuad.h>
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Iterated version of IBMOLS as described in
|
||||
* Basseur M., Burke K. : "Indicator-Based Multi-Objective Local Search" (2007).
|
||||
*/
|
||||
template < class MOEOT, class Move >
|
||||
class moeoIteratedIBMOLS : public moeoLS < MOEOT, eoPop < MOEOT > & >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type of objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _moveInit the move initializer
|
||||
* @param _nextMove the neighborhood explorer
|
||||
* @param _eval the full evaluation
|
||||
* @param _moveIncrEval the incremental evaluation
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _continuator the stopping criteria
|
||||
* @param _monOp the monary operator
|
||||
* @param _randomMonOp the random monary operator (or random initializer)
|
||||
* @param _nNoiseIterations the number of iterations to apply the random noise
|
||||
*/
|
||||
moeoIteratedIBMOLS(
|
||||
moMoveInit < Move > & _moveInit,
|
||||
moNextMove < Move > & _nextMove,
|
||||
eoEvalFunc < MOEOT > & _eval,
|
||||
moeoMoveIncrEval < Move > & _moveIncrEval,
|
||||
moeoIndicatorBasedFitnessAssignment < MOEOT > & _fitnessAssignment,
|
||||
eoContinue < MOEOT > & _continuator,
|
||||
eoMonOp < MOEOT > & _monOp,
|
||||
eoMonOp < MOEOT > & _randomMonOp,
|
||||
unsigned int _nNoiseIterations=1
|
||||
) :
|
||||
ibmols(_moveInit, _nextMove, _eval, _moveIncrEval, _fitnessAssignment, _continuator),
|
||||
eval(_eval),
|
||||
continuator(_continuator),
|
||||
monOp(_monOp),
|
||||
randomMonOp(_randomMonOp),
|
||||
nNoiseIterations(_nNoiseIterations)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Apply the local search iteratively until the stopping criteria is met.
|
||||
* @param _pop the initial population
|
||||
* @param _arch the (updated) archive
|
||||
*/
|
||||
void operator() (eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _arch)
|
||||
{
|
||||
_arch.update(_pop);
|
||||
ibmols(_pop, _arch);
|
||||
while (continuator(_arch))
|
||||
{
|
||||
// generate new solutions from the archive
|
||||
generateNewSolutions(_pop, _arch);
|
||||
// apply the local search (the global archive is updated in the sub-function)
|
||||
ibmols(_pop, _arch);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the local search to iterate */
|
||||
moeoIBMOLS < MOEOT, Move > ibmols;
|
||||
/** the full evaluation */
|
||||
eoEvalFunc < MOEOT > & eval;
|
||||
/** the stopping criteria */
|
||||
eoContinue < MOEOT > & continuator;
|
||||
/** the monary operator */
|
||||
eoMonOp < MOEOT > & monOp;
|
||||
/** the random monary operator (or random initializer) */
|
||||
eoMonOp < MOEOT > & randomMonOp;
|
||||
/** the number of iterations to apply the random noise */
|
||||
unsigned int nNoiseIterations;
|
||||
|
||||
|
||||
/**
|
||||
* Creates new population randomly initialized and/or initialized from the archive _arch.
|
||||
* @param _pop the output population
|
||||
* @param _arch the archive
|
||||
*/
|
||||
void generateNewSolutions(eoPop < MOEOT > & _pop, const moeoArchive < MOEOT > & _arch)
|
||||
{
|
||||
// shuffle vector for the random selection of individuals
|
||||
vector<unsigned int> shuffle;
|
||||
shuffle.resize(std::max(_pop.size(), _arch.size()));
|
||||
// init shuffle
|
||||
for (unsigned int i=0; i<shuffle.size(); i++)
|
||||
{
|
||||
shuffle[i] = i;
|
||||
}
|
||||
// randomize shuffle
|
||||
UF_random_generator <unsigned int int> gen;
|
||||
std::random_shuffle(shuffle.begin(), shuffle.end(), gen);
|
||||
// start the creation of new solutions
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
if (shuffle[i] < _arch.size())
|
||||
// the given archive contains the individual i
|
||||
{
|
||||
// add it to the resulting pop
|
||||
_pop[i] = _arch[shuffle[i]];
|
||||
// then, apply the operator nIterationsNoise times
|
||||
for (unsigned int j=0; j<nNoiseIterations; j++)
|
||||
{
|
||||
monOp(_pop[i]);
|
||||
}
|
||||
}
|
||||
else
|
||||
// a randomly generated solution needs to be added
|
||||
{
|
||||
// random initialization
|
||||
randomMonOp(_pop[i]);
|
||||
}
|
||||
// evaluation of the new individual
|
||||
_pop[i].invalidate();
|
||||
eval(_pop[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// A DEVELOPPER RAPIDEMENT POUR TESTER AVEC CROSSOVER //
|
||||
/*
|
||||
void generateNewSolutions2(eoPop < MOEOT > & _pop, const moeoArchive < MOEOT > & _arch)
|
||||
{
|
||||
// here, we must have a QuadOp !
|
||||
//eoQuadOp < MOEOT > quadOp;
|
||||
rsCrossQuad quadOp;
|
||||
// shuffle vector for the random selection of individuals
|
||||
vector<unsigned int> shuffle;
|
||||
shuffle.resize(_arch.size());
|
||||
// init shuffle
|
||||
for (unsigned int i=0; i<shuffle.size(); i++)
|
||||
{
|
||||
shuffle[i] = i;
|
||||
}
|
||||
// randomize shuffle
|
||||
UF_random_generator <unsigned int int> gen;
|
||||
std::random_shuffle(shuffle.begin(), shuffle.end(), gen);
|
||||
// start the creation of new solutions
|
||||
unsigned int i=0;
|
||||
while ((i<_pop.size()-1) && (i<_arch.size()-1))
|
||||
{
|
||||
_pop[i] = _arch[shuffle[i]];
|
||||
_pop[i+1] = _arch[shuffle[i+1]];
|
||||
// then, apply the operator nIterationsNoise times
|
||||
for (unsigned int j=0; j<nNoiseIterations; j++)
|
||||
{
|
||||
quadOp(_pop[i], _pop[i+1]);
|
||||
}
|
||||
eval(_pop[i]);
|
||||
eval(_pop[i+1]);
|
||||
i=i+2;
|
||||
}
|
||||
// do we have to add some random solutions ?
|
||||
while (i<_pop.size())
|
||||
{
|
||||
randomMonOp(_pop[i]);
|
||||
eval(_pop[i]);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOITERATEDIBMOLS_H_*/
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoLS.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOLS_H_
|
||||
#define MOEOLS_H_
|
||||
|
||||
#include <eoFunctor.h>
|
||||
#include <algo/moeoAlgo.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
|
||||
/**
|
||||
* Abstract class for local searches applied to multi-objective optimization.
|
||||
* Starting from a Type (i.e.: an individual, a pop, an archive...), it produces a set of new non-dominated solutions.
|
||||
*/
|
||||
template < class MOEOT, class Type >
|
||||
class moeoLS: public moeoAlgo, public eoBF < Type, moeoArchive < MOEOT > &, void > {};
|
||||
|
||||
#endif /*MOEOLS_H_*/
|
||||
|
|
@ -1,158 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoNSGA.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEONSGA_H_
|
||||
#define MOEONSGA_H_
|
||||
|
||||
#include <eoBreed.h>
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoGenContinue.h>
|
||||
#include <eoGeneralBreeder.h>
|
||||
#include <eoGenOp.h>
|
||||
#include <eoPopEvalFunc.h>
|
||||
#include <eoSGAGenOp.h>
|
||||
#include <algo/moeoEA.h>
|
||||
#include <diversity/moeoFrontByFrontSharingDiversityAssignment.h>
|
||||
#include <fitness/moeoFastNonDominatedSortingFitnessAssignment.h>
|
||||
#include <replacement/moeoElitistReplacement.h>
|
||||
#include <selection/moeoDetTournamentSelect.h>
|
||||
|
||||
/**
|
||||
* NSGA (Non-dominated Sorting Genetic Algorithm) as described in:
|
||||
* N. Srinivas, K. Deb, "Multiobjective Optimization Using Nondominated Sorting in Genetic Algorithms".
|
||||
* Evolutionary Computation, Vol. 2(3), No 2, pp. 221-248 (1994).
|
||||
* This class builds the NSGA algorithm only by using the fine-grained components of the ParadisEO-MOEO framework.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoNSGA: public moeoEA < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Simple ctor with a eoGenOp.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _nicheSize niche size
|
||||
*/
|
||||
moeoNSGA (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, double _nicheSize = 0.5) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2),
|
||||
diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Simple ctor with a eoTransform.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _nicheSize niche size
|
||||
*/
|
||||
moeoNSGA (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, double _nicheSize = 0.5) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2),
|
||||
diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a crossover, a mutation and their corresponding rates.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _crossover crossover
|
||||
* @param _pCross crossover probability
|
||||
* @param _mutation mutation
|
||||
* @param _pMut mutation probability
|
||||
* @param _nicheSize niche size
|
||||
*/
|
||||
moeoNSGA (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoQuadOp < MOEOT > & _crossover, double _pCross, eoMonOp < MOEOT > & _mutation, double _pMut, double _nicheSize = 0.5) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select (2),
|
||||
diversityAssignment(_nicheSize), replace (fitnessAssignment, diversityAssignment),
|
||||
defaultSGAGenOp(_crossover, _pCross, _mutation, _pMut), genBreed (select, defaultSGAGenOp), breed (genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a continuator (instead of _maxGen) and a eoGenOp.
|
||||
* @param _continuator stopping criteria
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _nicheSize niche size
|
||||
*/
|
||||
moeoNSGA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, double _nicheSize = 0.5) :
|
||||
continuator(_continuator), popEval(_eval), select(2),
|
||||
diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a continuator (instead of _maxGen) and a eoTransform.
|
||||
* @param _continuator stopping criteria
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
* @param _nicheSize niche size
|
||||
*/
|
||||
moeoNSGA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, double _nicheSize = 0.5) :
|
||||
continuator(_continuator), popEval(_eval), select(2),
|
||||
diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Apply a few generation of evolution to the population _pop until the stopping criteria is verified.
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void operator () (eoPop < MOEOT > &_pop)
|
||||
{
|
||||
eoPop < MOEOT > offspring, empty_pop;
|
||||
popEval (empty_pop, _pop); // a first eval of _pop
|
||||
// evaluate fitness and diversity
|
||||
fitnessAssignment(_pop);
|
||||
diversityAssignment(_pop);
|
||||
do
|
||||
{
|
||||
// generate offspring, worths are recalculated if necessary
|
||||
breed (_pop, offspring);
|
||||
// eval of offspring
|
||||
popEval (_pop, offspring);
|
||||
// after replace, the new pop is in _pop. Worths are recalculated if necessary
|
||||
replace (_pop, offspring);
|
||||
} while (continuator (_pop));
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** a continuator based on the number of generations (used as default) */
|
||||
eoGenContinue < MOEOT > defaultGenContinuator;
|
||||
/** stopping criteria */
|
||||
eoContinue < MOEOT > & continuator;
|
||||
/** evaluation function used to evaluate the whole population */
|
||||
eoPopLoopEval < MOEOT > popEval;
|
||||
/** binary tournament selection */
|
||||
moeoDetTournamentSelect < MOEOT > select;
|
||||
/** fitness assignment used in NSGA-II */
|
||||
moeoFastNonDominatedSortingFitnessAssignment < MOEOT > fitnessAssignment;
|
||||
/** diversity assignment used in NSGA-II */
|
||||
moeoFrontByFrontSharingDiversityAssignment < MOEOT > diversityAssignment;
|
||||
/** elitist replacement */
|
||||
moeoElitistReplacement < MOEOT > replace;
|
||||
/** an object for genetic operators (used as default) */
|
||||
eoSGAGenOp < MOEOT > defaultSGAGenOp;
|
||||
/** general breeder */
|
||||
eoGeneralBreeder < MOEOT > genBreed;
|
||||
/** breeder */
|
||||
eoBreed < MOEOT > & breed;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEONSGAII_H_*/
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoNSGAII.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEONSGAII_H_
|
||||
#define MOEONSGAII_H_
|
||||
|
||||
#include <eoBreed.h>
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoGenContinue.h>
|
||||
#include <eoGeneralBreeder.h>
|
||||
#include <eoGenOp.h>
|
||||
#include <eoPopEvalFunc.h>
|
||||
#include <eoSGAGenOp.h>
|
||||
#include <algo/moeoEA.h>
|
||||
#include <diversity/moeoFrontByFrontCrowdingDistanceDiversityAssignment.h>
|
||||
#include <fitness/moeoFastNonDominatedSortingFitnessAssignment.h>
|
||||
#include <replacement/moeoElitistReplacement.h>
|
||||
#include <selection/moeoDetTournamentSelect.h>
|
||||
|
||||
/**
|
||||
* NSGA-II (Non-dominated Sorting Genetic Algorithm II) as described in:
|
||||
* Deb, K., S. Agrawal, A. Pratap, and T. Meyarivan : "A fast elitist non-dominated sorting genetic algorithm for multi-objective optimization: NSGA-II".
|
||||
* In IEEE Transactions on Evolutionary Computation, Vol. 6, No 2, pp 182-197 (April 2002).
|
||||
* This class builds the NSGA-II algorithm only by using the fine-grained components of the ParadisEO-MOEO framework.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoNSGAII: public moeoEA < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Simple ctor with a eoGenOp.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
*/
|
||||
moeoNSGAII (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2),
|
||||
replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Simple ctor with a eoTransform.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
*/
|
||||
moeoNSGAII (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2),
|
||||
replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a crossover, a mutation and their corresponding rates.
|
||||
* @param _maxGen number of generations before stopping
|
||||
* @param _eval evaluation function
|
||||
* @param _crossover crossover
|
||||
* @param _pCross crossover probability
|
||||
* @param _mutation mutation
|
||||
* @param _pMut mutation probability
|
||||
*/
|
||||
moeoNSGAII (unsigned int _maxGen, eoEvalFunc < MOEOT > & _eval, eoQuadOp < MOEOT > & _crossover, double _pCross, eoMonOp < MOEOT > & _mutation, double _pMut) :
|
||||
defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select (2),
|
||||
replace (fitnessAssignment, diversityAssignment), defaultSGAGenOp(_crossover, _pCross, _mutation, _pMut),
|
||||
genBreed (select, defaultSGAGenOp), breed (genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a continuator (instead of _maxGen) and a eoGenOp.
|
||||
* @param _continuator stopping criteria
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
*/
|
||||
moeoNSGAII (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op) :
|
||||
continuator(_continuator), popEval(_eval), select(2),
|
||||
replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with a continuator (instead of _maxGen) and a eoTransform.
|
||||
* @param _continuator stopping criteria
|
||||
* @param _eval evaluation function
|
||||
* @param _op variation operator
|
||||
*/
|
||||
moeoNSGAII (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op) :
|
||||
continuator(_continuator), popEval(_eval), select(2),
|
||||
replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Apply a few generation of evolution to the population _pop until the stopping criteria is verified.
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void operator () (eoPop < MOEOT > &_pop)
|
||||
{
|
||||
eoPop < MOEOT > offspring, empty_pop;
|
||||
popEval (empty_pop, _pop); // a first eval of _pop
|
||||
// evaluate fitness and diversity
|
||||
fitnessAssignment(_pop);
|
||||
diversityAssignment(_pop);
|
||||
do
|
||||
{
|
||||
// generate offspring, worths are recalculated if necessary
|
||||
breed (_pop, offspring);
|
||||
// eval of offspring
|
||||
popEval (_pop, offspring);
|
||||
// after replace, the new pop is in _pop. Worths are recalculated if necessary
|
||||
replace (_pop, offspring);
|
||||
} while (continuator (_pop));
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** a continuator based on the number of generations (used as default) */
|
||||
eoGenContinue < MOEOT > defaultGenContinuator;
|
||||
/** stopping criteria */
|
||||
eoContinue < MOEOT > & continuator;
|
||||
/** evaluation function used to evaluate the whole population */
|
||||
eoPopLoopEval < MOEOT > popEval;
|
||||
/** binary tournament selection */
|
||||
moeoDetTournamentSelect < MOEOT > select;
|
||||
/** fitness assignment used in NSGA-II */
|
||||
moeoFastNonDominatedSortingFitnessAssignment < MOEOT > fitnessAssignment;
|
||||
/** diversity assignment used in NSGA-II */
|
||||
moeoFrontByFrontCrowdingDistanceDiversityAssignment < MOEOT > diversityAssignment;
|
||||
/** elitist replacement */
|
||||
moeoElitistReplacement < MOEOT > replace;
|
||||
/** an object for genetic operators (used as default) */
|
||||
eoSGAGenOp < MOEOT > defaultSGAGenOp;
|
||||
/** general breeder */
|
||||
eoGeneralBreeder < MOEOT > genBreed;
|
||||
/** breeder */
|
||||
eoBreed < MOEOT > & breed;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEONSGAII_H_*/
|
||||
|
|
@ -1,180 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoArchive.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOARCHIVE_H_
|
||||
#define MOEOARCHIVE_H_
|
||||
|
||||
#include <eoPop.h>
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
|
||||
/**
|
||||
* An archive is a secondary population that stores non-dominated solutions.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoArchive : public eoPop < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
using eoPop < MOEOT > :: size;
|
||||
using eoPop < MOEOT > :: operator[];
|
||||
using eoPop < MOEOT > :: back;
|
||||
using eoPop < MOEOT > :: pop_back;
|
||||
|
||||
|
||||
/**
|
||||
* The type of an objective vector for a solution
|
||||
*/
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Default ctor.
|
||||
* The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance
|
||||
*/
|
||||
moeoArchive() : eoPop < MOEOT >(), comparator(paretoComparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _comparator the moeoObjectiveVectorComparator used to compare solutions
|
||||
*/
|
||||
moeoArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : eoPop < MOEOT >(), comparator(_comparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current archive dominates _objectiveVector according to the moeoObjectiveVectorComparator given in the constructor
|
||||
* @param _objectiveVector the objective vector to compare with the current archive
|
||||
*/
|
||||
bool dominates (const ObjectiveVector & _objectiveVector) const
|
||||
{
|
||||
for (unsigned int i = 0; i<size(); i++)
|
||||
{
|
||||
// if _objectiveVector is dominated by the ith individual of the archive...
|
||||
if ( comparator(_objectiveVector, operator[](i).objectiveVector()) )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current archive already contains a solution with the same objective values than _objectiveVector
|
||||
* @param _objectiveVector the objective vector to compare with the current archive
|
||||
*/
|
||||
bool contains (const ObjectiveVector & _objectiveVector) const
|
||||
{
|
||||
for (unsigned int i = 0; i<size(); i++)
|
||||
{
|
||||
if (operator[](i).objectiveVector() == _objectiveVector)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the archive with a given individual _moeo
|
||||
* @param _moeo the given individual
|
||||
*/
|
||||
void update (const MOEOT & _moeo)
|
||||
{
|
||||
// first step: removing the dominated solutions from the archive
|
||||
for (unsigned int j=0; j<size();)
|
||||
{
|
||||
// if the jth solution contained in the archive is dominated by _moeo
|
||||
if ( comparator(operator[](j).objectiveVector(), _moeo.objectiveVector()) )
|
||||
{
|
||||
operator[](j) = back();
|
||||
pop_back();
|
||||
}
|
||||
else if (_moeo.objectiveVector() == operator[](j).objectiveVector())
|
||||
{
|
||||
operator[](j) = back();
|
||||
pop_back();
|
||||
}
|
||||
else
|
||||
{
|
||||
j++;
|
||||
}
|
||||
}
|
||||
// second step: is _moeo dominated?
|
||||
bool dom = false;
|
||||
for (unsigned int j=0; j<size(); j++)
|
||||
{
|
||||
// if _moeo is dominated by the jth solution contained in the archive
|
||||
if ( comparator(_moeo.objectiveVector(), operator[](j).objectiveVector()) )
|
||||
{
|
||||
dom = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!dom)
|
||||
{
|
||||
push_back(_moeo);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the archive with a given population _pop
|
||||
* @param _pop the given population
|
||||
*/
|
||||
void update (const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
update(_pop[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current archive contains the same objective vectors than the given archive _arch
|
||||
* @param _arch the given archive
|
||||
*/
|
||||
bool equals (const moeoArchive < MOEOT > & _arch)
|
||||
{
|
||||
for (unsigned int i=0; i<size(); i++)
|
||||
{
|
||||
if (! _arch.contains(operator[](i).objectiveVector()))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (unsigned int i=0; i<_arch.size() ; i++)
|
||||
{
|
||||
if (! contains(_arch[i].objectiveVector()))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** The moeoObjectiveVectorComparator used to compare solutions */
|
||||
moeoObjectiveVectorComparator < ObjectiveVector > & comparator;
|
||||
/** A moeoObjectiveVectorComparator based on Pareto dominance (used as default) */
|
||||
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOARCHIVE_H_ */
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoAggregativeComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOAGGREGATIVECOMPARATOR_H_
|
||||
#define MOEOAGGREGATIVECOMPARATOR_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
|
||||
/**
|
||||
* Functor allowing to compare two solutions according to their fitness and diversity values, each according to its aggregative value.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoAggregativeComparator : public moeoComparator < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _weightFitness the weight for fitness
|
||||
* @param _weightDiversity the weight for diversity
|
||||
*/
|
||||
moeoAggregativeComparator(double _weightFitness = 1.0, double _weightDiversity = 1.0) : weightFitness(_weightFitness), weightDiversity(_weightDiversity)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if _moeo1 < _moeo2 according to the aggregation of their fitness and diversity values
|
||||
* @param _moeo1 the first solution
|
||||
* @param _moeo2 the second solution
|
||||
*/
|
||||
const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
return ( weightFitness * _moeo1.fitness() + weightDiversity * _moeo1.diversity() ) < ( weightFitness * _moeo2.fitness() + weightDiversity * _moeo2.diversity() );
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the weight for fitness */
|
||||
double weightFitness;
|
||||
/** the weight for diversity */
|
||||
double weightDiversity;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOAGGREGATIVECOMPARATOR_H_*/
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOCOMPARATOR_H_
|
||||
#define MOEOCOMPARATOR_H_
|
||||
|
||||
#include <eoFunctor.h>
|
||||
|
||||
/**
|
||||
* Functor allowing to compare two solutions.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoComparator : public eoBF < const MOEOT &, const MOEOT &, const bool > {};
|
||||
|
||||
#endif /*MOEOCOMPARATOR_H_*/
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoDiversityThenFitnessComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEODIVERSITYTHENFITNESSCOMPARATOR_H_
|
||||
#define MOEODIVERSITYTHENFITNESSCOMPARATOR_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
|
||||
/**
|
||||
* Functor allowing to compare two solutions according to their diversity values, then according to their fitness values.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoDiversityThenFitnessComparator : public moeoComparator < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns true if _moeo1 < _moeo2 according to their diversity values, then according to their fitness values
|
||||
* @param _moeo1 the first solution
|
||||
* @param _moeo2 the second solution
|
||||
*/
|
||||
const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
if (_moeo1.diversity() == _moeo2.diversity())
|
||||
{
|
||||
return _moeo1.fitness() < _moeo2.fitness();
|
||||
}
|
||||
else
|
||||
{
|
||||
return _moeo1.diversity() < _moeo2.diversity();
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEODIVERSITYTHENFITNESSCOMPARATOR_H_*/
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoFitnessThenDiversityComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOFITNESSTHENDIVERSITYCOMPARATOR_H_
|
||||
#define MOEOFITNESSTHENDIVERSITYCOMPARATOR_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
|
||||
/**
|
||||
* Functor allowing to compare two solutions according to their fitness values, then according to their diversity values.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoFitnessThenDiversityComparator : public moeoComparator < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns true if _moeo1 < _moeo2 according to their fitness values, then according to their diversity values
|
||||
* @param _moeo1 the first solution
|
||||
* @param _moeo2 the second solution
|
||||
*/
|
||||
const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
if (_moeo1.fitness() == _moeo2.fitness())
|
||||
{
|
||||
return _moeo1.diversity() < _moeo2.diversity();
|
||||
}
|
||||
else
|
||||
{
|
||||
return _moeo1.fitness() < _moeo2.fitness();
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOFITNESSTHENDIVERSITYCOMPARATOR_H_*/
|
||||
|
|
@ -1,102 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoGDominanceObjectiveVectorComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOGDOMINANCEOBJECTIVEVECTORCOMPARATOR_H_
|
||||
#define MOEOGDOMINANCEOBJECTIVEVECTORCOMPARATOR_H_
|
||||
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
|
||||
/**
|
||||
* This functor class allows to compare 2 objective vectors according to g-dominance.
|
||||
* The concept of g-dominance as been introduced in:
|
||||
* J. Molina, L. V. Santana, A. G. Hernandez-Diaz, C. A. Coello Coello, R. Caballero,
|
||||
* "g-dominance: Reference point based dominance" (2007)
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoGDominanceObjectiveVectorComparator : public moeoObjectiveVectorComparator < ObjectiveVector >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _ref the reference point
|
||||
*/
|
||||
moeoGDominanceObjectiveVectorComparator(ObjectiveVector & _ref) : ref(_ref)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if _objectiveVector1 is g-dominated by _objectiveVector2.
|
||||
* @param _objectiveVector1 the first objective vector
|
||||
* @param _objectiveVector2 the second objective vector
|
||||
*/
|
||||
const bool operator()(const ObjectiveVector & _objectiveVector1, const ObjectiveVector & _objectiveVector2)
|
||||
{
|
||||
unsigned int flag1 = flag(_objectiveVector1);
|
||||
unsigned int flag2 = flag(_objectiveVector2);
|
||||
if (flag2==0)
|
||||
{
|
||||
// cannot dominate
|
||||
return false;
|
||||
}
|
||||
else if ( (flag2==1) && (flag1==0) )
|
||||
{
|
||||
// is dominated
|
||||
return true;
|
||||
}
|
||||
else // (flag1==1) && (flag2==1)
|
||||
{
|
||||
// both are on the good region, so let's use the classical Pareto dominance
|
||||
return paretoComparator(_objectiveVector1, _objectiveVector2);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the reference point */
|
||||
ObjectiveVector & ref;
|
||||
/** Pareto comparator */
|
||||
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
|
||||
|
||||
|
||||
/**
|
||||
* Returns the flag of _objectiveVector according to the reference point
|
||||
* @param _objectiveVector the first objective vector
|
||||
*/
|
||||
unsigned int flag(const ObjectiveVector & _objectiveVector)
|
||||
{
|
||||
unsigned int result=1;
|
||||
for (unsigned int i=0; i<ref.nObjectives(); i++)
|
||||
{
|
||||
if (_objectiveVector[i] > ref[i])
|
||||
{
|
||||
result=0;
|
||||
}
|
||||
}
|
||||
if (result==0)
|
||||
{
|
||||
result=1;
|
||||
for (unsigned int i=0; i<ref.nObjectives(); i++)
|
||||
{
|
||||
if (_objectiveVector[i] < ref[i])
|
||||
{
|
||||
result=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOGDOMINANCEOBJECTIVEVECTORCOMPARATOR_H_*/
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoObjectiveObjectiveVectorComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOOBJECTIVEOBJECTIVEVECTORCOMPARATOR_H_
|
||||
#define MOEOOBJECTIVEOBJECTIVEVECTORCOMPARATOR_H_
|
||||
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
|
||||
/**
|
||||
* Functor allowing to compare two objective vectors according to their first objective value, then their second, and so on.
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoObjectiveObjectiveVectorComparator : public moeoObjectiveVectorComparator < ObjectiveVector >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns true if _objectiveVector1 < _objectiveVector2 on the first objective, then on the second, and so on
|
||||
* @param _objectiveVector1 the first objective vector
|
||||
* @param _objectiveVector2 the second objective vector
|
||||
*/
|
||||
const bool operator()(const ObjectiveVector & _objectiveVector1, const ObjectiveVector & _objectiveVector2)
|
||||
{
|
||||
for (unsigned int i=0; i<ObjectiveVector::nObjectives(); i++)
|
||||
{
|
||||
if ( fabs(_objectiveVector1[i] - _objectiveVector2[i]) > ObjectiveVector::Traits::tolerance() )
|
||||
{
|
||||
if (_objectiveVector1[i] < _objectiveVector2[i])
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOOBJECTIVEOBJECTIVEVECTORCOMPARATOR_H_*/
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoObjectiveVectorComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOOBJECTIVEVECTORCOMPARATOR_H_
|
||||
#define MOEOOBJECTIVEVECTORCOMPARATOR_H_
|
||||
|
||||
#include <math.h>
|
||||
#include <eoFunctor.h>
|
||||
|
||||
/**
|
||||
* Abstract class allowing to compare 2 objective vectors.
|
||||
* The template argument ObjectiveVector have to be a moeoObjectiveVector.
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoObjectiveVectorComparator : public eoBF < const ObjectiveVector &, const ObjectiveVector &, const bool > {};
|
||||
|
||||
#endif /*MOEOOBJECTIVEVECTORCOMPARATOR_H_*/
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoOneObjectiveComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOONEOBJECTIVECOMPARATOR_H_
|
||||
#define MOEOONEOBJECTIVECOMPARATOR_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
|
||||
/**
|
||||
* Functor allowing to compare two solutions according to one objective.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoOneObjectiveComparator : public moeoComparator < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _obj the index of objective
|
||||
*/
|
||||
moeoOneObjectiveComparator(unsigned int _obj) : obj(_obj)
|
||||
{
|
||||
if (obj > MOEOT::ObjectiveVector::nObjectives())
|
||||
{
|
||||
throw std::runtime_error("Problem with the index of objective in moeoOneObjectiveComparator");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if _moeo1 < _moeo2 on the obj objective
|
||||
* @param _moeo1 the first solution
|
||||
* @param _moeo2 the second solution
|
||||
*/
|
||||
const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
return _moeo1.objectiveVector()[obj] < _moeo2.objectiveVector()[obj];
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the index of objective */
|
||||
unsigned int obj;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOONEOBJECTIVECOMPARATOR_H_*/
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoParetoObjectiveVectorComparator.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOPARETOOBJECTIVEVECTORCOMPARATOR_H_
|
||||
#define MOEOPARETOOBJECTIVEVECTORCOMPARATOR_H_
|
||||
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
|
||||
/**
|
||||
* This functor class allows to compare 2 objective vectors according to Pareto dominance.
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoParetoObjectiveVectorComparator : public moeoObjectiveVectorComparator < ObjectiveVector >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns true if _objectiveVector1 is dominated by _objectiveVector2
|
||||
* @param _objectiveVector1 the first objective vector
|
||||
* @param _objectiveVector2 the second objective vector
|
||||
*/
|
||||
const bool operator()(const ObjectiveVector & _objectiveVector1, const ObjectiveVector & _objectiveVector2)
|
||||
{
|
||||
bool dom = false;
|
||||
for (unsigned int i=0; i<ObjectiveVector::nObjectives(); i++)
|
||||
{
|
||||
// first, we have to check if the 2 objective values are not equal for the ith objective
|
||||
if ( fabs(_objectiveVector1[i] - _objectiveVector2[i]) > ObjectiveVector::Traits::tolerance() )
|
||||
{
|
||||
// if the ith objective have to be minimized...
|
||||
if (ObjectiveVector::minimizing(i))
|
||||
{
|
||||
if (_objectiveVector1[i] > _objectiveVector2[i])
|
||||
{
|
||||
dom = true; //_objectiveVector1[i] is not better than _objectiveVector2[i]
|
||||
}
|
||||
else
|
||||
{
|
||||
return false; //_objectiveVector2 cannot dominate _objectiveVector1
|
||||
}
|
||||
}
|
||||
// if the ith objective have to be maximized...
|
||||
else if (ObjectiveVector::maximizing(i))
|
||||
{
|
||||
if (_objectiveVector1[i] > _objectiveVector2[i])
|
||||
{
|
||||
dom = true; //_objectiveVector1[i] is not better than _objectiveVector2[i]
|
||||
}
|
||||
else
|
||||
{
|
||||
return false; //_objectiveVector2 cannot dominate _objectiveVector1
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return dom;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOPARETOOBJECTIVEVECTORCOMPARATOR_H_*/
|
||||
|
|
@ -1,291 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// MOEO.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEO_H_
|
||||
#define MOEO_H_
|
||||
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <EO.h>
|
||||
|
||||
/**
|
||||
* Base class allowing to represent a solution (an individual) for multi-objective optimization.
|
||||
* The template argument MOEOObjectiveVector allows to represent the solution in the objective space (it can be a moeoObjectiveVector object).
|
||||
* The template argument MOEOFitness is an object reflecting the quality of the solution in term of convergence (the fitness of a solution is always to be maximized).
|
||||
* The template argument MOEODiversity is an object reflecting the quality of the solution in term of diversity (the diversity of a solution is always to be maximized).
|
||||
* All template arguments must have a void and a copy constructor.
|
||||
* Using some specific representations, you will have to define a copy constructor if the default one is not what you want.
|
||||
* In the same cases, you will also have to define the affectation operator (operator=).
|
||||
* Then, you will explicitly have to call the parent copy constructor and the parent affectation operator at the beginning of the corresponding implementation.
|
||||
* Besides, note that, contrary to the mono-objective case (and to EO) where the fitness value of a solution is confused with its objective value,
|
||||
* the fitness value differs of the objectives values in the multi-objective case.
|
||||
*/
|
||||
template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity >
|
||||
class MOEO : public EO < MOEOObjectiveVector >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of a solution */
|
||||
typedef MOEOObjectiveVector ObjectiveVector;
|
||||
|
||||
/** the fitness type of a solution */
|
||||
typedef MOEOFitness Fitness;
|
||||
|
||||
/** the diversity type of a solution */
|
||||
typedef MOEODiversity Diversity;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
*/
|
||||
MOEO()
|
||||
{
|
||||
// default values for every parameters
|
||||
objectiveVectorValue = ObjectiveVector();
|
||||
fitnessValue = Fitness();
|
||||
diversityValue = Diversity();
|
||||
// invalidate all
|
||||
invalidate();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Virtual dtor
|
||||
*/
|
||||
virtual ~MOEO() {};
|
||||
|
||||
|
||||
/**
|
||||
* Returns the objective vector of the current solution
|
||||
*/
|
||||
ObjectiveVector objectiveVector() const
|
||||
{
|
||||
if ( invalidObjectiveVector() )
|
||||
{
|
||||
throw std::runtime_error("invalid objective vector in MOEO");
|
||||
}
|
||||
return objectiveVectorValue;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the objective vector of the current solution
|
||||
* @param _objectiveVectorValue the new objective vector
|
||||
*/
|
||||
void objectiveVector(const ObjectiveVector & _objectiveVectorValue)
|
||||
{
|
||||
objectiveVectorValue = _objectiveVectorValue;
|
||||
invalidObjectiveVectorValue = false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the objective vector as invalid
|
||||
*/
|
||||
void invalidateObjectiveVector()
|
||||
{
|
||||
invalidObjectiveVectorValue = true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the objective vector is invalid, false otherwise
|
||||
*/
|
||||
bool invalidObjectiveVector() const
|
||||
{
|
||||
return invalidObjectiveVectorValue;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the fitness value of the current solution
|
||||
*/
|
||||
Fitness fitness() const
|
||||
{
|
||||
if ( invalidFitness() )
|
||||
{
|
||||
throw std::runtime_error("invalid fitness in MOEO");
|
||||
}
|
||||
return fitnessValue;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness value of the current solution
|
||||
* @param _fitnessValue the new fitness value
|
||||
*/
|
||||
void fitness(const Fitness & _fitnessValue)
|
||||
{
|
||||
fitnessValue = _fitnessValue;
|
||||
invalidFitnessValue = false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness value as invalid
|
||||
*/
|
||||
void invalidateFitness()
|
||||
{
|
||||
invalidFitnessValue = true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the fitness value is invalid, false otherwise
|
||||
*/
|
||||
bool invalidFitness() const
|
||||
{
|
||||
return invalidFitnessValue;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the diversity value of the current solution
|
||||
*/
|
||||
Diversity diversity() const
|
||||
{
|
||||
if ( invalidDiversity() )
|
||||
{
|
||||
throw std::runtime_error("invalid diversity in MOEO");
|
||||
}
|
||||
return diversityValue;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the diversity value of the current solution
|
||||
* @param _diversityValue the new diversity value
|
||||
*/
|
||||
void diversity(const Diversity & _diversityValue)
|
||||
{
|
||||
diversityValue = _diversityValue;
|
||||
invalidDiversityValue = false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the diversity value as invalid
|
||||
*/
|
||||
void invalidateDiversity()
|
||||
{
|
||||
invalidDiversityValue = true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the diversity value is invalid, false otherwise
|
||||
*/
|
||||
bool invalidDiversity() const
|
||||
{
|
||||
return invalidDiversityValue;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the objective vector, the fitness value and the diversity value as invalid
|
||||
*/
|
||||
void invalidate()
|
||||
{
|
||||
invalidateObjectiveVector();
|
||||
invalidateFitness();
|
||||
invalidateDiversity();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the fitness value is invalid, false otherwise
|
||||
*/
|
||||
bool invalid() const
|
||||
{
|
||||
return invalidObjectiveVector();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the objective vector of the current solution is smaller than the objective vector of _other on the first objective,
|
||||
* then on the second, and so on (can be usefull for sorting/printing).
|
||||
* You should implement another function in the sub-class of MOEO to have another sorting mecanism.
|
||||
* @param _other the other MOEO object to compare with
|
||||
*/
|
||||
bool operator<(const MOEO & _other) const
|
||||
{
|
||||
return objectiveVector() < _other.objectiveVector();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return the class id (the class name as a std::string)
|
||||
*/
|
||||
virtual std::string className() const
|
||||
{
|
||||
return "MOEO";
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Writing object
|
||||
* @param _os output stream
|
||||
*/
|
||||
virtual void printOn(std::ostream & _os) const
|
||||
{
|
||||
if ( invalidObjectiveVector() )
|
||||
{
|
||||
_os << "INVALID\t";
|
||||
}
|
||||
else
|
||||
{
|
||||
_os << objectiveVectorValue << '\t';
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Reading object
|
||||
* @param _is input stream
|
||||
*/
|
||||
virtual void readFrom(std::istream & _is)
|
||||
{
|
||||
std::string objectiveVector_str;
|
||||
int pos = _is.tellg();
|
||||
_is >> objectiveVector_str;
|
||||
if (objectiveVector_str == "INVALID")
|
||||
{
|
||||
invalidateObjectiveVector();
|
||||
}
|
||||
else
|
||||
{
|
||||
invalidObjectiveVectorValue = false;
|
||||
_is.seekg(pos); // rewind
|
||||
_is >> objectiveVectorValue;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the objective vector of this solution */
|
||||
ObjectiveVector objectiveVectorValue;
|
||||
/** true if the objective vector is invalid */
|
||||
bool invalidObjectiveVectorValue;
|
||||
/** the fitness value of this solution */
|
||||
Fitness fitnessValue;
|
||||
/** true if the fitness value is invalid */
|
||||
bool invalidFitnessValue;
|
||||
/** the diversity value of this solution */
|
||||
Diversity diversityValue;
|
||||
/** true if the diversity value is invalid */
|
||||
bool invalidDiversityValue;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEO_H_*/
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
lib_LIBRARIES = libmoeo.a
|
||||
|
||||
libmoeo_a_SOURCES = moeoObjectiveVectorTraits.cpp
|
||||
|
||||
pkginclude_HEADERS = moeoObjectiveVectorTraits.h
|
||||
|
||||
INCLUDES = -I$(EO_DIR)/src/ -I$(top_srcdir)/src/
|
||||
|
||||
AM_CXXFLAGS = -Wall -ansi -pedantic
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoBitVector.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOBITVECTOR_H_
|
||||
#define MOEOBITVECTOR_H_
|
||||
|
||||
#include <core/moeoVector.h>
|
||||
|
||||
/**
|
||||
* This class is an implementationeo of a simple bit-valued moeoVector.
|
||||
*/
|
||||
template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity >
|
||||
class moeoBitVector : public moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool >
|
||||
{
|
||||
public:
|
||||
|
||||
using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: begin;
|
||||
using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: end;
|
||||
using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: resize;
|
||||
using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: size;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _size Length of vector (default is 0)
|
||||
* @param _value Initial value of all elements (default is default value of type GeneType)
|
||||
*/
|
||||
moeoBitVector(unsigned int _size = 0, bool _value = false) : moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool >(_size, _value)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Writing object
|
||||
* @param _os output stream
|
||||
*/
|
||||
virtual void printOn(std::ostream & _os) const
|
||||
{
|
||||
MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::printOn(_os);
|
||||
_os << ' ';
|
||||
_os << size() << ' ';
|
||||
std::copy(begin(), end(), std::ostream_iterator<bool>(_os));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Reading object
|
||||
* @param _is input stream
|
||||
*/
|
||||
virtual void readFrom(std::istream & _is)
|
||||
{
|
||||
MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::readFrom(_is);
|
||||
unsigned int s;
|
||||
_is >> s;
|
||||
std::string bits;
|
||||
_is >> bits;
|
||||
if (_is)
|
||||
{
|
||||
resize(bits.size());
|
||||
std::transform(bits.begin(), bits.end(), begin(), std::bind2nd(std::equal_to<char>(), '1'));
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOBITVECTOR_H_*/
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoEvalFunc.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOEVALFUNC_H_
|
||||
#define MOEOEVALFUNC_H_
|
||||
|
||||
#include <eoEvalFunc.h>
|
||||
|
||||
/*
|
||||
* Functor that evaluates one MOEO by setting all its objective values.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoEvalFunc : public eoEvalFunc< MOEOT > {};
|
||||
|
||||
#endif /*MOEOEVALFUNC_H_*/
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoObjectiveVector.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOOBJECTIVEVECTOR_H_
|
||||
#define MOEOOBJECTIVEVECTOR_H_
|
||||
|
||||
#include <vector>
|
||||
|
||||
/**
|
||||
* Abstract class allowing to represent a solution in the objective space (phenotypic representation).
|
||||
* The template argument ObjectiveVectorTraits defaults to moeoObjectiveVectorTraits,
|
||||
* but it can be replaced at will by any other class that implements the static functions defined therein.
|
||||
* Some static funtions to access to the traits characteristics are re-defined in order not to write a lot of typedef's.
|
||||
*/
|
||||
template < class ObjectiveVectorTraits, class ObjectiveVectorType >
|
||||
class moeoObjectiveVector : public std::vector < ObjectiveVectorType >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The traits of objective vectors */
|
||||
typedef ObjectiveVectorTraits Traits;
|
||||
/** The type of an objective value */
|
||||
typedef ObjectiveVectorType Type;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
*/
|
||||
moeoObjectiveVector(Type _value = Type()) : std::vector < Type > (ObjectiveVectorTraits::nObjectives(), _value)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor from a vector of Type
|
||||
* @param _v the std::vector < Type >
|
||||
*/
|
||||
moeoObjectiveVector(std::vector < Type > & _v) : std::vector < Type > (_v)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Parameters setting (for the objective vector of any solution)
|
||||
* @param _nObjectives the number of objectives
|
||||
* @param _bObjectives the min/max vector (true = min / false = max)
|
||||
*/
|
||||
static void setup(unsigned int _nObjectives, std::vector < bool > & _bObjectives)
|
||||
{
|
||||
ObjectiveVectorTraits::setup(_nObjectives, _bObjectives);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of objectives
|
||||
*/
|
||||
static unsigned int nObjectives()
|
||||
{
|
||||
return ObjectiveVectorTraits::nObjectives();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the _ith objective have to be minimized
|
||||
* @param _i the index
|
||||
*/
|
||||
static bool minimizing(unsigned int _i)
|
||||
{
|
||||
return ObjectiveVectorTraits::minimizing(_i);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the _ith objective have to be maximized
|
||||
* @param _i the index
|
||||
*/
|
||||
static bool maximizing(unsigned int _i)
|
||||
{
|
||||
return ObjectiveVectorTraits::maximizing(_i);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOOBJECTIVEVECTOR_H_*/
|
||||
|
|
@ -1,166 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoObjectiveVectorDouble.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOOBJECTIVEVECTORDOUBLE_H_
|
||||
#define MOEOOBJECTIVEVECTORDOUBLE_H_
|
||||
|
||||
#include <iostream>
|
||||
#include <math.h>
|
||||
#include <comparator/moeoObjectiveObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
#include <core/moeoObjectiveVector.h>
|
||||
|
||||
/**
|
||||
* This class allows to represent a solution in the objective space (phenotypic representation) by a std::vector of doubles,
|
||||
* i.e. that an objective value is represented using a double, and this for any objective.
|
||||
*/
|
||||
template < class ObjectiveVectorTraits >
|
||||
class moeoObjectiveVectorDouble : public moeoObjectiveVector < ObjectiveVectorTraits, double >
|
||||
{
|
||||
public:
|
||||
|
||||
using moeoObjectiveVector < ObjectiveVectorTraits, double >::size;
|
||||
using moeoObjectiveVector < ObjectiveVectorTraits, double >::operator[];
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
*/
|
||||
moeoObjectiveVectorDouble(double _value = 0.0) : moeoObjectiveVector < ObjectiveVectorTraits, double > (_value)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor from a vector of doubles
|
||||
* @param _v the std::vector < double >
|
||||
*/
|
||||
moeoObjectiveVectorDouble(std::vector < double > & _v) : moeoObjectiveVector < ObjectiveVectorTraits, double > (_v)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current objective vector dominates _other according to the Pareto dominance relation
|
||||
* (but it's better to use a moeoObjectiveVectorComparator object to compare solutions)
|
||||
* @param _other the other moeoObjectiveVectorDouble object to compare with
|
||||
*/
|
||||
bool dominates(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
|
||||
{
|
||||
moeoParetoObjectiveVectorComparator < moeoObjectiveVectorDouble<ObjectiveVectorTraits> > comparator;
|
||||
return comparator(_other, *this);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current objective vector is equal to _other (according to a tolerance value)
|
||||
* @param _other the other moeoObjectiveVectorDouble object to compare with
|
||||
*/
|
||||
bool operator==(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
|
||||
{
|
||||
for (unsigned int i=0; i < size(); i++)
|
||||
{
|
||||
if ( fabs(operator[](i) - _other[i]) > ObjectiveVectorTraits::tolerance() )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current objective vector is different than _other (according to a tolerance value)
|
||||
* @param _other the other moeoObjectiveVectorDouble object to compare with
|
||||
*/
|
||||
bool operator!=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
|
||||
{
|
||||
return ! operator==(_other);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current objective vector is smaller than _other on the first objective, then on the second, and so on
|
||||
* (can be usefull for sorting/printing)
|
||||
* @param _other the other moeoObjectiveVectorDouble object to compare with
|
||||
*/
|
||||
bool operator<(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
|
||||
{
|
||||
moeoObjectiveObjectiveVectorComparator < moeoObjectiveVectorDouble < ObjectiveVectorTraits > > cmp;
|
||||
return cmp(*this, _other);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current objective vector is greater than _other on the first objective, then on the second, and so on
|
||||
* (can be usefull for sorting/printing)
|
||||
* @param _other the other moeoObjectiveVectorDouble object to compare with
|
||||
*/
|
||||
bool operator>(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
|
||||
{
|
||||
return _other < *this;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current objective vector is smaller than or equal to _other on the first objective, then on the second, and so on
|
||||
* (can be usefull for sorting/printing)
|
||||
* @param _other the other moeoObjectiveVectorDouble object to compare with
|
||||
*/
|
||||
bool operator<=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
|
||||
{
|
||||
return operator==(_other) || operator<(_other);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the current objective vector is greater than or equal to _other on the first objective, then on the second, and so on
|
||||
* (can be usefull for sorting/printing)
|
||||
* @param _other the other moeoObjectiveVectorDouble object to compare with
|
||||
*/
|
||||
bool operator>=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
|
||||
{
|
||||
return operator==(_other) || operator>(_other);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Output for a moeoObjectiveVectorDouble object
|
||||
* @param _os output stream
|
||||
* @param _objectiveVector the objective vector to write
|
||||
*/
|
||||
template < class ObjectiveVectorTraits >
|
||||
std::ostream & operator<<(std::ostream & _os, const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _objectiveVector)
|
||||
{
|
||||
for (unsigned int i=0; i<_objectiveVector.size(); i++)
|
||||
{
|
||||
_os << _objectiveVector[i] << '\t';
|
||||
}
|
||||
return _os;
|
||||
}
|
||||
|
||||
/**
|
||||
* Input for a moeoObjectiveVectorDouble object
|
||||
* @param _is input stream
|
||||
* @param _objectiveVector the objective vector to read
|
||||
*/
|
||||
template < class ObjectiveVectorTraits >
|
||||
std::istream & operator>>(std::istream & _is, moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _objectiveVector)
|
||||
{
|
||||
_objectiveVector = moeoObjectiveVectorDouble < ObjectiveVectorTraits > ();
|
||||
for (unsigned int i=0; i<_objectiveVector.size(); i++)
|
||||
{
|
||||
_is >> _objectiveVector[i];
|
||||
}
|
||||
return _is;
|
||||
}
|
||||
|
||||
#endif /*MOEOOBJECTIVEVECTORDOUBLE_H_*/
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoObjectiveVectorTraits.cpp
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <core/moeoObjectiveVectorTraits.h>
|
||||
|
||||
// The static variables of the moeoObjectiveVectorTraits class need to be allocated
|
||||
unsigned int moeoObjectiveVectorTraits::nObj;
|
||||
std::vector < bool > moeoObjectiveVectorTraits::bObj;
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoObjectiveVectorTraits.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOOBJECTIVEVECTORTRAITS_H_
|
||||
#define MOEOOBJECTIVEVECTORTRAITS_H_
|
||||
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
|
||||
/**
|
||||
* A traits class for moeoObjectiveVector to specify the number of objectives and which ones have to be minimized or maximized.
|
||||
*/
|
||||
class moeoObjectiveVectorTraits
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Parameters setting
|
||||
* @param _nObjectives the number of objectives
|
||||
* @param _bObjectives the min/max vector (true = min / false = max)
|
||||
*/
|
||||
static void setup(unsigned int _nObjectives, std::vector < bool > & _bObjectives)
|
||||
{
|
||||
// in case the number of objectives was already set to a different value
|
||||
if ( nObj && (nObj != _nObjectives) ) {
|
||||
std::cout << "WARNING\n";
|
||||
std::cout << "WARNING : the number of objectives are changing\n";
|
||||
std::cout << "WARNING : Make sure all existing objects are destroyed\n";
|
||||
std::cout << "WARNING\n";
|
||||
}
|
||||
// number of objectives
|
||||
nObj = _nObjectives;
|
||||
// min/max vector
|
||||
bObj = _bObjectives;
|
||||
// in case the number of objectives and the min/max vector size don't match
|
||||
if (nObj != bObj.size())
|
||||
throw std::runtime_error("Number of objectives and min/max size don't match in moeoObjectiveVectorTraits::setup");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of objectives
|
||||
*/
|
||||
static unsigned int nObjectives()
|
||||
{
|
||||
// in case the number of objectives would not be assigned yet
|
||||
if (! nObj)
|
||||
throw std::runtime_error("Number of objectives not assigned in moeoObjectiveVectorTraits");
|
||||
return nObj;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the _ith objective have to be minimized
|
||||
* @param _i the index
|
||||
*/
|
||||
static bool minimizing(unsigned int _i)
|
||||
{
|
||||
// in case there would be a wrong index
|
||||
if (_i >= bObj.size())
|
||||
throw std::runtime_error("Wrong index in moeoObjectiveVectorTraits");
|
||||
return bObj[_i];
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the _ith objective have to be maximized
|
||||
* @param _i the index
|
||||
*/
|
||||
static bool maximizing(unsigned int _i) {
|
||||
return (! minimizing(_i));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the tolerance value (to compare solutions)
|
||||
*/
|
||||
static double tolerance()
|
||||
{
|
||||
return 1e-6;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** The number of objectives */
|
||||
static unsigned int nObj;
|
||||
/** The min/max vector */
|
||||
static std::vector < bool > bObj;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOOBJECTIVEVECTORTRAITS_H_*/
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoRealVector.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOREALVECTOR_H_
|
||||
#define MOEOREALVECTOR_H_
|
||||
|
||||
#include <core/moeoVector.h>
|
||||
|
||||
/**
|
||||
* This class is an implementation of a simple double-valued moeoVector.
|
||||
*/
|
||||
template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity >
|
||||
class moeoRealVector : public moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, double >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _size Length of vector (default is 0)
|
||||
* @param _value Initial value of all elements (default is default value of type GeneType)
|
||||
*/
|
||||
moeoRealVector(unsigned int _size = 0, double _value = 0.0) : moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, double >(_size, _value)
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOREALVECTOR_H_*/
|
||||
|
|
@ -1,143 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoVector.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOVECTOR_H_
|
||||
#define MOEOVECTOR_H_
|
||||
|
||||
#include <iterator>
|
||||
#include <vector>
|
||||
#include <core/MOEO.h>
|
||||
|
||||
/**
|
||||
* Base class for fixed length chromosomes, just derives from MOEO and std::vector and redirects the smaller than operator to MOEO (objective vector based comparison).
|
||||
* GeneType must have the following methods: void ctor (needed for the std::vector<>), copy ctor.
|
||||
*/
|
||||
template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity, class GeneType >
|
||||
class moeoVector : public MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >, public std::vector < GeneType >
|
||||
{
|
||||
public:
|
||||
|
||||
using MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity > :: invalidate;
|
||||
using std::vector < GeneType > :: operator[];
|
||||
using std::vector < GeneType > :: begin;
|
||||
using std::vector < GeneType > :: end;
|
||||
using std::vector < GeneType > :: resize;
|
||||
using std::vector < GeneType > :: size;
|
||||
|
||||
/** the atomic type */
|
||||
typedef GeneType AtomType;
|
||||
/** the container type */
|
||||
typedef std::vector < GeneType > ContainerType;
|
||||
|
||||
|
||||
/**
|
||||
* Default ctor.
|
||||
* @param _size Length of vector (default is 0)
|
||||
* @param _value Initial value of all elements (default is default value of type GeneType)
|
||||
*/
|
||||
moeoVector(unsigned int _size = 0, GeneType _value = GeneType()) :
|
||||
MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >(), std::vector<GeneType>(_size, _value)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* We can't have a Ctor from a std::vector as it would create ambiguity with the copy Ctor.
|
||||
* @param _v a vector of GeneType
|
||||
*/
|
||||
void value(const std::vector < GeneType > & _v)
|
||||
{
|
||||
if (_v.size() != size()) // safety check
|
||||
{
|
||||
if (size()) // NOT an initial empty std::vector
|
||||
{
|
||||
std::cout << "Warning: Changing size in moeoVector assignation"<<std::endl;
|
||||
resize(_v.size());
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error("Size not initialized in moeoVector");
|
||||
}
|
||||
}
|
||||
std::copy(_v.begin(), _v.end(), begin());
|
||||
invalidate();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* To avoid conflicts between MOEO::operator< and std::vector<GeneType>::operator<
|
||||
* @param _moeo the object to compare with
|
||||
*/
|
||||
bool operator<(const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo) const
|
||||
{
|
||||
return MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::operator<(_moeo);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Writing object
|
||||
* @param _os output stream
|
||||
*/
|
||||
virtual void printOn(std::ostream & _os) const
|
||||
{
|
||||
MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::printOn(_os);
|
||||
_os << ' ';
|
||||
_os << size() << ' ';
|
||||
std::copy(begin(), end(), std::ostream_iterator<AtomType>(_os, " "));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Reading object
|
||||
* @param _is input stream
|
||||
*/
|
||||
virtual void readFrom(std::istream & _is)
|
||||
{
|
||||
MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::readFrom(_is);
|
||||
unsigned int sz;
|
||||
_is >> sz;
|
||||
resize(sz);
|
||||
unsigned int i;
|
||||
for (i = 0; i < sz; ++i)
|
||||
{
|
||||
AtomType atom;
|
||||
_is >> atom;
|
||||
operator[](i) = atom;
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* To avoid conflicts between MOEO::operator< and std::vector<double>::operator<
|
||||
* @param _moeo1 the first object to compare
|
||||
* @param _moeo2 the second object to compare
|
||||
*/
|
||||
template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity, class GeneType >
|
||||
bool operator<(const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo1, const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo2)
|
||||
{
|
||||
return _moeo1.operator<(_moeo2);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* To avoid conflicts between MOEO::operator> and std::vector<double>::operator>
|
||||
* @param _moeo1 the first object to compare
|
||||
* @param _moeo2 the second object to compare
|
||||
*/
|
||||
template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity, class GeneType >
|
||||
bool operator>(const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo1, const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo2)
|
||||
{
|
||||
return _moeo1.operator>(_moeo2);
|
||||
}
|
||||
|
||||
#endif /*MOEOVECTOR_H_*/
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoDistance.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEODISTANCE_H_
|
||||
#define MOEODISTANCE_H_
|
||||
|
||||
#include <eoFunctor.h>
|
||||
|
||||
/**
|
||||
* The base class for distance computation.
|
||||
*/
|
||||
template < class MOEOT , class Type >
|
||||
class moeoDistance : public eoBF < const MOEOT &, const MOEOT &, const Type >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Nothing to do
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void setup(const eoPop < MOEOT > & _pop)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Nothing to do
|
||||
* @param _min lower bound
|
||||
* @param _max upper bound
|
||||
* @param _obj the objective index
|
||||
*/
|
||||
virtual void setup(double _min, double _max, unsigned int _obj)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Nothing to do
|
||||
* @param _realInterval the eoRealInterval object
|
||||
* @param _obj the objective index
|
||||
*/
|
||||
virtual void setup(eoRealInterval _realInterval, unsigned int _obj)
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEODISTANCE_H_*/
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoDistanceMatrix.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEODISTANCEMATRIX_H_
|
||||
#define MOEODISTANCEMATRIX_H_
|
||||
|
||||
#include <vector>
|
||||
#include <eoFunctor.h>
|
||||
#include <distance/moeoDistance.h>
|
||||
|
||||
/**
|
||||
* A matrix to compute distances between every pair of individuals contained in a population.
|
||||
*/
|
||||
template < class MOEOT , class Type >
|
||||
class moeoDistanceMatrix : public eoUF < const eoPop < MOEOT > &, void > , public std::vector< std::vector < Type > >
|
||||
{
|
||||
public:
|
||||
|
||||
using std::vector< std::vector < Type > > :: size;
|
||||
using std::vector< std::vector < Type > > :: operator[];
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _size size for every dimension of the matrix
|
||||
* @param _distance the distance to use
|
||||
*/
|
||||
moeoDistanceMatrix (unsigned int _size, moeoDistance < MOEOT , Type > & _distance) : distance(_distance)
|
||||
{
|
||||
this->resize(_size);
|
||||
for (unsigned int i=0; i<_size; i++)
|
||||
{
|
||||
this->operator[](i).resize(_size);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the distance between every pair of individuals contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator()(const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// 1 - setup the bounds (if necessary)
|
||||
distance.setup(_pop);
|
||||
// 2 - compute distances
|
||||
this->operator[](0).operator[](0) = Type();
|
||||
for (unsigned int i=0; i<size(); i++)
|
||||
{
|
||||
this->operator[](i).operator[](i) = Type();
|
||||
for (unsigned int j=0; j<i; j++)
|
||||
{
|
||||
this->operator[](i).operator[](j) = distance(_pop[i], _pop[j]);
|
||||
this->operator[](j).operator[](i) = this->operator[](i).operator[](j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the distance to use */
|
||||
moeoDistance < MOEOT , Type > & distance;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEODISTANCEMATRIX_H_*/
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoEuclideanDistance.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOEUCLIDEANDISTANCE_H_
|
||||
#define MOEOEUCLIDEANDISTANCE_H_
|
||||
|
||||
#include <math.h>
|
||||
#include <distance/moeoNormalizedDistance.h>
|
||||
|
||||
/**
|
||||
* A class allowing to compute an euclidian distance between two solutions in the objective space with normalized objective values (i.e. between 0 and 1).
|
||||
* A distance value then lies between 0 and sqrt(nObjectives).
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoEuclideanDistance : public moeoNormalizedDistance < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Returns the euclidian distance between _moeo1 and _moeo2 in the objective space
|
||||
* @param _moeo1 the first solution
|
||||
* @param _moeo2 the second solution
|
||||
*/
|
||||
const double operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
double result = 0.0;
|
||||
double tmp1, tmp2;
|
||||
for (unsigned int i=0; i<ObjectiveVector::nObjectives(); i++)
|
||||
{
|
||||
tmp1 = (_moeo1.objectiveVector()[i] - bounds[i].minimum()) / bounds[i].range();
|
||||
tmp2 = (_moeo2.objectiveVector()[i] - bounds[i].minimum()) / bounds[i].range();
|
||||
result += (tmp1-tmp2) * (tmp1-tmp2);
|
||||
}
|
||||
return sqrt(result);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the bounds for every objective */
|
||||
using moeoNormalizedDistance < MOEOT > :: bounds;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOEUCLIDEANDISTANCE_H_*/
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoManhattanDistance.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOMANHATTANDISTANCE_H_
|
||||
#define MOEOMANHATTANDISTANCE_H_
|
||||
|
||||
#include <math.h>
|
||||
#include <distance/moeoNormalizedDistance.h>
|
||||
|
||||
/**
|
||||
* A class allowing to compute the Manhattan distance between two solutions in the objective space normalized objective values (i.e. between 0 and 1).
|
||||
* A distance value then lies between 0 and nObjectives.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoManhattanDistance : public moeoNormalizedDistance < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Returns the Manhattan distance between _moeo1 and _moeo2 in the objective space
|
||||
* @param _moeo1 the first solution
|
||||
* @param _moeo2 the second solution
|
||||
*/
|
||||
const double operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
double result = 0.0;
|
||||
double tmp1, tmp2;
|
||||
for (unsigned int i=0; i<ObjectiveVector::nObjectives(); i++)
|
||||
{
|
||||
tmp1 = (_moeo1.objectiveVector()[i] - bounds[i].minimum()) / bounds[i].range();
|
||||
tmp2 = (_moeo2.objectiveVector()[i] - bounds[i].minimum()) / bounds[i].range();
|
||||
result += fabs(tmp1-tmp2);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the bounds for every objective */
|
||||
using moeoNormalizedDistance < MOEOT > :: bounds;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOMANHATTANDISTANCE_H_*/
|
||||
|
|
@ -1,112 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoNormalizedDistance.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEONORMALIZEDDISTANCE_H_
|
||||
#define MOEONORMALIZEDDISTANCE_H_
|
||||
|
||||
#include <vector>
|
||||
#include <utils/eoRealBounds.h>
|
||||
#include <distance/moeoDistance.h>
|
||||
|
||||
/**
|
||||
* The base class for double distance computation with normalized objective values (i.e. between 0 and 1).
|
||||
*/
|
||||
template < class MOEOT , class Type = double >
|
||||
class moeoNormalizedDistance : public moeoDistance < MOEOT , Type >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Default ctr
|
||||
*/
|
||||
moeoNormalizedDistance()
|
||||
{
|
||||
bounds.resize(ObjectiveVector::Traits::nObjectives());
|
||||
// initialize bounds in case someone does not want to use them
|
||||
for (unsigned int i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
|
||||
{
|
||||
bounds[i] = eoRealInterval(0,1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns a very small value that can be used to avoid extreme cases (where the min bound == the max bound)
|
||||
*/
|
||||
static double tiny()
|
||||
{
|
||||
return 1e-6;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the lower and the upper bounds for every objective using extremes values for solutions contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void setup(const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
double min, max;
|
||||
for (unsigned int i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
|
||||
{
|
||||
min = _pop[0].objectiveVector()[i];
|
||||
max = _pop[0].objectiveVector()[i];
|
||||
for (unsigned int j=1; j<_pop.size(); j++)
|
||||
{
|
||||
min = std::min(min, _pop[j].objectiveVector()[i]);
|
||||
max = std::max(max, _pop[j].objectiveVector()[i]);
|
||||
}
|
||||
// setting of the bounds for the objective i
|
||||
setup(min, max, i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the lower bound (_min) and the upper bound (_max) for the objective _obj
|
||||
* @param _min lower bound
|
||||
* @param _max upper bound
|
||||
* @param _obj the objective index
|
||||
*/
|
||||
virtual void setup(double _min, double _max, unsigned int _obj)
|
||||
{
|
||||
if (_min == _max)
|
||||
{
|
||||
_min -= tiny();
|
||||
_max += tiny();
|
||||
}
|
||||
bounds[_obj] = eoRealInterval(_min, _max);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the lower bound and the upper bound for the objective _obj using a eoRealInterval object
|
||||
* @param _realInterval the eoRealInterval object
|
||||
* @param _obj the objective index
|
||||
*/
|
||||
virtual void setup(eoRealInterval _realInterval, unsigned int _obj)
|
||||
{
|
||||
bounds[_obj] = _realInterval;
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the bounds for every objective (bounds[i] = bounds for the objective i) */
|
||||
std::vector < eoRealInterval > bounds;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEONORMALIZEDDISTANCE_H_*/
|
||||
|
|
@ -1,122 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoCrowdingDistanceDiversityAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_
|
||||
#define MOEOCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_
|
||||
|
||||
#include <eoPop.h>
|
||||
#include <comparator/moeoOneObjectiveComparator.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
|
||||
/**
|
||||
* Diversity assignment sheme based on crowding distance proposed in:
|
||||
* K. Deb, A. Pratap, S. Agarwal, T. Meyarivan, "A Fast and Elitist Multi-Objective Genetic Algorithm: NSGA-II", IEEE Transactions on Evolutionary Computation, vol. 6, no. 2 (2002).
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoCrowdingDistanceDiversityAssignment : public moeoDiversityAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Returns a big value (regarded as infinite)
|
||||
*/
|
||||
double inf() const
|
||||
{
|
||||
return std::numeric_limits<double>::max();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns a very small value that can be used to avoid extreme cases (where the min bound == the max bound)
|
||||
*/
|
||||
double tiny() const
|
||||
{
|
||||
return 1e-6;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Computes diversity values for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator()(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
if (_pop.size() <= 2)
|
||||
{
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
_pop[i].diversity(inf());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
setDistances(_pop);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
* Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
std::cout << "WARNING : updateByDeleting not implemented in moeoCrowdingDiversityAssignment" << std::endl;
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/**
|
||||
* Sets the distance values
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void setDistances (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
double min, max, distance;
|
||||
unsigned int nObjectives = MOEOT::ObjectiveVector::nObjectives();
|
||||
// set diversity to 0
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
_pop[i].diversity(0);
|
||||
}
|
||||
// for each objective
|
||||
for (unsigned int obj=0; obj<nObjectives; obj++)
|
||||
{
|
||||
// comparator
|
||||
moeoOneObjectiveComparator < MOEOT > objComp(obj);
|
||||
// sort
|
||||
std::sort(_pop.begin(), _pop.end(), objComp);
|
||||
// min & max
|
||||
min = _pop[0].objectiveVector()[obj];
|
||||
max = _pop[_pop.size()-1].objectiveVector()[obj];
|
||||
// set the diversity value to infiny for min and max
|
||||
_pop[0].diversity(inf());
|
||||
_pop[_pop.size()-1].diversity(inf());
|
||||
for (unsigned int i=1; i<_pop.size()-1; i++)
|
||||
{
|
||||
distance = (_pop[i+1].objectiveVector()[obj] - _pop[i-1].objectiveVector()[obj]) / (max-min);
|
||||
_pop[i].diversity(_pop[i].diversity() + distance);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_*/
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoDiversityAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEODIVERSITYASSIGNMENT_H_
|
||||
#define MOEODIVERSITYASSIGNMENT_H_
|
||||
|
||||
#include <eoFunctor.h>
|
||||
#include <eoPop.h>
|
||||
|
||||
/**
|
||||
* Functor that sets the diversity values of a whole population.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoDiversityAssignment : public eoUF < eoPop < MOEOT > &, void >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type for objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
virtual void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) = 0;
|
||||
|
||||
|
||||
/**
|
||||
* Updates the diversity values of the whole population _pop by taking the deletion of the individual _moeo into account.
|
||||
* @param _pop the population
|
||||
* @param _moeo the individual
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, MOEOT & _moeo)
|
||||
{
|
||||
updateByDeleting(_pop, _moeo.objectiveVector());
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEODIVERSITYASSIGNMENT_H_*/
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoDummyDiversityAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEODUMMYDIVERSITYASSIGNMENT_H_
|
||||
#define MOEODUMMYDIVERSITYASSIGNMENT_H_
|
||||
|
||||
#include<diversity/moeoDiversityAssignment.h>
|
||||
|
||||
/**
|
||||
* moeoDummyDiversityAssignment is a moeoDiversityAssignment that gives the value '0' as the individual's diversity for a whole population if it is invalid.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoDummyDiversityAssignment : public moeoDiversityAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type for objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Sets the diversity to '0' for every individuals of the population _pop if it is invalid
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator () (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
for (unsigned int idx = 0; idx<_pop.size (); idx++)
|
||||
{
|
||||
if (_pop[idx].invalidDiversity())
|
||||
{
|
||||
// set the diversity to 0
|
||||
_pop[idx].diversity(0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
// nothing to do... ;-)
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEODUMMYDIVERSITYASSIGNMENT_H_*/
|
||||
|
|
@ -1,133 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoFrontByFrontCrowdingDistanceDiversityAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOFRONTBYFRONTCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_
|
||||
#define MOEOFRONTBYFRONTCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_
|
||||
|
||||
#include <diversity/moeoCrowdingDistanceDiversityAssignment.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
|
||||
/**
|
||||
* Diversity assignment sheme based on crowding distance proposed in:
|
||||
* K. Deb, A. Pratap, S. Agarwal, T. Meyarivan, "A Fast and Elitist Multi-Objective Genetic Algorithm: NSGA-II", IEEE Transactions on Evolutionary Computation, vol. 6, no. 2 (2002).
|
||||
* Tis strategy assigns diversity values FRONT BY FRONT. It is, for instance, used in NSGA-II.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoFrontByFrontCrowdingDistanceDiversityAssignment : public moeoCrowdingDistanceDiversityAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
* Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
std::cout << "WARNING : updateByDeleting not implemented in moeoFrontByFrontCrowdingDistanceDiversityAssignment" << std::endl;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
using moeoCrowdingDistanceDiversityAssignment < MOEOT >::inf;
|
||||
using moeoCrowdingDistanceDiversityAssignment < MOEOT >::tiny;
|
||||
|
||||
/**
|
||||
* Sets the distance values
|
||||
* @param _pop the population
|
||||
*/
|
||||
void setDistances (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
unsigned int a,b;
|
||||
double min, max, distance;
|
||||
unsigned int nObjectives = MOEOT::ObjectiveVector::nObjectives();
|
||||
// set diversity to 0 for every individual
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
_pop[i].diversity(0.0);
|
||||
}
|
||||
// sort the whole pop according to fitness values
|
||||
moeoFitnessThenDiversityComparator < MOEOT > fitnessComparator;
|
||||
std::sort(_pop.begin(), _pop.end(), fitnessComparator);
|
||||
// compute the crowding distance values for every individual "front" by "front" (front : from a to b)
|
||||
a = 0; // the front starts at a
|
||||
while (a < _pop.size())
|
||||
{
|
||||
b = lastIndex(_pop,a); // the front ends at b
|
||||
// if there is less than 2 individuals in the front...
|
||||
if ((b-a) < 2)
|
||||
{
|
||||
for (unsigned int i=a; i<=b; i++)
|
||||
{
|
||||
_pop[i].diversity(inf());
|
||||
}
|
||||
}
|
||||
// else...
|
||||
else
|
||||
{
|
||||
// for each objective
|
||||
for (unsigned int obj=0; obj<nObjectives; obj++)
|
||||
{
|
||||
// sort in the descending order using the values of the objective 'obj'
|
||||
moeoOneObjectiveComparator < MOEOT > objComp(obj);
|
||||
std::sort(_pop.begin()+a, _pop.begin()+b+1, objComp);
|
||||
// min & max
|
||||
min = _pop[b].objectiveVector()[obj];
|
||||
max = _pop[a].objectiveVector()[obj];
|
||||
// avoid extreme case
|
||||
if (min == max)
|
||||
{
|
||||
min -= tiny();
|
||||
max += tiny();
|
||||
}
|
||||
// set the diversity value to infiny for min and max
|
||||
_pop[a].diversity(inf());
|
||||
_pop[b].diversity(inf());
|
||||
// set the diversity values for the other individuals
|
||||
for (unsigned int i=a+1; i<b; i++)
|
||||
{
|
||||
distance = (_pop[i-1].objectiveVector()[obj] - _pop[i+1].objectiveVector()[obj]) / (max-min);
|
||||
_pop[i].diversity(_pop[i].diversity() + distance);
|
||||
}
|
||||
}
|
||||
}
|
||||
// go to the next front
|
||||
a = b+1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the index of the last individual having the same fitness value than _pop[_start]
|
||||
* @param _pop the population
|
||||
* @param _start the index to start from
|
||||
*/
|
||||
unsigned int lastIndex (eoPop < MOEOT > & _pop, unsigned int _start)
|
||||
{
|
||||
unsigned int i=_start;
|
||||
while ( (i<_pop.size()-1) && (_pop[i].fitness()==_pop[i+1].fitness()) )
|
||||
{
|
||||
i++;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOFRONTBYFRONTCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_*/
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoFrontByFrontSharingDiversityAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOFRONTBYFRONTSHARINGDIVERSITYASSIGNMENT_H_
|
||||
#define MOEOFRONTBYFRONTSHARINGDIVERSITYASSIGNMENT_H_
|
||||
|
||||
#include <diversity/moeoSharingDiversityAssignment.h>
|
||||
|
||||
/**
|
||||
* Sharing assignment scheme on the way it is used in NSGA.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoFrontByFrontSharingDiversityAssignment : public moeoSharingDiversityAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _distance the distance used to compute the neighborhood of solutions (can be related to the decision space or the objective space)
|
||||
* @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed)
|
||||
* @param _alpha parameter used to regulate the shape of the sharing function
|
||||
*/
|
||||
moeoFrontByFrontSharingDiversityAssignment(moeoDistance<MOEOT,double> & _distance, double _nicheSize = 0.5, double _alpha = 2.0) : moeoSharingDiversityAssignment < MOEOT >(_distance, _nicheSize, _alpha)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with an euclidean distance (with normalized objective values) in the objective space is used as default
|
||||
* @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed)
|
||||
* @param _alpha parameter used to regulate the shape of the sharing function
|
||||
*/
|
||||
moeoFrontByFrontSharingDiversityAssignment(double _nicheSize = 0.5, double _alpha = 2.0) : moeoSharingDiversityAssignment < MOEOT >(_nicheSize, _alpha)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
* Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
std::cout << "WARNING : updateByDeleting not implemented in moeoSharingDiversityAssignment" << std::endl;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
using moeoSharingDiversityAssignment < MOEOT >::distance;
|
||||
using moeoSharingDiversityAssignment < MOEOT >::nicheSize;
|
||||
using moeoSharingDiversityAssignment < MOEOT >::sh;
|
||||
using moeoSharingDiversityAssignment < MOEOT >::operator();
|
||||
|
||||
|
||||
/**
|
||||
* Sets similarities FRONT BY FRONT for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void setSimilarities(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// compute distances between every individuals
|
||||
moeoDistanceMatrix < MOEOT , double > dMatrix (_pop.size(), distance);
|
||||
dMatrix(_pop);
|
||||
// sets the distance to bigger than the niche size for every couple of solutions that do not belong to the same front
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
for (unsigned int j=0; j<i; j++)
|
||||
{
|
||||
if (_pop[i].fitness() != _pop[j].fitness())
|
||||
{
|
||||
dMatrix[i][j] = nicheSize;
|
||||
dMatrix[j][i] = nicheSize;
|
||||
}
|
||||
}
|
||||
}
|
||||
// compute similarities
|
||||
double sum;
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
sum = 0.0;
|
||||
for (unsigned int j=0; j<_pop.size(); j++)
|
||||
{
|
||||
sum += sh(dMatrix[i][j]);
|
||||
}
|
||||
_pop[i].diversity(sum);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOFRONTBYFRONTSHARINGDIVERSITYASSIGNMENT_H_*/
|
||||
|
|
@ -1,142 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoSharingDiversityAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOSHARINGDIVERSITYASSIGNMENT_H_
|
||||
#define MOEOSHARINGDIVERSITYASSIGNMENT_H_
|
||||
|
||||
#include <eoPop.h>
|
||||
#include <comparator/moeoDiversityThenFitnessComparator.h>
|
||||
#include <distance/moeoDistance.h>
|
||||
#include <distance/moeoDistanceMatrix.h>
|
||||
#include <distance/moeoEuclideanDistance.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
|
||||
/**
|
||||
* Sharing assignment scheme originally porposed by:
|
||||
* D. E. Goldberg, "Genetic Algorithms in Search, Optimization and Machine Learning", Addision-Wesley, MA, USA (1989).
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoSharingDiversityAssignment : public moeoDiversityAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _distance the distance used to compute the neighborhood of solutions (can be related to the decision space or the objective space)
|
||||
* @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed)
|
||||
* @param _alpha parameter used to regulate the shape of the sharing function
|
||||
*/
|
||||
moeoSharingDiversityAssignment(moeoDistance<MOEOT,double> & _distance, double _nicheSize = 0.5, double _alpha = 1.0) : distance(_distance), nicheSize(_nicheSize), alpha(_alpha)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with an euclidean distance (with normalized objective values) in the objective space is used as default
|
||||
* @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed)
|
||||
* @param _alpha parameter used to regulate the shape of the sharing function
|
||||
*/
|
||||
moeoSharingDiversityAssignment(double _nicheSize = 0.5, double _alpha = 1.0) : distance(defaultDistance), nicheSize(_nicheSize), alpha(_alpha)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Sets diversity values for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator()(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// 1 - set simuilarities
|
||||
setSimilarities(_pop);
|
||||
// 2 - a higher diversity is better, so the values need to be inverted
|
||||
moeoDiversityThenFitnessComparator < MOEOT > divComparator;
|
||||
double max = std::max_element(_pop.begin(), _pop.end(), divComparator)->diversity();
|
||||
for (unsigned int i=0 ; i<_pop.size() ; i++)
|
||||
{
|
||||
_pop[i].diversity(max - _pop[i].diversity());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
* Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
* @warning NOT IMPLEMENTED, DO NOTHING !
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
std::cout << "WARNING : updateByDeleting not implemented in moeoSharingDiversityAssignment" << std::endl;
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the distance used to compute the neighborhood of solutions */
|
||||
moeoDistance < MOEOT , double > & distance;
|
||||
/** euclidean distancein the objective space (can be used as default) */
|
||||
moeoEuclideanDistance < MOEOT > defaultDistance;
|
||||
/** neighborhood size in terms of radius distance */
|
||||
double nicheSize;
|
||||
/** parameter used to regulate the shape of the sharing function */
|
||||
double alpha;
|
||||
|
||||
|
||||
/**
|
||||
* Sets similarities for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void setSimilarities(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// compute distances between every individuals
|
||||
moeoDistanceMatrix < MOEOT , double > dMatrix (_pop.size(), distance);
|
||||
dMatrix(_pop);
|
||||
// compute similarities
|
||||
double sum;
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
sum = 0.0;
|
||||
for (unsigned int j=0; j<_pop.size(); j++)
|
||||
{
|
||||
sum += sh(dMatrix[i][j]);
|
||||
}
|
||||
_pop[i].diversity(sum);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sharing function
|
||||
* @param _dist the distance value
|
||||
*/
|
||||
double sh(double _dist)
|
||||
{
|
||||
double result;
|
||||
if (_dist < nicheSize)
|
||||
{
|
||||
result = 1.0 - pow(_dist / nicheSize, alpha);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = 0.0;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
#endif /*MOEOSHARINGDIVERSITYASSIGNMENT_H_*/
|
||||
|
|
@ -1,176 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// make_checkpoint_moeo.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MAKE_CHECKPOINT_MOEO_H_
|
||||
#define MAKE_CHECKPOINT_MOEO_H_
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <sstream>
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFuncCounter.h>
|
||||
#include <utils/checkpointing>
|
||||
#include <utils/selectors.h>
|
||||
#include <utils/eoParser.h>
|
||||
#include <utils/eoState.h>
|
||||
#include <metric/moeoContributionMetric.h>
|
||||
#include <metric/moeoEntropyMetric.h>
|
||||
#include <utils/moeoArchiveUpdater.h>
|
||||
#include <utils/moeoArchiveObjectiveVectorSavingUpdater.h>
|
||||
#include <utils/moeoBinaryMetricSavingUpdater.h>
|
||||
|
||||
bool testDirRes(std::string _dirName, bool _erase);
|
||||
|
||||
/**
|
||||
* This functions allows to build an eoCheckPoint for multi-objective optimization from the parser (partly taken from make_checkpoint_pareto.h)
|
||||
* @param _parser the parser
|
||||
* @param _state to store allocated objects
|
||||
* @param _eval the funtions evaluator
|
||||
* @param _continue the stopping crietria
|
||||
* @param _pop the population
|
||||
* @param _archive the archive of non-dominated solutions
|
||||
*/
|
||||
template < class MOEOT >
|
||||
eoCheckPoint < MOEOT > & do_make_checkpoint_moeo (eoParser & _parser, eoState & _state, eoEvalFuncCounter < MOEOT > & _eval, eoContinue < MOEOT > & _continue, eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _archive)
|
||||
{
|
||||
eoCheckPoint < MOEOT > & checkpoint = _state.storeFunctor(new eoCheckPoint < MOEOT > (_continue));
|
||||
/* the objective vector type */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
///////////////////
|
||||
// Counters
|
||||
//////////////////
|
||||
// is nb Eval to be used as counter?
|
||||
//bool useEval = _parser.getORcreateParam(true, "useEval", "Use nb of eval. as counter (vs nb of gen.)", '\0', "Output").value();
|
||||
// Create anyway a generation-counter parameter
|
||||
eoValueParam<unsigned int> *generationCounter = new eoValueParam<unsigned int>(0, "Gen.");
|
||||
// Create an incrementor (sub-class of eoUpdater).
|
||||
eoIncrementor<unsigned int> & increment = _state.storeFunctor( new eoIncrementor<unsigned int>(generationCounter->value()) );
|
||||
// Add it to the checkpoint
|
||||
checkpoint.add(increment);
|
||||
// dir for DISK output
|
||||
std::string & dirName = _parser.getORcreateParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output").value();
|
||||
// shoudl we empty it if exists
|
||||
eoValueParam<bool>& eraseParam = _parser.getORcreateParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output");
|
||||
bool dirOK = false; // not tested yet
|
||||
|
||||
// Dump of the whole population
|
||||
//-----------------------------
|
||||
bool printPop = _parser.getORcreateParam(false, "printPop", "Print sorted pop. every gen.", '\0', "Output").value();
|
||||
eoSortedPopStat<MOEOT> * popStat;
|
||||
if ( printPop ) // we do want pop dump
|
||||
{
|
||||
popStat = & _state.storeFunctor(new eoSortedPopStat<MOEOT>);
|
||||
checkpoint.add(*popStat);
|
||||
}
|
||||
|
||||
//////////////////////////////////
|
||||
// State savers
|
||||
//////////////////////////////
|
||||
// feed the state to state savers
|
||||
// save state every N generation
|
||||
eoValueParam<unsigned int>& saveFrequencyParam = _parser.createParam((unsigned int)(0), "saveFrequency", "Save every F generation (0 = only final state, absent = never)", '\0', "Persistence" );
|
||||
if (_parser.isItThere(saveFrequencyParam))
|
||||
{
|
||||
// first make sure dirName is OK
|
||||
if (! dirOK )
|
||||
dirOK = testDirRes(dirName, eraseParam.value()); // TRUE
|
||||
unsigned int freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX );
|
||||
#ifdef _MSVC
|
||||
std::string stmp = dirName + "\generations";
|
||||
#else
|
||||
std::string stmp = dirName + "/generations";
|
||||
#endif
|
||||
eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp);
|
||||
_state.storeFunctor(stateSaver1);
|
||||
checkpoint.add(*stateSaver1);
|
||||
}
|
||||
// save state every T seconds
|
||||
eoValueParam<unsigned int>& saveTimeIntervalParam = _parser.getORcreateParam((unsigned int)(0), "saveTimeInterval", "Save every T seconds (0 or absent = never)", '\0',"Persistence" );
|
||||
if (_parser.isItThere(saveTimeIntervalParam) && saveTimeIntervalParam.value()>0)
|
||||
{
|
||||
// first make sure dirName is OK
|
||||
if (! dirOK )
|
||||
dirOK = testDirRes(dirName, eraseParam.value()); // TRUE
|
||||
#ifdef _MSVC
|
||||
std::string stmp = dirName + "\time";
|
||||
#else
|
||||
std::string stmp = dirName + "/time";
|
||||
#endif
|
||||
eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp);
|
||||
_state.storeFunctor(stateSaver2);
|
||||
checkpoint.add(*stateSaver2);
|
||||
}
|
||||
|
||||
///////////////////
|
||||
// Archive
|
||||
//////////////////
|
||||
// update the archive every generation
|
||||
bool updateArch = _parser.getORcreateParam(true, "updateArch", "Update the archive at each gen.", '\0', "Evolution Engine").value();
|
||||
if (updateArch)
|
||||
{
|
||||
moeoArchiveUpdater < MOEOT > * updater = new moeoArchiveUpdater < MOEOT > (_archive, _pop);
|
||||
_state.storeFunctor(updater);
|
||||
checkpoint.add(*updater);
|
||||
}
|
||||
// store the objective vectors contained in the archive every generation
|
||||
bool storeArch = _parser.getORcreateParam(false, "storeArch", "Store the archive's objective vectors at each gen.", '\0', "Output").value();
|
||||
if (storeArch)
|
||||
{
|
||||
if (! dirOK )
|
||||
dirOK = testDirRes(dirName, eraseParam.value()); // TRUE
|
||||
#ifdef _MSVC
|
||||
std::string stmp = dirName + "\arch";
|
||||
#else
|
||||
std::string stmp = dirName + "/arch";
|
||||
#endif
|
||||
moeoArchiveObjectiveVectorSavingUpdater < MOEOT > * save_updater = new moeoArchiveObjectiveVectorSavingUpdater < MOEOT > (_archive, stmp);
|
||||
_state.storeFunctor(save_updater);
|
||||
checkpoint.add(*save_updater);
|
||||
}
|
||||
// store the contribution of the non-dominated solutions
|
||||
bool cont = _parser.getORcreateParam(false, "contribution", "Store the contribution of the archive at each gen.", '\0', "Output").value();
|
||||
if (cont)
|
||||
{
|
||||
if (! dirOK )
|
||||
dirOK = testDirRes(dirName, eraseParam.value()); // TRUE
|
||||
#ifdef _MSVC
|
||||
std::string stmp = dirName + "\contribution";
|
||||
#else
|
||||
std::string stmp = dirName + "/contribution";
|
||||
#endif
|
||||
moeoContributionMetric < ObjectiveVector > * contribution = new moeoContributionMetric < ObjectiveVector >;
|
||||
moeoBinaryMetricSavingUpdater < MOEOT > * contribution_updater = new moeoBinaryMetricSavingUpdater < MOEOT > (*contribution, _archive, stmp);
|
||||
_state.storeFunctor(contribution_updater);
|
||||
checkpoint.add(*contribution_updater);
|
||||
}
|
||||
// store the entropy of the non-dominated solutions
|
||||
bool ent = _parser.getORcreateParam(false, "entropy", "Store the entropy of the archive at each gen.", '\0', "Output").value();
|
||||
if (ent)
|
||||
{
|
||||
if (! dirOK )
|
||||
dirOK = testDirRes(dirName, eraseParam.value()); // TRUE
|
||||
#ifdef _MSVC
|
||||
std::string stmp = dirName + "\entropy";
|
||||
#else
|
||||
std::string stmp = dirName + "/entropy";
|
||||
#endif
|
||||
moeoEntropyMetric < ObjectiveVector > * entropy = new moeoEntropyMetric < ObjectiveVector >;
|
||||
moeoBinaryMetricSavingUpdater < MOEOT > * entropy_updater = new moeoBinaryMetricSavingUpdater < MOEOT > (*entropy, _archive, stmp);
|
||||
_state.storeFunctor(entropy_updater);
|
||||
checkpoint.add(*entropy_updater);
|
||||
}
|
||||
|
||||
// and that's it for the (control and) output
|
||||
return checkpoint;
|
||||
}
|
||||
|
||||
#endif /*MAKE_CHECKPOINT_MOEO_H_*/
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// make_continue_moeo.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MAKE_CONTINUE_MOEO_H_
|
||||
#define MAKE_CONTINUE_MOEO_H_
|
||||
|
||||
#include <eoCombinedContinue.h>
|
||||
#include <eoGenContinue.h>
|
||||
#include <eoEvalContinue.h>
|
||||
#include <eoFitContinue.h>
|
||||
#include <eoTimeContinue.h>
|
||||
#ifndef _MSC_VER
|
||||
#include <eoCtrlCContinue.h>
|
||||
#endif
|
||||
#include <utils/eoParser.h>
|
||||
#include <utils/eoState.h>
|
||||
|
||||
|
||||
/**
|
||||
* Helper function
|
||||
* @param _combined the eoCombinedContinue object
|
||||
* @param _cont the eoContinue to add
|
||||
*/
|
||||
template <class MOEOT>
|
||||
eoCombinedContinue<MOEOT> * make_combinedContinue(eoCombinedContinue<MOEOT> *_combined, eoContinue<MOEOT> *_cont)
|
||||
{
|
||||
if (_combined) // already exists
|
||||
_combined->add(*_cont);
|
||||
else
|
||||
_combined = new eoCombinedContinue<MOEOT>(*_cont);
|
||||
return _combined;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* This functions allows to build a eoContinue for multi-objective optimization from the parser (partly taken from make_continue_pareto.h)
|
||||
* @param _parser the parser
|
||||
* @param _state to store allocated objects
|
||||
* @param _eval the funtions evaluator
|
||||
*/
|
||||
template <class MOEOT>
|
||||
eoContinue<MOEOT> & do_make_continue_moeo(eoParser& _parser, eoState& _state, eoEvalFuncCounter<MOEOT> & _eval)
|
||||
{
|
||||
// the combined continue - to be filled
|
||||
eoCombinedContinue<MOEOT> *continuator = NULL;
|
||||
// First the eoGenContinue - need a default value so you can run blind
|
||||
// but we also need to be able to avoid it <--> 0
|
||||
eoValueParam<unsigned int>& maxGenParam = _parser.createParam((unsigned int)(100), "maxGen", "Maximum number of generations (0 = none)",'G',"Stopping criterion");
|
||||
if (maxGenParam.value()) // positive: -> define and store
|
||||
{
|
||||
eoGenContinue<MOEOT> *genCont = new eoGenContinue<MOEOT>(maxGenParam.value());
|
||||
_state.storeFunctor(genCont);
|
||||
// and "add" to combined
|
||||
continuator = make_combinedContinue<MOEOT>(continuator, genCont);
|
||||
}
|
||||
// maxEval
|
||||
eoValueParam<unsigned long>& maxEvalParam = _parser.getORcreateParam((unsigned long)(0), "maxEval", "Maximum number of evaluations (0 = none)", 'E', "Stopping criterion");
|
||||
if (maxEvalParam.value())
|
||||
{
|
||||
eoEvalContinue<MOEOT> *evalCont = new eoEvalContinue<MOEOT>(_eval, maxEvalParam.value());
|
||||
_state.storeFunctor(evalCont);
|
||||
// and "add" to combined
|
||||
continuator = make_combinedContinue<MOEOT>(continuator, evalCont);
|
||||
}
|
||||
// maxTime
|
||||
eoValueParam<unsigned long>& maxTimeParam = _parser.getORcreateParam((unsigned long)(0), "maxTime", "Maximum running time in seconds (0 = none)", 'T', "Stopping criterion");
|
||||
if (maxTimeParam.value()) // positive: -> define and store
|
||||
{
|
||||
eoTimeContinue<MOEOT> *timeCont = new eoTimeContinue<MOEOT>(maxTimeParam.value());
|
||||
_state.storeFunctor(timeCont);
|
||||
// and "add" to combined
|
||||
continuator = make_combinedContinue<MOEOT>(continuator, timeCont);
|
||||
}
|
||||
// CtrlC
|
||||
#ifndef _MSC_VER
|
||||
// the CtrlC interception (Linux only I'm afraid)
|
||||
eoCtrlCContinue<MOEOT> *ctrlCCont;
|
||||
eoValueParam<bool>& ctrlCParam = _parser.createParam(true, "CtrlC", "Terminate current generation upon Ctrl C",'C', "Stopping criterion");
|
||||
if (_parser.isItThere(ctrlCParam))
|
||||
{
|
||||
ctrlCCont = new eoCtrlCContinue<MOEOT>;
|
||||
// store
|
||||
_state.storeFunctor(ctrlCCont);
|
||||
// add to combinedContinue
|
||||
continuator = make_combinedContinue<MOEOT>(continuator, ctrlCCont);
|
||||
}
|
||||
#endif
|
||||
// now check that there is at least one!
|
||||
if (!continuator)
|
||||
throw std::runtime_error("You MUST provide a stopping criterion");
|
||||
// OK, it's there: store in the eoState
|
||||
_state.storeFunctor(continuator);
|
||||
// and return
|
||||
return *continuator;
|
||||
}
|
||||
|
||||
#endif /*MAKE_CONTINUE_MOEO_H_*/
|
||||
|
|
@ -1,272 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// make_ea_moeo.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MAKE_EA_MOEO_H_
|
||||
#define MAKE_EA_MOEO_H_
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoGeneralBreeder.h>
|
||||
#include <eoGenOp.h>
|
||||
#include <utils/eoParser.h>
|
||||
#include <utils/eoState.h>
|
||||
|
||||
#include <algo/moeoEA.h>
|
||||
#include <algo/moeoEasyEA.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <comparator/moeoAggregativeComparator.h>
|
||||
#include <comparator/moeoComparator.h>
|
||||
#include <comparator/moeoDiversityThenFitnessComparator.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
#include <diversity/moeoDummyDiversityAssignment.h>
|
||||
#include <diversity/moeoFrontByFrontCrowdingDistanceDiversityAssignment.h>
|
||||
#include <diversity/moeoFrontByFrontSharingDiversityAssignment.h>
|
||||
#include <fitness/moeoFastNonDominatedSortingFitnessAssignment.h>
|
||||
#include <fitness/moeoDummyFitnessAssignment.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <fitness/moeoIndicatorBasedFitnessAssignment.h>
|
||||
#include <metric/moeoAdditiveEpsilonBinaryMetric.h>
|
||||
#include <metric/moeoHypervolumeBinaryMetric.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
#include <replacement/moeoElitistReplacement.h>
|
||||
#include <replacement/moeoEnvironmentalReplacement.h>
|
||||
#include <replacement/moeoGenerationalReplacement.h>
|
||||
#include <replacement/moeoReplacement.h>
|
||||
#include <selection/moeoDetTournamentSelect.h>
|
||||
#include <selection/moeoRandomSelect.h>
|
||||
#include <selection/moeoStochTournamentSelect.h>
|
||||
#include <selection/moeoSelectOne.h>
|
||||
#include <selection/moeoSelectors.h>
|
||||
|
||||
|
||||
/**
|
||||
* This functions allows to build a moeoEA from the parser
|
||||
* @param _parser the parser
|
||||
* @param _state to store allocated objects
|
||||
* @param _eval the funtions evaluator
|
||||
* @param _continue the stopping crietria
|
||||
* @param _op the variation operators
|
||||
* @param _archive the archive of non-dominated solutions
|
||||
*/
|
||||
template < class MOEOT >
|
||||
moeoEA < MOEOT > & do_make_ea_moeo(eoParser & _parser, eoState & _state, eoEvalFunc < MOEOT > & _eval, eoContinue < MOEOT > & _continue, eoGenOp < MOEOT > & _op, moeoArchive < MOEOT > & _archive)
|
||||
{
|
||||
|
||||
/* the objective vector type */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/* the fitness assignment strategy */
|
||||
std::string & fitnessParam = _parser.createParam(std::string("FastNonDominatedSorting"), "fitness",
|
||||
"Fitness assignment scheme: Dummy, FastNonDominatedSorting or IndicatorBased", 'F',
|
||||
"Evolution Engine").value();
|
||||
std::string & indicatorParam = _parser.createParam(std::string("Epsilon"), "indicator",
|
||||
"Binary indicator for IndicatorBased: Epsilon, Hypervolume", 'i',
|
||||
"Evolution Engine").value();
|
||||
double rho = _parser.createParam(1.1, "rho", "reference point for the hypervolume indicator", 'r',
|
||||
"Evolution Engine").value();
|
||||
double kappa = _parser.createParam(0.05, "kappa", "Scaling factor kappa for IndicatorBased", 'k',
|
||||
"Evolution Engine").value();
|
||||
moeoFitnessAssignment < MOEOT > * fitnessAssignment;
|
||||
if (fitnessParam == std::string("Dummy"))
|
||||
{
|
||||
fitnessAssignment = new moeoDummyFitnessAssignment < MOEOT> ();
|
||||
}
|
||||
else if (fitnessParam == std::string("FastNonDominatedSorting"))
|
||||
{
|
||||
fitnessAssignment = new moeoFastNonDominatedSortingFitnessAssignment < MOEOT> ();
|
||||
}
|
||||
else if (fitnessParam == std::string("IndicatorBased"))
|
||||
{
|
||||
// metric
|
||||
moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > *metric;
|
||||
if (indicatorParam == std::string("Epsilon"))
|
||||
{
|
||||
metric = new moeoAdditiveEpsilonBinaryMetric < ObjectiveVector >;
|
||||
}
|
||||
else if (indicatorParam == std::string("Hypervolume"))
|
||||
{
|
||||
metric = new moeoHypervolumeBinaryMetric < ObjectiveVector > (rho);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid binary quality indicator: ") + indicatorParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
fitnessAssignment = new moeoIndicatorBasedFitnessAssignment < MOEOT > (*metric, kappa);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid fitness assignment strategy: ") + fitnessParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(fitnessAssignment);
|
||||
|
||||
|
||||
/* the diversity assignment strategy */
|
||||
eoValueParam<eoParamParamType> & diversityParam = _parser.createParam(eoParamParamType("Dummy"), "diversity",
|
||||
"Diversity assignment scheme: Dummy, Sharing(nicheSize) or Crowding", 'D', "Evolution Engine");
|
||||
eoParamParamType & diversityParamValue = diversityParam.value();
|
||||
moeoDiversityAssignment < MOEOT > * diversityAssignment;
|
||||
if (diversityParamValue.first == std::string("Dummy"))
|
||||
{
|
||||
diversityAssignment = new moeoDummyDiversityAssignment < MOEOT> ();
|
||||
}
|
||||
else if (diversityParamValue.first == std::string("Sharing"))
|
||||
{
|
||||
double nicheSize;
|
||||
if (!diversityParamValue.second.size()) // no parameter added
|
||||
{
|
||||
std::cerr << "WARNING, no niche size given for Sharing, using 0.5" << std::endl;
|
||||
nicheSize = 0.5;
|
||||
diversityParamValue.second.push_back(std::string("0.5"));
|
||||
}
|
||||
else
|
||||
{
|
||||
nicheSize = atoi(diversityParamValue.second[0].c_str());
|
||||
}
|
||||
diversityAssignment = new moeoFrontByFrontSharingDiversityAssignment < MOEOT> (nicheSize);
|
||||
}
|
||||
else if (diversityParamValue.first == std::string("Crowding"))
|
||||
{
|
||||
diversityAssignment = new moeoFrontByFrontCrowdingDistanceDiversityAssignment < MOEOT> ();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid diversity assignment strategy: ") + diversityParamValue.first;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(diversityAssignment);
|
||||
|
||||
|
||||
/* the comparator strategy */
|
||||
std::string & comparatorParam = _parser.createParam(std::string("FitnessThenDiversity"), "comparator",
|
||||
"Comparator scheme: FitnessThenDiversity, DiversityThenFitness or Aggregative", 'C', "Evolution Engine").value();
|
||||
moeoComparator < MOEOT > * comparator;
|
||||
if (comparatorParam == std::string("FitnessThenDiversity"))
|
||||
{
|
||||
comparator = new moeoFitnessThenDiversityComparator < MOEOT> ();
|
||||
}
|
||||
else if (comparatorParam == std::string("DiversityThenFitness"))
|
||||
{
|
||||
comparator = new moeoDiversityThenFitnessComparator < MOEOT> ();
|
||||
}
|
||||
else if (comparatorParam == std::string("Aggregative"))
|
||||
{
|
||||
comparator = new moeoAggregativeComparator < MOEOT> ();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid comparator strategy: ") + comparatorParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(comparator);
|
||||
|
||||
|
||||
/* the selection strategy */
|
||||
eoValueParam < eoParamParamType > & selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection",
|
||||
"Selection scheme: DetTour(T), StochTour(t) or Random", 'S', "Evolution Engine");
|
||||
eoParamParamType & ppSelect = selectionParam.value();
|
||||
moeoSelectOne < MOEOT > * select;
|
||||
if (ppSelect.first == std::string("DetTour"))
|
||||
{
|
||||
unsigned int tSize;
|
||||
if (!ppSelect.second.size()) // no parameter added
|
||||
{
|
||||
std::cerr << "WARNING, no parameter passed to DetTour, using 2" << std::endl;
|
||||
tSize = 2;
|
||||
// put back 2 in parameter for consistency (and status file)
|
||||
ppSelect.second.push_back(std::string("2"));
|
||||
}
|
||||
else // parameter passed by user as DetTour(T)
|
||||
{
|
||||
tSize = atoi(ppSelect.second[0].c_str());
|
||||
}
|
||||
select = new moeoDetTournamentSelect < MOEOT > (*comparator, tSize);
|
||||
}
|
||||
else if (ppSelect.first == std::string("StochTour"))
|
||||
{
|
||||
double tRate;
|
||||
if (!ppSelect.second.size()) // no parameter added
|
||||
{
|
||||
std::cerr << "WARNING, no parameter passed to StochTour, using 1" << std::endl;
|
||||
tRate = 1;
|
||||
// put back 1 in parameter for consistency (and status file)
|
||||
ppSelect.second.push_back(std::string("1"));
|
||||
}
|
||||
else // parameter passed by user as StochTour(T)
|
||||
{
|
||||
tRate = atof(ppSelect.second[0].c_str());
|
||||
}
|
||||
select = new moeoStochTournamentSelect < MOEOT > (*comparator, tRate);
|
||||
}
|
||||
/*
|
||||
else if (ppSelect.first == string("Roulette"))
|
||||
{
|
||||
// TO DO !
|
||||
// ...
|
||||
}
|
||||
*/
|
||||
else if (ppSelect.first == std::string("Random"))
|
||||
{
|
||||
select = new moeoRandomSelect <MOEOT > ();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid selection strategy: ") + ppSelect.first;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(select);
|
||||
|
||||
|
||||
/* the replacement strategy */
|
||||
std::string & replacementParam = _parser.createParam(std::string("Elitist"), "replacement",
|
||||
"Replacement scheme: Elitist, Environmental or Generational", 'R', "Evolution Engine").value();
|
||||
moeoReplacement < MOEOT > * replace;
|
||||
if (replacementParam == std::string("Elitist"))
|
||||
{
|
||||
replace = new moeoElitistReplacement < MOEOT> (*fitnessAssignment, *diversityAssignment, *comparator);
|
||||
}
|
||||
else if (replacementParam == std::string("Environmental"))
|
||||
{
|
||||
replace = new moeoEnvironmentalReplacement < MOEOT> (*fitnessAssignment, *diversityAssignment, *comparator);
|
||||
}
|
||||
else if (replacementParam == std::string("Generational"))
|
||||
{
|
||||
replace = new moeoGenerationalReplacement < MOEOT> ();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid replacement strategy: ") + replacementParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(replace);
|
||||
|
||||
|
||||
/* the number of offspring */
|
||||
eoValueParam < eoHowMany > & offspringRateParam = _parser.createParam(eoHowMany(1.0), "nbOffspring",
|
||||
"Number of offspring (percentage or absolute)", 'O', "Evolution Engine");
|
||||
|
||||
|
||||
// the general breeder
|
||||
eoGeneralBreeder < MOEOT > * breed = new eoGeneralBreeder < MOEOT > (*select, _op, offspringRateParam.value());
|
||||
_state.storeFunctor(breed);
|
||||
// the eoEasyEA
|
||||
moeoEA < MOEOT > * algo = new moeoEasyEA < MOEOT > (_continue, _eval, *breed, *replace, *fitnessAssignment, *diversityAssignment);
|
||||
_state.storeFunctor(algo);
|
||||
return *algo;
|
||||
|
||||
}
|
||||
|
||||
#endif /*MAKE_EA_MOEO_H_*/
|
||||
|
|
@ -1,120 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// make_ls_moeo.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MAKE_LS_MOEO_H_
|
||||
#define MAKE_LS_MOEO_H_
|
||||
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoGenOp.h>
|
||||
#include <utils/eoParser.h>
|
||||
#include <utils/eoState.h>
|
||||
#include <algo/moeoIBMOLS.h>
|
||||
#include <algo/moeoIteratedIBMOLS.h>
|
||||
#include <algo/moeoLS.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <fitness/moeoIndicatorBasedFitnessAssignment.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
#include <move/moeoMoveIncrEval.h>
|
||||
|
||||
/**
|
||||
* This functions allows to build a moeoLS from the parser
|
||||
* @param _parser the parser
|
||||
* @param _state to store allocated objects
|
||||
* @param _eval the funtions evaluator
|
||||
* @param _moveIncrEval the incremental evaluation
|
||||
* @param _continue the stopping crietria
|
||||
* @param _op the variation operators
|
||||
* @param _opInit the initilization operator
|
||||
* @param _moveInit the move initializer
|
||||
* @param _nextMove the move incrementor
|
||||
* @param _archive the archive of non-dominated solutions
|
||||
*/
|
||||
template < class MOEOT, class Move >
|
||||
moeoLS < MOEOT, eoPop<MOEOT> & > & do_make_ls_moeo (
|
||||
eoParser & _parser,
|
||||
eoState & _state,
|
||||
eoEvalFunc < MOEOT > & _eval,
|
||||
moeoMoveIncrEval < Move > & _moveIncrEval,
|
||||
eoContinue < MOEOT > & _continue,
|
||||
eoMonOp < MOEOT > & _op,
|
||||
eoMonOp < MOEOT > & _opInit,
|
||||
moMoveInit < Move > & _moveInit,
|
||||
moNextMove < Move > & _nextMove,
|
||||
moeoArchive < MOEOT > & _archive
|
||||
)
|
||||
{
|
||||
/* the objective vector type */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
/* the fitness assignment strategy */
|
||||
std::string & fitnessParam = _parser.getORcreateParam(std::string("IndicatorBased"), "fitness",
|
||||
"Fitness assignment strategy parameter: IndicatorBased...", 'F',
|
||||
"Evolution Engine").value();
|
||||
std::string & indicatorParam = _parser.getORcreateParam(std::string("Epsilon"), "indicator",
|
||||
"Binary indicator to use with the IndicatorBased assignment: Epsilon, Hypervolume", 'i',
|
||||
"Evolution Engine").value();
|
||||
double rho = _parser.getORcreateParam(1.1, "rho", "reference point for the hypervolume indicator",
|
||||
'r', "Evolution Engine").value();
|
||||
double kappa = _parser.getORcreateParam(0.05, "kappa", "Scaling factor kappa for IndicatorBased",
|
||||
'k', "Evolution Engine").value();
|
||||
moeoIndicatorBasedFitnessAssignment < MOEOT > * fitnessAssignment;
|
||||
if (fitnessParam == std::string("IndicatorBased"))
|
||||
{
|
||||
// metric
|
||||
moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > *metric;
|
||||
if (indicatorParam == std::string("Epsilon"))
|
||||
{
|
||||
metric = new moeoAdditiveEpsilonBinaryMetric < ObjectiveVector >;
|
||||
}
|
||||
else if (indicatorParam == std::string("Hypervolume"))
|
||||
{
|
||||
metric = new moeoHypervolumeBinaryMetric < ObjectiveVector > (rho);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid binary quality indicator: ") + indicatorParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
fitnessAssignment = new moeoIndicatorBasedFitnessAssignment < MOEOT> (*metric, kappa);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid fitness assignment strategy: ") + fitnessParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(fitnessAssignment);
|
||||
// number of iterations
|
||||
unsigned int n = _parser.getORcreateParam(1, "n", "Number of iterations for population Initialization", 'n', "Evolution Engine").value();
|
||||
// LS
|
||||
std::string & lsParam = _parser.getORcreateParam(std::string("I-IBMOLS"), "ls",
|
||||
"Local Search: IBMOLS, I-IBMOLS (Iterated-IBMOLS)...", 'L',
|
||||
"Evolution Engine").value();
|
||||
moeoLS < MOEOT, eoPop<MOEOT> & > * ls;
|
||||
if (lsParam == std::string("IBMOLS"))
|
||||
{
|
||||
ls = new moeoIBMOLS < MOEOT, Move > (_moveInit, _nextMove, _eval, _moveIncrEval, *fitnessAssignment, _continue);;
|
||||
}
|
||||
else if (lsParam == std::string("I-IBMOLS"))
|
||||
{
|
||||
ls = new moeoIteratedIBMOLS < MOEOT, Move > (_moveInit, _nextMove, _eval, _moveIncrEval, *fitnessAssignment, _continue, _op, _opInit, n);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid fitness assignment strategy: ") + fitnessParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(ls);
|
||||
// that's it !
|
||||
return *ls;
|
||||
}
|
||||
|
||||
#endif /*MAKE_LS_MOEO_H_*/
|
||||
|
|
@ -1,145 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoAchievementFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOACHIEVEMENTFITNESSASSIGNMENT_H_
|
||||
#define MOEOACHIEVEMENTFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <vector>
|
||||
#include <eoPop.h>
|
||||
#include <fitness/moeoScalarFitnessAssignment.h>
|
||||
|
||||
/**
|
||||
* Fitness assignment sheme based on the achievement scalarizing function propozed by Wiersbicki (1980).
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoAchievementFitnessAssignment : public moeoScalarFitnessAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Default ctor
|
||||
* @param _reference reference point vector
|
||||
* @param _lambdas weighted coefficients vector
|
||||
* @param _spn arbitrary small positive number (0 < _spn << 1)
|
||||
*/
|
||||
moeoAchievementFitnessAssignment(ObjectiveVector & _reference, std::vector < double > & _lambdas, double _spn=0.0001) : reference(_reference), lambdas(_lambdas), spn(_spn)
|
||||
{
|
||||
// consistency check
|
||||
if ((spn < 0.0) || (spn > 1.0))
|
||||
{
|
||||
std::cout << "Warning, the arbitrary small positive number should be > 0 and <<1, adjusted to 0.0001\n";
|
||||
spn = 0.0001;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor with default values for lambdas (1/nObjectives)
|
||||
* @param _reference reference point vector
|
||||
* @param _spn arbitrary small positive number (0 < _spn << 1)
|
||||
*/
|
||||
moeoAchievementFitnessAssignment(ObjectiveVector & _reference, double _spn=0.0001) : reference(_reference), spn(_spn)
|
||||
{
|
||||
// compute the default values for lambdas
|
||||
lambdas = std::vector < double > (ObjectiveVector::nObjectives());
|
||||
for (unsigned int i=0 ; i<lambdas.size(); i++)
|
||||
{
|
||||
lambdas[i] = 1.0 / ObjectiveVector::nObjectives();
|
||||
}
|
||||
// consistency check
|
||||
if ((spn < 0.0) || (spn > 1.0))
|
||||
{
|
||||
std::cout << "Warning, the arbitrary small positive number should be > 0 and <<1, adjusted to 0.0001\n";
|
||||
spn = 0.0001;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness values for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
virtual void operator()(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
for (unsigned int i=0; i<_pop.size() ; i++)
|
||||
{
|
||||
compute(_pop[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account (nothing to do).
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
// nothing to do ;-)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the reference point
|
||||
* @param _reference the new reference point
|
||||
*/
|
||||
void setReference(const ObjectiveVector & _reference)
|
||||
{
|
||||
reference = _reference;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the reference point */
|
||||
ObjectiveVector reference;
|
||||
/** the weighted coefficients vector */
|
||||
std::vector < double > lambdas;
|
||||
/** an arbitrary small positive number (0 < _spn << 1) */
|
||||
double spn;
|
||||
|
||||
|
||||
/**
|
||||
* Returns a big value (regarded as infinite)
|
||||
*/
|
||||
double inf() const
|
||||
{
|
||||
return std::numeric_limits<double>::max();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Computes the fitness value for a solution
|
||||
* @param _moeo the solution
|
||||
*/
|
||||
void compute(MOEOT & _moeo)
|
||||
{
|
||||
unsigned int nobj = MOEOT::ObjectiveVector::nObjectives();
|
||||
double temp;
|
||||
double min = inf();
|
||||
double sum = 0;
|
||||
for (unsigned int obj=0; obj<nobj; obj++)
|
||||
{
|
||||
temp = lambdas[obj] * (reference[obj] - _moeo.objectiveVector()[obj]);
|
||||
min = std::min(min, temp);
|
||||
sum += temp;
|
||||
}
|
||||
_moeo.fitness(min + spn*sum);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOACHIEVEMENTFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoCriterionBasedFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOCRITERIONBASEDFITNESSASSIGNMENT_H_
|
||||
#define MOEOCRITERIONBASEDFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
|
||||
/**
|
||||
* moeoCriterionBasedFitnessAssignment is a moeoFitnessAssignment for criterion-based strategies.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoCriterionBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT > {};
|
||||
|
||||
#endif /*MOEOCRITERIONBASEDFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoDummyFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEODUMMYFITNESSASSIGNMENT_H_
|
||||
#define MOEODUMMYFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
|
||||
/**
|
||||
* moeoDummyFitnessAssignment is a moeoFitnessAssignment that gives the value '0' as the individual's fitness for a whole population if it is invalid.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoDummyFitnessAssignment : public moeoFitnessAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type for objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness to '0' for every individuals of the population _pop if it is invalid
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator () (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
for (unsigned int idx = 0; idx<_pop.size (); idx++)
|
||||
{
|
||||
if (_pop[idx].invalidFitness())
|
||||
{
|
||||
// set the diversity to 0
|
||||
_pop[idx].fitness(0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
// nothing to do... ;-)
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEODUMMYFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,239 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoFastNonDominatedSortingFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_
|
||||
#define MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <vector>
|
||||
#include <eoPop.h>
|
||||
#include <comparator/moeoObjectiveObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
#include <fitness/moeoParetoBasedFitnessAssignment.h>
|
||||
|
||||
|
||||
/**
|
||||
* Fitness assignment sheme based on Pareto-dominance count proposed in:
|
||||
* N. Srinivas, K. Deb, "Multiobjective Optimization Using Nondominated Sorting in Genetic Algorithms", Evolutionary Computation vol. 2, no. 3, pp. 221-248 (1994)
|
||||
* and in:
|
||||
* K. Deb, A. Pratap, S. Agarwal, T. Meyarivan, "A Fast and Elitist Multi-Objective Genetic Algorithm: NSGA-II", IEEE Transactions on Evolutionary Computation, vol. 6, no. 2 (2002).
|
||||
* This strategy is, for instance, used in NSGA and NSGA-II.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoFastNonDominatedSortingFitnessAssignment : public moeoParetoBasedFitnessAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** the objective vector type of the solutions */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Default ctor
|
||||
*/
|
||||
moeoFastNonDominatedSortingFitnessAssignment() : comparator(paretoComparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor where you can choose your own way to compare objective vectors
|
||||
* @param _comparator the functor used to compare objective vectors
|
||||
*/
|
||||
moeoFastNonDominatedSortingFitnessAssignment(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : comparator(_comparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness values for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator()(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// number of objectives for the problem under consideration
|
||||
unsigned int nObjectives = MOEOT::ObjectiveVector::nObjectives();
|
||||
if (nObjectives == 1)
|
||||
{
|
||||
// one objective
|
||||
oneObjective(_pop);
|
||||
}
|
||||
else if (nObjectives == 2)
|
||||
{
|
||||
// two objectives (the two objectives function is still to implement)
|
||||
mObjectives(_pop);
|
||||
}
|
||||
else if (nObjectives > 2)
|
||||
{
|
||||
// more than two objectives
|
||||
mObjectives(_pop);
|
||||
}
|
||||
else
|
||||
{
|
||||
// problem with the number of objectives
|
||||
throw std::runtime_error("Problem with the number of objectives in moeoNonDominatedSortingFitnessAssignment");
|
||||
}
|
||||
// a higher fitness is better, so the values need to be inverted
|
||||
double max = _pop[0].fitness();
|
||||
for (unsigned int i=1 ; i<_pop.size() ; i++)
|
||||
{
|
||||
max = std::max(max, _pop[i].fitness());
|
||||
}
|
||||
for (unsigned int i=0 ; i<_pop.size() ; i++)
|
||||
{
|
||||
_pop[i].fitness(max - _pop[i].fitness());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
// if _pop[i] is dominated by _objVec
|
||||
if ( comparator(_pop[i].objectiveVector(), _objVec) )
|
||||
{
|
||||
_pop[i].fitness(_pop[i].fitness()+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** Functor to compare two objective vectors */
|
||||
moeoObjectiveVectorComparator < ObjectiveVector > & comparator;
|
||||
/** Functor to compare two objective vectors according to Pareto dominance relation */
|
||||
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
|
||||
/** Functor allowing to compare two solutions according to their first objective value, then their second, and so on. */
|
||||
class ObjectiveComparator : public moeoComparator < MOEOT >
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Returns true if _moeo1 < _moeo2 on the first objective, then on the second, and so on
|
||||
* @param _moeo1 the first solution
|
||||
* @param _moeo2 the second solution
|
||||
*/
|
||||
const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
return cmp(_moeo1.objectiveVector(), _moeo2.objectiveVector());
|
||||
}
|
||||
private:
|
||||
/** the corresponding comparator for objective vectors */
|
||||
moeoObjectiveObjectiveVectorComparator < ObjectiveVector > cmp;
|
||||
} objComparator;
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness values for mono-objective problems
|
||||
* @param _pop the population
|
||||
*/
|
||||
void oneObjective (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// sorts the population in the ascending order
|
||||
std::sort(_pop.begin(), _pop.end(), objComparator);
|
||||
// assign fitness values
|
||||
unsigned int rank = 1;
|
||||
_pop[_pop.size()-1].fitness(rank);
|
||||
for (unsigned int i=_pop.size()-2; i>=0; i--)
|
||||
{
|
||||
if (_pop[i].objectiveVector() != _pop[i+1].objectiveVector())
|
||||
{
|
||||
rank++;
|
||||
}
|
||||
_pop[i].fitness(rank);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness values for bi-objective problems with a complexity of O(n log n), where n stands for the population size
|
||||
* @param _pop the population
|
||||
*/
|
||||
void twoObjectives (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
//... TO DO !
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness values for problems with more than two objectives with a complexity of O(n² log n), where n stands for the population size
|
||||
* @param _pop the population
|
||||
*/
|
||||
void mObjectives (eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// S[i] = indexes of the individuals dominated by _pop[i]
|
||||
std::vector < std::vector<unsigned int> > S(_pop.size());
|
||||
// n[i] = number of individuals that dominate the individual _pop[i]
|
||||
std::vector < unsigned int > n(_pop.size(), 0);
|
||||
// fronts: F[i] = indexes of the individuals contained in the ith front
|
||||
std::vector < std::vector<unsigned int> > F(_pop.size()+2);
|
||||
// used to store the number of the first front
|
||||
F[1].reserve(_pop.size());
|
||||
for (unsigned int p=0; p<_pop.size(); p++)
|
||||
{
|
||||
for (unsigned int q=0; q<_pop.size(); q++)
|
||||
{
|
||||
// if q is dominated by p
|
||||
if ( comparator(_pop[q].objectiveVector(), _pop[p].objectiveVector()) )
|
||||
{
|
||||
// add q to the set of solutions dominated by p
|
||||
S[p].push_back(q);
|
||||
}
|
||||
// if p is dominated by q
|
||||
else if ( comparator(_pop[p].objectiveVector(), _pop[q].objectiveVector()) )
|
||||
{
|
||||
// increment the domination counter of p
|
||||
n[p]++;
|
||||
}
|
||||
}
|
||||
// if no individual dominates p
|
||||
if (n[p] == 0)
|
||||
{
|
||||
// p belongs to the first front
|
||||
_pop[p].fitness(1);
|
||||
F[1].push_back(p);
|
||||
}
|
||||
}
|
||||
// front counter
|
||||
unsigned int counter=1;
|
||||
unsigned int p,q;
|
||||
while (! F[counter].empty())
|
||||
{
|
||||
// used to store the number of the next front
|
||||
F[counter+1].reserve(_pop.size());
|
||||
for (unsigned int i=0; i<F[counter].size(); i++)
|
||||
{
|
||||
p = F[counter][i];
|
||||
for (unsigned int j=0; j<S[p].size(); j++)
|
||||
{
|
||||
q = S[p][j];
|
||||
n[q]--;
|
||||
// if no individual dominates q anymore
|
||||
if (n[q] == 0)
|
||||
{
|
||||
// q belongs to the next front
|
||||
_pop[q].fitness(counter+1);
|
||||
F[counter+1].push_back(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
counter++;
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOFITNESSASSIGNMENT_H_
|
||||
#define MOEOFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <eoFunctor.h>
|
||||
#include <eoPop.h>
|
||||
|
||||
/**
|
||||
* Functor that sets the fitness values of a whole population.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoFitnessAssignment : public eoUF < eoPop < MOEOT > &, void >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type for objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
virtual void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) = 0;
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the deletion of the individual _moeo into account.
|
||||
* @param _pop the population
|
||||
* @param _moeo the individual
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, MOEOT & _moeo)
|
||||
{
|
||||
updateByDeleting(_pop, _moeo.objectiveVector());
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,202 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoIndicatorBasedFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOINDICATORBASEDFITNESSASSIGNMENT_H_
|
||||
#define MOEOINDICATORBASEDFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
#include <eoPop.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
#include <utils/moeoConvertPopToObjectiveVectors.h>
|
||||
|
||||
/**
|
||||
* Fitness assignment sheme based an Indicator proposed in:
|
||||
* E. Zitzler, S. Künzli, "Indicator-Based Selection in Multiobjective Search", Proc. 8th International Conference on Parallel Problem Solving from Nature (PPSN VIII), pp. 832-842, Birmingham, UK (2004).
|
||||
* This strategy is, for instance, used in IBEA.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoIndicatorBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type of objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _metric the quality indicator
|
||||
* @param _kappa the scaling factor
|
||||
*/
|
||||
moeoIndicatorBasedFitnessAssignment(moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa = 0.05) : metric(_metric), kappa(_kappa)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness values for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator()(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// 1 - setting of the bounds
|
||||
setup(_pop);
|
||||
// 2 - computing every indicator values
|
||||
computeValues(_pop);
|
||||
// 3 - setting fitnesses
|
||||
setFitnesses(_pop);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
std::vector < double > v;
|
||||
v.resize(_pop.size());
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
v[i] = metric(_objVec, _pop[i].objectiveVector());
|
||||
}
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
_pop[i].fitness( _pop[i].fitness() + exp(-v[i]/kappa) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the adding of the objective vector _objVec into account
|
||||
* and returns the fitness value of _objVec.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
double updateByAdding(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
std::vector < double > v;
|
||||
// update every fitness values to take the new individual into account
|
||||
v.resize(_pop.size());
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
v[i] = metric(_objVec, _pop[i].objectiveVector());
|
||||
}
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
_pop[i].fitness( _pop[i].fitness() - exp(-v[i]/kappa) );
|
||||
}
|
||||
// compute the fitness of the new individual
|
||||
v.clear();
|
||||
v.resize(_pop.size());
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
v[i] = metric(_pop[i].objectiveVector(), _objVec);
|
||||
}
|
||||
double result = 0;
|
||||
for (unsigned int i=0; i<v.size(); i++)
|
||||
{
|
||||
result -= exp(-v[i]/kappa);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the quality indicator */
|
||||
moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & metric;
|
||||
/** the scaling factor */
|
||||
double kappa;
|
||||
/** the computed indicator values */
|
||||
std::vector < std::vector<double> > values;
|
||||
|
||||
|
||||
/**
|
||||
* Sets the bounds for every objective using the min and the max value for every objective vector of _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void setup(const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
double min, max;
|
||||
for (unsigned int i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
|
||||
{
|
||||
min = _pop[0].objectiveVector()[i];
|
||||
max = _pop[0].objectiveVector()[i];
|
||||
for (unsigned int j=1; j<_pop.size(); j++)
|
||||
{
|
||||
min = std::min(min, _pop[j].objectiveVector()[i]);
|
||||
max = std::max(max, _pop[j].objectiveVector()[i]);
|
||||
}
|
||||
// setting of the bounds for the objective i
|
||||
metric.setup(min, max, i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Compute every indicator value in values (values[i] = I(_v[i], _o))
|
||||
* @param _pop the population
|
||||
*/
|
||||
void computeValues(const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
values.clear();
|
||||
values.resize(_pop.size());
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
values[i].resize(_pop.size());
|
||||
for (unsigned int j=0; j<_pop.size(); j++)
|
||||
{
|
||||
if (i != j)
|
||||
{
|
||||
values[i][j] = metric(_pop[i].objectiveVector(), _pop[j].objectiveVector());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness value of the whple population
|
||||
* @param _pop the population
|
||||
*/
|
||||
void setFitnesses(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
_pop[i].fitness(computeFitness(i));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the fitness value of the _idx th individual of the population
|
||||
* @param _idx the index
|
||||
*/
|
||||
double computeFitness(const unsigned int _idx)
|
||||
{
|
||||
double result = 0;
|
||||
for (unsigned int i=0; i<values.size(); i++)
|
||||
{
|
||||
if (i != _idx)
|
||||
{
|
||||
result -= exp(-values[i][_idx]/kappa);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOINDICATORBASEDFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoParetoBasedFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOPARETOBASEDFITNESSASSIGNMENT_H_
|
||||
#define MOEOPARETOBASEDFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
|
||||
/**
|
||||
* moeoParetoBasedFitnessAssignment is a moeoFitnessAssignment for Pareto-based strategies.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoParetoBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT > {};
|
||||
|
||||
#endif /*MOEOPARETOBASEDFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,109 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoReferencePointIndicatorBasedFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOREFERENCEPOINTINDICATORBASEDFITNESSASSIGNMENT_H_
|
||||
#define MOEOREFERENCEPOINTINDICATORBASEDFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <math.h>
|
||||
#include <eoPop.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
|
||||
/**
|
||||
* Fitness assignment sheme based a Reference Point and a Quality Indicator.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoReferencePointIndicatorBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type of objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _refPoint the reference point
|
||||
* @param _metric the quality indicator
|
||||
*/
|
||||
moeoReferencePointIndicatorBasedFitnessAssignment (ObjectiveVector & _refPoint, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric) :
|
||||
refPoint(_refPoint), metric(_metric)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the fitness values for every solution contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void operator()(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// 1 - setting of the bounds
|
||||
setup(_pop);
|
||||
// 2 - setting fitnesses
|
||||
setFitnesses(_pop);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account.
|
||||
* @param _pop the population
|
||||
* @param _objVec the objective vector
|
||||
*/
|
||||
void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec)
|
||||
{
|
||||
// nothing to do ;-)
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the reference point */
|
||||
ObjectiveVector & refPoint;
|
||||
/** the quality indicator */
|
||||
moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & metric;
|
||||
|
||||
|
||||
/**
|
||||
* Sets the bounds for every objective using the min and the max value for every objective vector of _pop (and the reference point)
|
||||
* @param _pop the population
|
||||
*/
|
||||
void setup(const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
double min, max;
|
||||
for (unsigned int i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
|
||||
{
|
||||
min = refPoint[i];
|
||||
max = refPoint[i];
|
||||
for (unsigned int j=0; j<_pop.size(); j++)
|
||||
{
|
||||
min = std::min(min, _pop[j].objectiveVector()[i]);
|
||||
max = std::max(max, _pop[j].objectiveVector()[i]);
|
||||
}
|
||||
// setting of the bounds for the objective i
|
||||
metric.setup(min, max, i);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the fitness of every individual contained in the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
void setFitnesses(eoPop < MOEOT > & _pop)
|
||||
{
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
_pop[i].fitness(- metric(_pop[i].objectiveVector(), refPoint) );
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOREFERENCEPOINTINDICATORBASEDFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoScalarFitnessAssignment.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOSCALARFITNESSASSIGNMENT_H_
|
||||
#define MOEOSCALARFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
|
||||
/**
|
||||
* moeoScalarFitnessAssignment is a moeoFitnessAssignment for scalar strategies.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoScalarFitnessAssignment : public moeoFitnessAssignment < MOEOT > {};
|
||||
|
||||
#endif /*MOEOSCALARFITNESSASSIGNMENT_H_*/
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoAdditiveEpsilonBinaryMetric.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOADDITIVEEPSILONBINARYMETRIC_H_
|
||||
#define MOEOADDITIVEEPSILONBINARYMETRIC_H_
|
||||
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
|
||||
/**
|
||||
* Additive epsilon binary metric allowing to compare two objective vectors as proposed in
|
||||
* Zitzler E., Thiele L., Laumanns M., Fonseca C. M., Grunert da Fonseca V.:
|
||||
* Performance Assessment of Multiobjective Optimizers: An Analysis and Review. IEEE Transactions on Evolutionary Computation 7(2), pp.117–132 (2003).
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoAdditiveEpsilonBinaryMetric : public moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns the minimal distance by which the objective vector _o1 must be translated in all objectives
|
||||
* so that it weakly dominates the objective vector _o2
|
||||
* @warning don't forget to set the bounds for every objective before the call of this function
|
||||
* @param _o1 the first objective vector
|
||||
* @param _o2 the second objective vector
|
||||
*/
|
||||
double operator()(const ObjectiveVector & _o1, const ObjectiveVector & _o2)
|
||||
{
|
||||
// computation of the epsilon value for the first objective
|
||||
double result = epsilon(_o1, _o2, 0);
|
||||
// computation of the epsilon value for the other objectives
|
||||
double tmp;
|
||||
for (unsigned int i=1; i<ObjectiveVector::Traits::nObjectives(); i++)
|
||||
{
|
||||
tmp = epsilon(_o1, _o2, i);
|
||||
result = std::max(result, tmp);
|
||||
}
|
||||
// returns the maximum epsilon value
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the bounds for every objective */
|
||||
using moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > :: bounds;
|
||||
|
||||
|
||||
/**
|
||||
* Returns the epsilon value by which the objective vector _o1 must be translated in the objective _obj
|
||||
* so that it dominates the objective vector _o2
|
||||
* @param _o1 the first objective vector
|
||||
* @param _o2 the second objective vector
|
||||
* @param _obj the index of the objective
|
||||
*/
|
||||
double epsilon(const ObjectiveVector & _o1, const ObjectiveVector & _o2, const unsigned int _obj)
|
||||
{
|
||||
double result;
|
||||
// if the objective _obj have to be minimized
|
||||
if (ObjectiveVector::Traits::minimizing(_obj))
|
||||
{
|
||||
// _o1[_obj] - _o2[_obj]
|
||||
result = ( (_o1[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() ) - ( (_o2[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() );
|
||||
}
|
||||
// if the objective _obj have to be maximized
|
||||
else
|
||||
{
|
||||
// _o2[_obj] - _o1[_obj]
|
||||
result = ( (_o2[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() ) - ( (_o1[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() );
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOADDITIVEEPSILONBINARYMETRIC_H_*/
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoContributionMetric.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOCONTRIBUTIONMETRIC_H_
|
||||
#define MOEOCONTRIBUTIONMETRIC_H_
|
||||
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
#include <metric/moeoMetric.h>
|
||||
|
||||
/**
|
||||
* The contribution metric evaluates the proportion of non-dominated solutions given by a Pareto set relatively to another Pareto set
|
||||
* (Meunier, Talbi, Reininger: 'A multiobjective genetic algorithm for radio network optimization', in Proc. of the 2000 Congress on Evolutionary Computation, IEEE Press, pp. 317-324)
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoContributionMetric : public moeoVectorVsVectorBinaryMetric < ObjectiveVector, double >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns the contribution of the Pareto set '_set1' relatively to the Pareto set '_set2'
|
||||
* @param _set1 the first Pareto set
|
||||
* @param _set2 the second Pareto set
|
||||
*/
|
||||
double operator()(const std::vector < ObjectiveVector > & _set1, const std::vector < ObjectiveVector > & _set2) {
|
||||
unsigned int c = card_C(_set1, _set2);
|
||||
unsigned int w1 = card_W(_set1, _set2);
|
||||
unsigned int n1 = card_N(_set1, _set2);
|
||||
unsigned int w2 = card_W(_set2, _set1);
|
||||
unsigned int n2 = card_N(_set2, _set1);
|
||||
return (double) (c / 2.0 + w1 + n1) / (c + w1 + n1 + w2 + n2);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** Functor to compare two objective vectors according to Pareto dominance relation */
|
||||
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of solutions both in '_set1' and '_set2'
|
||||
* @param _set1 the first Pareto set
|
||||
* @param _set2 the second Pareto set
|
||||
*/
|
||||
unsigned int card_C (const std::vector < ObjectiveVector > & _set1, const std::vector < ObjectiveVector > & _set2) {
|
||||
unsigned int c=0;
|
||||
for (unsigned int i=0; i<_set1.size(); i++)
|
||||
for (unsigned int j=0; j<_set2.size(); j++)
|
||||
if (_set1[i] == _set2[j]) {
|
||||
c++;
|
||||
break;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of solutions in '_set1' dominating at least one solution of '_set2'
|
||||
* @param _set1 the first Pareto set
|
||||
* @param _set2 the second Pareto set
|
||||
*/
|
||||
unsigned int card_W (const std::vector < ObjectiveVector > & _set1, const std::vector < ObjectiveVector > & _set2) {
|
||||
unsigned int w=0;
|
||||
for (unsigned int i=0; i<_set1.size(); i++)
|
||||
for (unsigned int j=0; j<_set2.size(); j++)
|
||||
if (paretoComparator(_set2[j], _set1[i]))
|
||||
{
|
||||
w++;
|
||||
break;
|
||||
}
|
||||
return w;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of solutions in '_set1' having no relation of dominance with those from '_set2'
|
||||
* @param _set1 the first Pareto set
|
||||
* @param _set2 the second Pareto set
|
||||
*/
|
||||
unsigned int card_N (const std::vector < ObjectiveVector > & _set1, const std::vector < ObjectiveVector > & _set2) {
|
||||
unsigned int n=0;
|
||||
for (unsigned int i=0; i<_set1.size(); i++) {
|
||||
bool domin_rel = false;
|
||||
for (unsigned int j=0; j<_set2.size(); j++)
|
||||
if ( (paretoComparator(_set2[j], _set1[i])) || (paretoComparator(_set1[i], _set2[j])) )
|
||||
{
|
||||
domin_rel = true;
|
||||
break;
|
||||
}
|
||||
if (! domin_rel)
|
||||
n++;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOCONTRIBUTIONMETRIC_H_*/
|
||||
|
|
@ -1,182 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoEntropyMetric.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOENTROPYMETRIC_H_
|
||||
#define MOEOENTROPYMETRIC_H_
|
||||
|
||||
#include <vector>
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
#include <metric/moeoMetric.h>
|
||||
|
||||
/**
|
||||
* The entropy gives an idea of the diversity of a Pareto set relatively to another
|
||||
* (Basseur, Seynhaeve, Talbi: 'Design of Multi-objective Evolutionary Algorithms: Application to the Flow-shop Scheduling Problem', in Proc. of the 2002 Congress on Evolutionary Computation, IEEE Press, pp. 1155-1156)
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoEntropyMetric : public moeoVectorVsVectorBinaryMetric < ObjectiveVector, double >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns the entropy of the Pareto set '_set1' relatively to the Pareto set '_set2'
|
||||
* @param _set1 the first Pareto set
|
||||
* @param _set2 the second Pareto set
|
||||
*/
|
||||
double operator()(const std::vector < ObjectiveVector > & _set1, const std::vector < ObjectiveVector > & _set2) {
|
||||
// normalization
|
||||
std::vector< ObjectiveVector > set1 = _set1;
|
||||
std::vector< ObjectiveVector > set2= _set2;
|
||||
removeDominated (set1);
|
||||
removeDominated (set2);
|
||||
prenormalize (set1);
|
||||
normalize (set1);
|
||||
normalize (set2);
|
||||
|
||||
// making of PO*
|
||||
std::vector< ObjectiveVector > star; // rotf :-)
|
||||
computeUnion (set1, set2, star);
|
||||
removeDominated (star);
|
||||
|
||||
// making of PO1 U PO*
|
||||
std::vector< ObjectiveVector > union_set1_star; // rotf again ...
|
||||
computeUnion (set1, star, union_set1_star);
|
||||
|
||||
unsigned int C = union_set1_star.size();
|
||||
float omega=0;
|
||||
float entropy=0;
|
||||
|
||||
for (unsigned int i=0 ; i<C ; i++) {
|
||||
unsigned int N_i = howManyInNicheOf (union_set1_star, union_set1_star[i], star.size());
|
||||
unsigned int n_i = howManyInNicheOf (set1, union_set1_star[i], star.size());
|
||||
if (n_i > 0) {
|
||||
omega += 1.0 / N_i;
|
||||
entropy += (float) n_i / (N_i * C) * log (((float) n_i / C) / log (2.0));
|
||||
}
|
||||
}
|
||||
entropy /= - log (omega);
|
||||
entropy *= log (2.0);
|
||||
return entropy;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** vector of min values */
|
||||
std::vector<double> vect_min_val;
|
||||
/** vector of max values */
|
||||
std::vector<double> vect_max_val;
|
||||
/** Functor to compare two objective vectors according to Pareto dominance relation */
|
||||
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
|
||||
|
||||
|
||||
/**
|
||||
* Removes the dominated individuals contained in _f
|
||||
* @param _f a Pareto set
|
||||
*/
|
||||
void removeDominated(std::vector < ObjectiveVector > & _f) {
|
||||
for (unsigned int i=0 ; i<_f.size(); i++) {
|
||||
bool dom = false;
|
||||
for (unsigned int j=0; j<_f.size(); j++)
|
||||
if (i != j && paretoComparator(_f[i],_f[j]))
|
||||
{
|
||||
dom = true;
|
||||
break;
|
||||
}
|
||||
if (dom) {
|
||||
_f[i] = _f.back();
|
||||
_f.pop_back();
|
||||
i--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Prenormalization
|
||||
* @param _f a Pareto set
|
||||
*/
|
||||
void prenormalize (const std::vector< ObjectiveVector > & _f) {
|
||||
vect_min_val.clear();
|
||||
vect_max_val.clear();
|
||||
|
||||
for (unsigned int i=0 ; i<ObjectiveVector::nObjectives(); i++) {
|
||||
float min_val = _f.front()[i], max_val = min_val;
|
||||
for (unsigned int j=1 ; j<_f.size(); j++) {
|
||||
if (_f[j][i] < min_val)
|
||||
min_val = _f[j][i];
|
||||
if (_f[j][i]>max_val)
|
||||
max_val = _f[j][i];
|
||||
}
|
||||
vect_min_val.push_back(min_val);
|
||||
vect_max_val.push_back (max_val);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Normalization
|
||||
* @param _f a Pareto set
|
||||
*/
|
||||
void normalize (std::vector< ObjectiveVector > & _f) {
|
||||
for (unsigned int i=0 ; i<ObjectiveVector::nObjectives(); i++)
|
||||
for (unsigned int j=0; j<_f.size(); j++)
|
||||
_f[j][i] = (_f[j][i] - vect_min_val[i]) / (vect_max_val[i] - vect_min_val[i]);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Computation of the union of _f1 and _f2 in _f
|
||||
* @param _f1 the first Pareto set
|
||||
* @param _f2 the second Pareto set
|
||||
* @param _f the final Pareto set
|
||||
*/
|
||||
void computeUnion(const std::vector< ObjectiveVector > & _f1, const std::vector< ObjectiveVector > & _f2, std::vector< ObjectiveVector > & _f) {
|
||||
_f = _f1 ;
|
||||
for (unsigned int i=0; i<_f2.size(); i++) {
|
||||
bool b = false;
|
||||
for (unsigned int j=0; j<_f1.size(); j ++)
|
||||
if (_f1[j] == _f2[i]) {
|
||||
b = true;
|
||||
break;
|
||||
}
|
||||
if (! b)
|
||||
_f.push_back(_f2[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* How many in niche
|
||||
*/
|
||||
unsigned int howManyInNicheOf (const std::vector< ObjectiveVector > & _f, const ObjectiveVector & _s, unsigned int _size) {
|
||||
unsigned int n=0;
|
||||
for (unsigned int i=0 ; i<_f.size(); i++) {
|
||||
if (euclidianDistance(_f[i], _s) < (_s.size() / (double) _size))
|
||||
n++;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Euclidian distance
|
||||
*/
|
||||
double euclidianDistance (const ObjectiveVector & _set1, const ObjectiveVector & _to, unsigned int _deg = 2) {
|
||||
double dist=0;
|
||||
for (unsigned int i=0; i<_set1.size(); i++)
|
||||
dist += pow(fabs(_set1[i] - _to[i]), (int)_deg);
|
||||
return pow(dist, 1.0 / _deg);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOENTROPYMETRIC_H_*/
|
||||
|
|
@ -1,141 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoHypervolumeBinaryMetric.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOHYPERVOLUMEBINARYMETRIC_H_
|
||||
#define MOEOHYPERVOLUMEBINARYMETRIC_H_
|
||||
|
||||
#include <stdexcept>
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
|
||||
/**
|
||||
* Hypervolume binary metric allowing to compare two objective vectors as proposed in
|
||||
* Zitzler E., Künzli S.: Indicator-Based Selection in Multiobjective Search. In Parallel Problem Solving from Nature (PPSN VIII).
|
||||
* Lecture Notes in Computer Science 3242, Springer, Birmingham, UK pp.832–842 (2004).
|
||||
* This indicator is based on the hypervolume concept introduced in
|
||||
* Zitzler, E., Thiele, L.: Multiobjective Optimization Using Evolutionary Algorithms - A Comparative Case Study.
|
||||
* Parallel Problem Solving from Nature (PPSN-V), pp.292-301 (1998).
|
||||
*/
|
||||
template < class ObjectiveVector >
|
||||
class moeoHypervolumeBinaryMetric : public moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _rho value used to compute the reference point from the worst values for each objective (default : 1.1)
|
||||
*/
|
||||
moeoHypervolumeBinaryMetric(double _rho = 1.1) : rho(_rho)
|
||||
{
|
||||
// not-a-maximization problem check
|
||||
for (unsigned int i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
|
||||
{
|
||||
if (ObjectiveVector::Traits::maximizing(i))
|
||||
{
|
||||
throw std::runtime_error("Hypervolume binary metric not yet implemented for a maximization problem in moeoHypervolumeBinaryMetric");
|
||||
}
|
||||
}
|
||||
// consistency check
|
||||
if (rho < 1)
|
||||
{
|
||||
std::cout << "Warning, value used to compute the reference point rho for the hypervolume calculation must not be smaller than 1" << std::endl;
|
||||
std::cout << "Adjusted to 1" << std::endl;
|
||||
rho = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the volume of the space that is dominated by _o2 but not by _o1 with respect to a reference point computed using rho.
|
||||
* @warning don't forget to set the bounds for every objective before the call of this function
|
||||
* @param _o1 the first objective vector
|
||||
* @param _o2 the second objective vector
|
||||
*/
|
||||
double operator()(const ObjectiveVector & _o1, const ObjectiveVector & _o2)
|
||||
{
|
||||
double result;
|
||||
// if _o2 is dominated by _o1
|
||||
if ( paretoComparator(_o2,_o1) )
|
||||
{
|
||||
result = - hypervolume(_o1, _o2, ObjectiveVector::Traits::nObjectives()-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = hypervolume(_o2, _o1, ObjectiveVector::Traits::nObjectives()-1);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** value used to compute the reference point from the worst values for each objective */
|
||||
double rho;
|
||||
/** the bounds for every objective */
|
||||
using moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > :: bounds;
|
||||
/** Functor to compare two objective vectors according to Pareto dominance relation */
|
||||
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
|
||||
|
||||
|
||||
/**
|
||||
* Returns the volume of the space that is dominated by _o2 but not by _o1 with respect to a reference point computed using rho for the objective _obj.
|
||||
* @param _o1 the first objective vector
|
||||
* @param _o2 the second objective vector
|
||||
* @param _obj the objective index
|
||||
* @param _flag used for iteration, if _flag=true _o2 is not talen into account (default : false)
|
||||
*/
|
||||
double hypervolume(const ObjectiveVector & _o1, const ObjectiveVector & _o2, const unsigned int _obj, const bool _flag = false)
|
||||
{
|
||||
double result;
|
||||
double range = rho * bounds[_obj].range();
|
||||
double max = bounds[_obj].minimum() + range;
|
||||
// value of _1 for the objective _obj
|
||||
double v1 = _o1[_obj];
|
||||
// value of _2 for the objective _obj (if _flag=true, v2=max)
|
||||
double v2;
|
||||
if (_flag)
|
||||
{
|
||||
v2 = max;
|
||||
}
|
||||
else
|
||||
{
|
||||
v2 = _o2[_obj];
|
||||
}
|
||||
// computation of the volume
|
||||
if (_obj == 0)
|
||||
{
|
||||
if (v1 < v2)
|
||||
{
|
||||
result = (v2 - v1) / range;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (v1 < v2)
|
||||
{
|
||||
result = ( hypervolume(_o1, _o2, _obj-1, true) * (v2 - v1) / range ) + ( hypervolume(_o1, _o2, _obj-1) * (max - v2) / range );
|
||||
}
|
||||
else
|
||||
{
|
||||
result = hypervolume(_o1, _o2, _obj-1) * (max - v2) / range;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOHYPERVOLUMEBINARYMETRIC_H_*/
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoMetric.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOMETRIC_H_
|
||||
#define MOEOMETRIC_H_
|
||||
|
||||
#include <vector>
|
||||
#include <eoFunctor.h>
|
||||
|
||||
/**
|
||||
* Base class for performance metrics (also known as quality indicators).
|
||||
*/
|
||||
class moeoMetric : public eoFunctorBase {};
|
||||
|
||||
|
||||
/**
|
||||
* Base class for unary metrics.
|
||||
*/
|
||||
template < class A, class R >
|
||||
class moeoUnaryMetric : public eoUF < A, R >, public moeoMetric {};
|
||||
|
||||
|
||||
/**
|
||||
* Base class for binary metrics.
|
||||
*/
|
||||
template < class A1, class A2, class R >
|
||||
class moeoBinaryMetric : public eoBF < A1, A2, R >, public moeoMetric {};
|
||||
|
||||
|
||||
/**
|
||||
* Base class for unary metrics dedicated to the performance evaluation of a single solution's objective vector.
|
||||
*/
|
||||
template < class ObjectiveVector, class R >
|
||||
class moeoSolutionUnaryMetric : public moeoUnaryMetric < const ObjectiveVector &, R > {};
|
||||
|
||||
|
||||
/**
|
||||
* Base class for unary metrics dedicated to the performance evaluation of a Pareto set (a vector of objective vectors)
|
||||
*/
|
||||
template < class ObjectiveVector, class R >
|
||||
class moeoVectorUnaryMetric : public moeoUnaryMetric < const std::vector < ObjectiveVector > &, R > {};
|
||||
|
||||
|
||||
/**
|
||||
* Base class for binary metrics dedicated to the performance comparison between two solutions's objective vectors.
|
||||
*/
|
||||
template < class ObjectiveVector, class R >
|
||||
class moeoSolutionVsSolutionBinaryMetric : public moeoBinaryMetric < const ObjectiveVector &, const ObjectiveVector &, R > {};
|
||||
|
||||
|
||||
/**
|
||||
* Base class for binary metrics dedicated to the performance comparison between two Pareto sets (two vectors of objective vectors)
|
||||
*/
|
||||
template < class ObjectiveVector, class R >
|
||||
class moeoVectorVsVectorBinaryMetric : public moeoBinaryMetric < const std::vector < ObjectiveVector > &, const std::vector < ObjectiveVector > &, R > {};
|
||||
|
||||
|
||||
#endif /*MOEOMETRIC_H_*/
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoNormalizedSolutionVsSolutionBinaryMetric.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEONORMALIZEDSOLUTIONVSSOLUTIONBINARYMETRIC_H_
|
||||
#define MOEONORMALIZEDSOLUTIONVSSOLUTIONBINARYMETRIC_H_
|
||||
|
||||
#include <vector>
|
||||
#include <utils/eoRealBounds.h>
|
||||
#include <metric/moeoMetric.h>
|
||||
|
||||
/**
|
||||
* Base class for binary metrics dedicated to the performance comparison between two solutions's objective vectors using normalized values.
|
||||
* Then, indicator values lie in the interval [-1,1].
|
||||
* Note that you have to set the bounds for every objective before using the operator().
|
||||
*/
|
||||
template < class ObjectiveVector, class R >
|
||||
class moeoNormalizedSolutionVsSolutionBinaryMetric : public moeoSolutionVsSolutionBinaryMetric < ObjectiveVector, R >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Default ctr for any moeoNormalizedSolutionVsSolutionBinaryMetric object
|
||||
*/
|
||||
moeoNormalizedSolutionVsSolutionBinaryMetric()
|
||||
{
|
||||
bounds.resize(ObjectiveVector::Traits::nObjectives());
|
||||
// initialize bounds in case someone does not want to use them
|
||||
for (unsigned int i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
|
||||
{
|
||||
bounds[i] = eoRealInterval(0,1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the lower bound (_min) and the upper bound (_max) for the objective _obj
|
||||
* @param _min lower bound
|
||||
* @param _max upper bound
|
||||
* @param _obj the objective index
|
||||
*/
|
||||
void setup(double _min, double _max, unsigned int _obj)
|
||||
{
|
||||
if (_min == _max)
|
||||
{
|
||||
_min -= tiny();
|
||||
_max += tiny();
|
||||
}
|
||||
bounds[_obj] = eoRealInterval(_min, _max);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the lower bound and the upper bound for the objective _obj using a eoRealInterval object
|
||||
* @param _realInterval the eoRealInterval object
|
||||
* @param _obj the objective index
|
||||
*/
|
||||
virtual void setup(eoRealInterval _realInterval, unsigned int _obj)
|
||||
{
|
||||
bounds[_obj] = _realInterval;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns a very small value that can be used to avoid extreme cases (where the min bound == the max bound)
|
||||
*/
|
||||
static double tiny()
|
||||
{
|
||||
return 1e-6;
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the bounds for every objective (bounds[i] = bounds for the objective i) */
|
||||
std::vector < eoRealInterval > bounds;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEONORMALIZEDSOLUTIONVSSOLUTIONBINARYMETRIC_H_*/
|
||||
|
|
@ -1,100 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeo
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEO_
|
||||
#define MOEO_
|
||||
|
||||
#include <eo>
|
||||
|
||||
#include <algo/moeoAlgo.h>
|
||||
#include <algo/moeoCombinedLS.h>
|
||||
#include <algo/moeoEA.h>
|
||||
#include <algo/moeoEasyEA.h>
|
||||
#include <algo/moeoHybridLS.h>
|
||||
#include <algo/moeoIBEA.h>
|
||||
//#include <algo/moeoIBMOLS.h>
|
||||
//#include <algo/moeoIteratedIBMOLS.h>
|
||||
#include <algo/moeoLS.h>
|
||||
#include <algo/moeoNSGA.h>
|
||||
#include <algo/moeoNSGAII.h>
|
||||
|
||||
#include <archive/moeoArchive.h>
|
||||
|
||||
#include <comparator/moeoAggregativeComparator.h>
|
||||
#include <comparator/moeoComparator.h>
|
||||
#include <comparator/moeoDiversityThenFitnessComparator.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
#include <comparator/moeoGDominanceObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoObjectiveObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoOneObjectiveComparator.h>
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
|
||||
#include <core/MOEO.h>
|
||||
#include <core/moeoBitVector.h>
|
||||
#include <core/moeoEvalFunc.h>
|
||||
#include <core/moeoObjectiveVector.h>
|
||||
#include <core/moeoObjectiveVectorDouble.h>
|
||||
#include <core/moeoObjectiveVectorTraits.h>
|
||||
#include <core/moeoBitVector.h>
|
||||
#include <core/moeoRealVector.h>
|
||||
|
||||
#include <distance/moeoDistance.h>
|
||||
#include <distance/moeoDistanceMatrix.h>
|
||||
#include <distance/moeoEuclideanDistance.h>
|
||||
#include <distance/moeoManhattanDistance.h>
|
||||
#include <distance/moeoNormalizedDistance.h>
|
||||
|
||||
#include <diversity/moeoCrowdingDistanceDiversityAssignment.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
#include <diversity/moeoDummyDiversityAssignment.h>
|
||||
#include <diversity/moeoFrontByFrontCrowdingDistanceDiversityAssignment.h>
|
||||
#include <diversity/moeoFrontByFrontSharingDiversityAssignment.h>
|
||||
#include <diversity/moeoSharingDiversityAssignment.h>
|
||||
|
||||
#include <fitness/moeoAchievementFitnessAssignment.h>
|
||||
#include <fitness/moeoCriterionBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoDummyFitnessAssignment.h>
|
||||
#include <fitness/moeoFastNonDominatedSortingFitnessAssignment.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <fitness/moeoIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoParetoBasedFitnessAssignment.h>
|
||||
//#include <fitness/moeoReferencePointIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoScalarFitnessAssignment.h>
|
||||
|
||||
#include <metric/moeoAdditiveEpsilonBinaryMetric.h>
|
||||
#include <metric/moeoContributionMetric.h>
|
||||
#include <metric/moeoEntropyMetric.h>
|
||||
#include <metric/moeoHypervolumeBinaryMetric.h>
|
||||
#include <metric/moeoMetric.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
|
||||
#include <replacement/moeoElitistReplacement.h>
|
||||
#include <replacement/moeoEnvironmentalReplacement.h>
|
||||
#include <replacement/moeoGenerationalReplacement.h>
|
||||
#include <replacement/moeoReplacement.h>
|
||||
|
||||
#include <selection/moeoDetTournamentSelect.h>
|
||||
#include <selection/moeoRandomSelect.h>
|
||||
#include <selection/moeoRouletteSelect.h>
|
||||
#include <selection/moeoSelectFromPopAndArch.h>
|
||||
#include <selection/moeoSelectOne.h>
|
||||
#include <selection/moeoSelectors.h>
|
||||
#include <selection/moeoStochTournamentSelect.h>
|
||||
|
||||
#include <utils/moeoArchiveObjectiveVectorSavingUpdater.h>
|
||||
#include <utils/moeoArchiveUpdater.h>
|
||||
#include <utils/moeoBinaryMetricSavingUpdater.h>
|
||||
#include <utils/moeoConvertPopToObjectiveVectors.h>
|
||||
|
||||
|
||||
#endif /*MOEO_*/
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
#ifndef _MOEOMOVEINCREVAL_H
|
||||
#define _MOEOMOVEINCREVAL_H
|
||||
|
||||
#include <eoFunctor.h>
|
||||
|
||||
template < class Move >
|
||||
class moeoMoveIncrEval : public eoBF < const Move &, const typename Move::EOType &, typename Move::EOType::ObjectiveVector > {};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoElitistReplacement.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOELITISTREPLACEMENT_H_
|
||||
#define MOEOELITISTREPLACEMENT_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
#include <diversity/moeoDummyDiversityAssignment.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <replacement/moeoReplacement.h>
|
||||
|
||||
/**
|
||||
* Elitist replacement strategy that consists in keeping the N best individuals.
|
||||
*/
|
||||
template < class MOEOT > class moeoElitistReplacement:public moeoReplacement < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Full constructor.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _diversityAssignment the diversity assignment strategy
|
||||
* @param _comparator the comparator (used to compare 2 individuals)
|
||||
*/
|
||||
moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment, moeoComparator < MOEOT > & _comparator) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (_comparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Constructor without comparator. A moeoFitThenDivComparator is used as default.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _diversityAssignment the diversity assignment strategy
|
||||
*/
|
||||
moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (defaultComparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Constructor without moeoDiversityAssignement. A dummy diversity is used as default.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _comparator the comparator (used to compare 2 individuals)
|
||||
*/
|
||||
moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoComparator < MOEOT > & _comparator) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (_comparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Constructor without moeoDiversityAssignement nor moeoComparator.
|
||||
* A moeoFitThenDivComparator and a dummy diversity are used as default.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
*/
|
||||
moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (defaultComparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Replaces the first population by adding the individuals of the second one, sorting with a moeoComparator and resizing the whole population obtained.
|
||||
* @param _parents the population composed of the parents (the population you want to replace)
|
||||
* @param _offspring the offspring population
|
||||
*/
|
||||
void operator () (eoPop < MOEOT > &_parents, eoPop < MOEOT > &_offspring)
|
||||
{
|
||||
unsigned int sz = _parents.size ();
|
||||
// merges offspring and parents into a global population
|
||||
_parents.reserve (_parents.size () + _offspring.size ());
|
||||
std::copy (_offspring.begin (), _offspring.end (), back_inserter (_parents));
|
||||
// evaluates the fitness and the diversity of this global population
|
||||
fitnessAssignment (_parents);
|
||||
diversityAssignment (_parents);
|
||||
// sorts the whole population according to the comparator
|
||||
std::sort(_parents.begin(), _parents.end(), comparator);
|
||||
// finally, resize this global population
|
||||
_parents.resize (sz);
|
||||
// and clear the offspring population
|
||||
_offspring.clear ();
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the fitness assignment strategy */
|
||||
moeoFitnessAssignment < MOEOT > & fitnessAssignment;
|
||||
/** the diversity assignment strategy */
|
||||
moeoDiversityAssignment < MOEOT > & diversityAssignment;
|
||||
/** a dummy diversity assignment can be used as default */
|
||||
moeoDummyDiversityAssignment < MOEOT > defaultDiversity;
|
||||
/** a fitness then diversity comparator can be used as default */
|
||||
moeoFitnessThenDiversityComparator < MOEOT > defaultComparator;
|
||||
/** this object is used to compare solutions in order to sort the population */
|
||||
class Cmp
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _comp the comparator
|
||||
*/
|
||||
Cmp(moeoComparator < MOEOT > & _comp) : comp(_comp)
|
||||
{}
|
||||
/**
|
||||
* Returns true if _moeo1 is greater than _moeo2 according to the comparator
|
||||
* _moeo1 the first individual
|
||||
* _moeo2 the first individual
|
||||
*/
|
||||
bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
return comp(_moeo2,_moeo1);
|
||||
}
|
||||
private:
|
||||
/** the comparator */
|
||||
moeoComparator < MOEOT > & comp;
|
||||
} comparator;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOELITISTREPLACEMENT_H_ */
|
||||
|
|
@ -1,146 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoEnvironmentalReplacement.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOENVIRONMENTALREPLACEMENT_H_
|
||||
#define MOEOENVIRONMENTALREPLACEMENT_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <replacement/moeoReplacement.h>
|
||||
|
||||
/**
|
||||
* Environmental replacement strategy that consists in keeping the N best individuals by deleting individuals 1 by 1
|
||||
* and by updating the fitness and diversity values after each deletion.
|
||||
*/
|
||||
template < class MOEOT > class moeoEnvironmentalReplacement:public moeoReplacement < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/** The type for objective vector */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Full constructor.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _diversityAssignment the diversity assignment strategy
|
||||
* @param _comparator the comparator (used to compare 2 individuals)
|
||||
*/
|
||||
moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment, moeoComparator < MOEOT > & _comparator) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (_comparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Constructor without comparator. A moeoFitThenDivComparator is used as default.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _diversityAssignment the diversity assignment strategy
|
||||
*/
|
||||
moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (defaultComparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Constructor without moeoDiversityAssignement. A dummy diversity is used as default.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
* @param _comparator the comparator (used to compare 2 individuals)
|
||||
*/
|
||||
moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoComparator < MOEOT > & _comparator) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (_comparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Constructor without moeoDiversityAssignement nor moeoComparator.
|
||||
* A moeoFitThenDivComparator and a dummy diversity are used as default.
|
||||
* @param _fitnessAssignment the fitness assignment strategy
|
||||
*/
|
||||
moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment) :
|
||||
fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (defaultComparator)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Replaces the first population by adding the individuals of the second one, sorting with a moeoComparator and resizing the whole population obtained.
|
||||
* @param _parents the population composed of the parents (the population you want to replace)
|
||||
* @param _offspring the offspring population
|
||||
*/
|
||||
void operator () (eoPop < MOEOT > &_parents, eoPop < MOEOT > &_offspring)
|
||||
{
|
||||
unsigned int sz = _parents.size();
|
||||
// merges offspring and parents into a global population
|
||||
_parents.reserve (_parents.size() + _offspring.size());
|
||||
std::copy (_offspring.begin(), _offspring.end(), back_inserter(_parents));
|
||||
// evaluates the fitness and the diversity of this global population
|
||||
fitnessAssignment (_parents);
|
||||
diversityAssignment (_parents);
|
||||
// remove individuals 1 by 1 and update the fitness values
|
||||
unsigned int worstIdx;
|
||||
ObjectiveVector worstObjVec;
|
||||
while (_parents.size() > sz)
|
||||
{
|
||||
// the individual to delete
|
||||
worstIdx = std::min_element(_parents.begin(), _parents.end(), comparator) - _parents.begin();
|
||||
worstObjVec = _parents[worstIdx].objectiveVector();
|
||||
// remove the woorst individual
|
||||
_parents[worstIdx] = _parents.back();
|
||||
_parents.pop_back();
|
||||
// update of the fitness and diversity values
|
||||
fitnessAssignment.updateByDeleting(_parents, worstObjVec);
|
||||
diversityAssignment.updateByDeleting(_parents, worstObjVec);
|
||||
|
||||
}
|
||||
// clear the offspring population
|
||||
_offspring.clear ();
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the fitness assignment strategy */
|
||||
moeoFitnessAssignment < MOEOT > & fitnessAssignment;
|
||||
/** the diversity assignment strategy */
|
||||
moeoDiversityAssignment < MOEOT > & diversityAssignment;
|
||||
/** a dummy diversity assignment can be used as default */
|
||||
moeoDummyDiversityAssignment < MOEOT > defaultDiversity;
|
||||
/** a fitness then diversity comparator can be used as default */
|
||||
moeoFitnessThenDiversityComparator < MOEOT > defaultComparator;
|
||||
/** this object is used to compare solutions in order to sort the population */
|
||||
class Cmp
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _comp the comparator
|
||||
*/
|
||||
Cmp(moeoComparator < MOEOT > & _comp) : comp(_comp)
|
||||
{}
|
||||
/**
|
||||
* Returns true if _moeo1 is greater than _moeo2 according to the comparator
|
||||
* _moeo1 the first individual
|
||||
* _moeo2 the first individual
|
||||
*/
|
||||
bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
|
||||
{
|
||||
return comp(_moeo1,_moeo2);
|
||||
}
|
||||
private:
|
||||
/** the comparator */
|
||||
moeoComparator < MOEOT > & comp;
|
||||
} comparator;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOENVIRONMENTALREPLACEMENT_H_ */
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoGenerationalReplacement.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOGENERATIONALREPLACEMENT_H_
|
||||
#define MOEOGENERATIONALREPLACEMENT_H_
|
||||
|
||||
#include <eoReplacement.h>
|
||||
#include <replacement/moeoReplacement.h>
|
||||
|
||||
/**
|
||||
* Generational replacement: only the new individuals are preserved.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoGenerationalReplacement : public moeoReplacement < MOEOT >, public eoGenerationalReplacement < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Swaps _parents and _offspring
|
||||
* @param _parents the parents population
|
||||
* @param _offspring the offspring population
|
||||
*/
|
||||
void operator()(eoPop < MOEOT > & _parents, eoPop < MOEOT > & _offspring)
|
||||
{
|
||||
eoGenerationalReplacement < MOEOT >::operator ()(_parents, _offspring);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOGENERATIONALREPLACEMENT_H_*/
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoReplacement.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOREPLACEMENT_H_
|
||||
#define MOEOREPLACEMENT_H_
|
||||
|
||||
#include <eoReplacement.h>
|
||||
|
||||
/**
|
||||
* Replacement strategy for multi-objective optimization.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoReplacement : public eoReplacement < MOEOT > {};
|
||||
|
||||
#endif /*MOEOREPLACEMENT_H_*/
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoDetTournamentSelect.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEODETTOURNAMENTSELECT_H_
|
||||
#define MOEODETTOURNAMENTSELECT_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
#include <selection/moeoSelectOne.h>
|
||||
#include <selection/moeoSelectors.h>
|
||||
|
||||
/**
|
||||
* Selection strategy that selects ONE individual by deterministic tournament.
|
||||
*/
|
||||
template < class MOEOT > class moeoDetTournamentSelect:public moeoSelectOne < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Full Ctor.
|
||||
* @param _comparator the comparator (used to compare 2 individuals)
|
||||
* @param _tSize the number of individuals in the tournament (default: 2)
|
||||
*/
|
||||
moeoDetTournamentSelect (moeoComparator < MOEOT > & _comparator, unsigned int _tSize = 2) : comparator (_comparator), tSize (_tSize)
|
||||
{
|
||||
// consistency check
|
||||
if (tSize < 2)
|
||||
{
|
||||
std::
|
||||
cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n";
|
||||
tSize = 2;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor without comparator. A moeoFitnessThenDiversityComparator is used as default.
|
||||
* @param _tSize the number of individuals in the tournament (default: 2)
|
||||
*/
|
||||
moeoDetTournamentSelect (unsigned int _tSize = 2) : comparator (defaultComparator), tSize (_tSize)
|
||||
{
|
||||
// consistency check
|
||||
if (tSize < 2)
|
||||
{
|
||||
std::
|
||||
cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n";
|
||||
tSize = 2;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Apply the tournament to the given population
|
||||
* @param _pop the population
|
||||
*/
|
||||
const MOEOT & operator() (const eoPop < MOEOT > &_pop)
|
||||
{
|
||||
// use the selector
|
||||
return mo_deterministic_tournament (_pop, tSize, comparator);
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the comparator (used to compare 2 individuals) */
|
||||
moeoComparator < MOEOT > & comparator;
|
||||
/** a fitness then diversity comparator can be used as default */
|
||||
moeoFitnessThenDiversityComparator < MOEOT > defaultComparator;
|
||||
/** the number of individuals in the tournament */
|
||||
unsigned int tSize;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEODETTOURNAMENTSELECT_H_ */
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoRandomSelect.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEORANDOMSELECT_H_
|
||||
#define MOEORANDOMSELECT_H_
|
||||
|
||||
#include <eoRandomSelect.h>
|
||||
#include <selection/moeoSelectOne.h>
|
||||
|
||||
|
||||
/**
|
||||
* Selection strategy that selects only one element randomly from a whole population.
|
||||
*/
|
||||
template < class MOEOT > class moeoRandomSelect:public moeoSelectOne < MOEOT >, public eoRandomSelect <MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
*/
|
||||
moeoRandomSelect(){}
|
||||
|
||||
|
||||
/**
|
||||
* Return one individual at random by using an eoRandomSelect.
|
||||
*/
|
||||
const MOEOT & operator () (const eoPop < MOEOT > &_pop)
|
||||
{
|
||||
return eoRandomSelect < MOEOT >::operator ()(_pop);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEORANDOMSELECT_H_ */
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoRouletteSelect.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOROULETTESELECT_H_
|
||||
#define MOEOROULETTESELECT_H_
|
||||
|
||||
#include <selection/moeoSelectOne.h>
|
||||
#include <selection/moeoSelectors.h>
|
||||
|
||||
/**
|
||||
* Selection strategy that selects ONE individual by using roulette wheel process.
|
||||
* @WARNING This selection only uses fitness values (and not diversity values).
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoRouletteSelect:public moeoSelectOne < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @param _tSize the number of individuals in the tournament (default: 2)
|
||||
*/
|
||||
moeoRouletteSelect (unsigned int _tSize = 2) : tSize (_tSize)
|
||||
{
|
||||
// consistency check
|
||||
if (tSize < 2)
|
||||
{
|
||||
std::
|
||||
cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n";
|
||||
tSize = 2;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Apply the tournament to the given population
|
||||
* @param _pop the population
|
||||
*/
|
||||
const MOEOT & operator () (const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
// use the selector
|
||||
return mo_roulette_wheel(_pop,tSize);
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** size */
|
||||
double & tSize;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOROULETTESELECT_H_ */
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoSelectFormPopAndArch.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOSELECTONEFROMPOPANDARCH_H_
|
||||
#define MOEOSELECTONEFROMPOPANDARCH_H_
|
||||
|
||||
#include <eoPop.h>
|
||||
#include <utils/eoRNG.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <selection/moeoSelectOne.h>
|
||||
#include <selection/moeoRandomSelect.h>
|
||||
|
||||
/**
|
||||
* Elitist selection process that consists in choosing individuals in the archive as well as in the current population.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoSelectFromPopAndArch : public moeoSelectOne < MOEOT >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _popSelectOne the population's selection operator
|
||||
* @param _archSelectOne the archive's selection operator
|
||||
* @param _arch the archive
|
||||
* @param _ratioFromPop the ratio of selected individuals from the population
|
||||
*/
|
||||
moeoSelectFromPopAndArch (moeoSelectOne < MOEOT > & _popSelectOne, moeoSelectOne < MOEOT > _archSelectOne, moeoArchive < MOEOT > & _arch, double _ratioFromPop=0.5)
|
||||
: popSelectOne(_popSelectOne), archSelectOne(_archSelectOne), arch(_arch), ratioFromPop(_ratioFromPop)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Defaulr ctor - the archive's selection operator is a random selector
|
||||
* @param _popSelectOne the population's selection operator
|
||||
* @param _arch the archive
|
||||
* @param _ratioFromPop the ratio of selected individuals from the population
|
||||
*/
|
||||
moeoSelectFromPopAndArch (moeoSelectOne < MOEOT > & _popSelectOne, moeoArchive < MOEOT > & _arch, double _ratioFromPop=0.5)
|
||||
: popSelectOne(_popSelectOne), archSelectOne(randomSelectOne), arch(_arch), ratioFromPop(_ratioFromPop)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* The selection process
|
||||
*/
|
||||
virtual const MOEOT & operator () (const eoPop < MOEOT > & pop)
|
||||
{
|
||||
if (arch.size() > 0)
|
||||
if (rng.flip(ratioFromPop))
|
||||
return popSelectOne(pop);
|
||||
else
|
||||
return archSelectOne(arch);
|
||||
else
|
||||
return popSelectOne(pop);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Setups some population stats
|
||||
*/
|
||||
virtual void setup (const eoPop < MOEOT > & _pop)
|
||||
{
|
||||
popSelectOne.setup(_pop);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** The population's selection operator */
|
||||
moeoSelectOne < MOEOT > & popSelectOne;
|
||||
/** The archive's selection operator */
|
||||
moeoSelectOne < MOEOT > & archSelectOne;
|
||||
/** The archive */
|
||||
moeoArchive < MOEOT > & arch;
|
||||
/** The ratio of selected individuals from the population*/
|
||||
double ratioFromPop;
|
||||
/** A random selection operator (used as default for archSelectOne) */
|
||||
moeoRandomSelect < MOEOT > randomSelectOne;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOSELECTONEFROMPOPANDARCH_H_*/
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoSelectOne.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOSELECTONE_H_
|
||||
#define MOEOSELECTONE_H_
|
||||
|
||||
#include <eoSelectOne.h>
|
||||
|
||||
/**
|
||||
* Selection strategy for multi-objective optimization that selects only one element from a whole population.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoSelectOne : public eoSelectOne < MOEOT > {};
|
||||
|
||||
#endif /*MOEOSELECTONE_H_*/
|
||||
|
|
@ -1,158 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoSelectors.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOSELECTORS_H_
|
||||
#define MOEOSELECTORS_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
|
||||
|
||||
template <class It,class MOEOT>
|
||||
It mo_deterministic_tournament(It _begin, It _end, unsigned int _t_size,moeoComparator<MOEOT>& _comparator ,eoRng& _gen = rng)
|
||||
{
|
||||
It best = _begin + _gen.random(_end - _begin);
|
||||
|
||||
for (unsigned int i = 0; i < _t_size - 1; ++i)
|
||||
{
|
||||
It competitor = _begin + _gen.random(_end - _begin);
|
||||
// compare the two individuals by using the comparator
|
||||
if (_comparator(*best, *competitor))
|
||||
// best "better" than competitor
|
||||
best=competitor;
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
|
||||
template <class MOEOT>
|
||||
const MOEOT& mo_deterministic_tournament(const eoPop<MOEOT>& _pop, unsigned int _t_size,moeoComparator<MOEOT>& _comparator, eoRng& _gen = rng)
|
||||
{
|
||||
return *mo_deterministic_tournament(_pop.begin(), _pop.end(),_t_size,_comparator, _gen);
|
||||
}
|
||||
|
||||
|
||||
template <class MOEOT>
|
||||
MOEOT& mo_deterministic_tournament(eoPop<MOEOT>& _pop, unsigned int _t_size,moeoComparator<MOEOT>& _comparator,eoRng& _gen = rng)
|
||||
{
|
||||
return *mo_deterministic_tournament(_pop.begin(), _pop.end(), _t_size,_comparator, _gen);
|
||||
}
|
||||
|
||||
|
||||
template <class It,class MOEOT>
|
||||
It mo_stochastic_tournament(It _begin, It _end, double _t_rate,moeoComparator<MOEOT>& _comparator ,eoRng& _gen = rng)
|
||||
{
|
||||
It i1 = _begin + _gen.random(_end - _begin);
|
||||
It i2 = _begin + _gen.random(_end - _begin);
|
||||
|
||||
bool return_better = _gen.flip(_t_rate);
|
||||
|
||||
if (_comparator(*i1, *i2))
|
||||
{
|
||||
if (return_better) return i2;
|
||||
// else
|
||||
|
||||
return i1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (return_better) return i1;
|
||||
// else
|
||||
}
|
||||
// else
|
||||
|
||||
return i2;
|
||||
}
|
||||
|
||||
|
||||
template <class MOEOT>
|
||||
const MOEOT& mo_stochastic_tournament(const eoPop<MOEOT>& _pop, double _t_rate,moeoComparator<MOEOT>& _comparator, eoRng& _gen = rng)
|
||||
{
|
||||
return *mo_stochastic_tournament(_pop.begin(), _pop.end(), _t_rate,_comparator, _gen);
|
||||
}
|
||||
|
||||
|
||||
template <class MOEOT>
|
||||
MOEOT& mo_stochastic_tournament(eoPop<MOEOT>& _pop, double _t_rate, eoRng& _gen = rng)
|
||||
{
|
||||
return *mo_stochastic_tournament(_pop.begin(), _pop.end(), _t_rate, _gen);
|
||||
}
|
||||
|
||||
|
||||
template <class It>
|
||||
It mo_roulette_wheel(It _begin, It _end, double total, eoRng& _gen = rng)
|
||||
{
|
||||
|
||||
float roulette = _gen.uniform(total);
|
||||
|
||||
if (roulette == 0.0) // covers the case where total==0.0
|
||||
return _begin + _gen.random(_end - _begin); // uniform choice
|
||||
|
||||
It i = _begin;
|
||||
|
||||
while (roulette > 0.0)
|
||||
{
|
||||
roulette -= static_cast<double>(*(i++));
|
||||
}
|
||||
|
||||
return --i;
|
||||
}
|
||||
|
||||
|
||||
template <class MOEOT>
|
||||
const MOEOT& mo_roulette_wheel(const eoPop<MOEOT>& _pop, double total, eoRng& _gen = rng)
|
||||
{
|
||||
float roulette = _gen.uniform(total);
|
||||
|
||||
if (roulette == 0.0) // covers the case where total==0.0
|
||||
return _pop[_gen.random(_pop.size())]; // uniform choice
|
||||
|
||||
typename eoPop<MOEOT>::const_iterator i = _pop.begin();
|
||||
|
||||
while (roulette > 0.0)
|
||||
{
|
||||
roulette -= static_cast<double>((i++)->fitness());
|
||||
}
|
||||
|
||||
return *--i;
|
||||
}
|
||||
|
||||
|
||||
template <class MOEOT>
|
||||
MOEOT& mo_roulette_wheel(eoPop<MOEOT>& _pop, double total, eoRng& _gen = rng)
|
||||
{
|
||||
float roulette = _gen.uniform(total);
|
||||
|
||||
if (roulette == 0.0) // covers the case where total==0.0
|
||||
return _pop[_gen.random(_pop.size())]; // uniform choice
|
||||
|
||||
typename eoPop<MOEOT>::iterator i = _pop.begin();
|
||||
|
||||
while (roulette > 0.0)
|
||||
{
|
||||
// fitness only
|
||||
roulette -= static_cast<double>((i++)->fitness());
|
||||
}
|
||||
|
||||
return *--i;
|
||||
}
|
||||
|
||||
|
||||
#endif /*MOEOSELECTORS_H_*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoStochTournamentSelect.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOSTOCHTOURNAMENTSELECT_H_
|
||||
#define MOEOSTOCHTOURNAMENTSELECT_H_
|
||||
|
||||
#include <comparator/moeoComparator.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
#include <selection/moeoSelectOne.h>
|
||||
#include <selection/moeoSelectors.h>
|
||||
|
||||
/**
|
||||
* Selection strategy that selects ONE individual by stochastic tournament.
|
||||
*/
|
||||
template < class MOEOT > class moeoStochTournamentSelect:public moeoSelectOne <MOEOT>
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Full Ctor
|
||||
* @param _comparator the comparator (used to compare 2 individuals)
|
||||
* @param _tRate the tournament rate
|
||||
*/
|
||||
moeoStochTournamentSelect (moeoComparator < MOEOT > & _comparator, double _tRate = 1.0) : comparator (_comparator), tRate (_tRate)
|
||||
{
|
||||
// consistency checks
|
||||
if (tRate < 0.5)
|
||||
{
|
||||
std::cerr << "Warning, Tournament rate should be > 0.5\nAdjusted to 0.55\n";
|
||||
tRate = 0.55;
|
||||
}
|
||||
if (tRate > 1)
|
||||
{
|
||||
std::cerr << "Warning, Tournament rate should be < 1\nAdjusted to 1\n";
|
||||
tRate = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Ctor without comparator. A moeoFitnessThenDiversityComparator is used as default.
|
||||
* @param _tRate the tournament rate
|
||||
*/
|
||||
moeoStochTournamentSelect (double _tRate = 1.0) : comparator (defaultComparator), tRate (_tRate)
|
||||
{
|
||||
// consistency checks
|
||||
if (tRate < 0.5)
|
||||
{
|
||||
std::cerr << "Warning, Tournament rate should be > 0.5\nAdjusted to 0.55\n";
|
||||
tRate = 0.55;
|
||||
}
|
||||
if (tRate > 1)
|
||||
{
|
||||
std::cerr << "Warning, Tournament rate should be < 1\nAdjusted to 1\n";
|
||||
tRate = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Apply the tournament to the given population
|
||||
* @param _pop the population
|
||||
*/
|
||||
const MOEOT & operator() (const eoPop < MOEOT > &_pop)
|
||||
{
|
||||
// use the selector
|
||||
return mo_stochastic_tournament(_pop,tRate,comparator);
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
/** the comparator (used to compare 2 individuals) */
|
||||
moeoComparator < MOEOT > & comparator;
|
||||
/** a fitness then diversity comparator can be used as default */
|
||||
moeoFitnessThenDiversityComparator < MOEOT > defaultComparator;
|
||||
/** the tournament rate */
|
||||
double tRate;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOSTOCHTOURNAMENTSELECT_H_ */
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoArchiveObjectiveVectorSavingUpdater.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOARCHIVEOBJECTIVEVECTORSAVINGUPDATER_H_
|
||||
#define MOEOARCHIVEOBJECTIVEVECTORSAVINGUPDATER_H_
|
||||
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <eoPop.h>
|
||||
#include <utils/eoUpdater.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
|
||||
#define MAX_BUFFER_SIZE 1000
|
||||
|
||||
/**
|
||||
* This class allows to save the objective vectors of the solutions contained in an archive into a file at each generation.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoArchiveObjectiveVectorSavingUpdater : public eoUpdater
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _arch local archive
|
||||
* @param _filename target filename
|
||||
* @param _count put this variable to true if you want a new file to be created each time () is called and to false if you only want the file to be updated
|
||||
* @param _id own ID
|
||||
*/
|
||||
moeoArchiveObjectiveVectorSavingUpdater (moeoArchive<MOEOT> & _arch, const std::string & _filename, bool _count = false, int _id = -1) :
|
||||
arch(_arch), filename(_filename), count(_count), counter(0), id(_id)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Saves the fitness of the archive's members into the file
|
||||
*/
|
||||
void operator()() {
|
||||
char buff[MAX_BUFFER_SIZE];
|
||||
if (count)
|
||||
{
|
||||
if (id == -1)
|
||||
{
|
||||
sprintf (buff, "%s.%u", filename.c_str(), counter ++);
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf (buff, "%s.%u.%u", filename.c_str(), id, counter ++);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (id == -1)
|
||||
{
|
||||
sprintf (buff, "%s", filename.c_str());
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf (buff, "%s.%u", filename.c_str(), id);
|
||||
}
|
||||
counter ++;
|
||||
}
|
||||
std::ofstream f(buff);
|
||||
for (unsigned int i = 0; i < arch.size (); i++)
|
||||
f << arch[i].objectiveVector() << std::endl;
|
||||
f.close ();
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** local archive */
|
||||
moeoArchive<MOEOT> & arch;
|
||||
/** target filename */
|
||||
std::string filename;
|
||||
/** this variable is set to true if a new file have to be created each time () is called and to false if the file only HAVE to be updated */
|
||||
bool count;
|
||||
/** counter */
|
||||
unsigned int counter;
|
||||
/** own ID */
|
||||
int id;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOARCHIVEOBJECTIVEVECTORSAVINGUPDATER_H_*/
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoArchiveUpdater.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOARCHIVEUPDATER_H_
|
||||
#define MOEOARCHIVEUPDATER_H_
|
||||
|
||||
#include <eoPop.h>
|
||||
#include <utils/eoUpdater.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
|
||||
/**
|
||||
* This class allows to update the archive at each generation with newly found non-dominated solutions.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoArchiveUpdater : public eoUpdater
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _arch an archive of non-dominated solutions
|
||||
* @param _pop the main population
|
||||
*/
|
||||
moeoArchiveUpdater(moeoArchive < MOEOT > & _arch, const eoPop < MOEOT > & _pop) : arch(_arch), pop(_pop)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the archive with newly found non-dominated solutions contained in the main population
|
||||
*/
|
||||
void operator()() {
|
||||
arch.update(pop);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** the archive of non-dominated solutions */
|
||||
moeoArchive < MOEOT > & arch;
|
||||
/** the main population */
|
||||
const eoPop < MOEOT > & pop;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOARCHIVEUPDATER_H_*/
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoBinaryMetricSavingUpdater.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOBINARYMETRICSAVINGUPDATER_H_
|
||||
#define MOEOBINARYMETRICSAVINGUPDATER_H_
|
||||
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <eoPop.h>
|
||||
#include <utils/eoUpdater.h>
|
||||
#include <metric/moeoMetric.h>
|
||||
|
||||
/**
|
||||
* This class allows to save the progression of a binary metric comparing the objective vectors of the current population (or archive)
|
||||
* with the objective vectors of the population (or archive) of the generation (n-1) into a file
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoBinaryMetricSavingUpdater : public eoUpdater
|
||||
{
|
||||
public:
|
||||
|
||||
/** The objective vector type of a solution */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor
|
||||
* @param _metric the binary metric comparing two Pareto sets
|
||||
* @param _pop the main population
|
||||
* @param _filename the target filename
|
||||
*/
|
||||
moeoBinaryMetricSavingUpdater (moeoVectorVsVectorBinaryMetric < ObjectiveVector, double > & _metric, const eoPop < MOEOT > & _pop, std::string _filename) :
|
||||
metric(_metric), pop(_pop), filename(_filename), counter(1)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
* Saves the metric's value for the current generation
|
||||
*/
|
||||
void operator()() {
|
||||
if (pop.size()) {
|
||||
if (firstGen) {
|
||||
firstGen = false;
|
||||
}
|
||||
else {
|
||||
// creation of the two Pareto sets
|
||||
std::vector < ObjectiveVector > from;
|
||||
std::vector < ObjectiveVector > to;
|
||||
for (unsigned int i=0; i<pop.size(); i++)
|
||||
from.push_back(pop[i].objectiveVector());
|
||||
for (unsigned int i=0 ; i<oldPop.size(); i++)
|
||||
to.push_back(oldPop[i].objectiveVector());
|
||||
// writing the result into the file
|
||||
std::ofstream f (filename.c_str(), std::ios::app);
|
||||
f << counter++ << ' ' << metric(from,to) << std::endl;
|
||||
f.close();
|
||||
}
|
||||
oldPop = pop;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/** binary metric comparing two Pareto sets */
|
||||
moeoVectorVsVectorBinaryMetric < ObjectiveVector, double > & metric;
|
||||
/** main population */
|
||||
const eoPop < MOEOT > & pop;
|
||||
/** (n-1) population */
|
||||
eoPop< MOEOT > oldPop;
|
||||
/** target filename */
|
||||
std::string filename;
|
||||
/** is it the first generation ? */
|
||||
bool firstGen;
|
||||
/** counter */
|
||||
unsigned int counter;
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOBINARYMETRICSAVINGUPDATER_H_*/
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// moeoConvertPopToObjectiveVectors.h
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MOEOPOPTOOBJECTIVEVECTORS_H_
|
||||
#define MOEOPOPTOOBJECTIVEVECTORS_H_
|
||||
|
||||
#include <vector>
|
||||
#include <eoFunctor.h>
|
||||
|
||||
/**
|
||||
* Functor allowing to get a vector of objective vectors from a population
|
||||
*/
|
||||
template < class MOEOT, class ObjectiveVector = typename MOEOT::ObjectiveVector >
|
||||
class moeoConvertPopToObjectiveVectors : public eoUF < const eoPop < MOEOT >, const std::vector < ObjectiveVector > >
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Returns a vector of the objective vectors from the population _pop
|
||||
* @param _pop the population
|
||||
*/
|
||||
const std::vector < ObjectiveVector > operator()(const eoPop < MOEOT > _pop)
|
||||
{
|
||||
std::vector < ObjectiveVector > result;
|
||||
result.resize(_pop.size());
|
||||
for (unsigned int i=0; i<_pop.size(); i++)
|
||||
{
|
||||
result.push_back(_pop[i].objectiveVector());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /*MOEOPOPTOOBJECTIVEVECTORS_H_*/
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// FlowShopEA.cpp
|
||||
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
|
||||
/*
|
||||
This library...
|
||||
|
||||
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
// moeo general include
|
||||
#include <moeo>
|
||||
// for the creation of an evaluator
|
||||
#include <make_eval_FlowShop.h>
|
||||
// for the creation of an initializer
|
||||
#include <make_genotype_FlowShop.h>
|
||||
// for the creation of the variation operators
|
||||
#include <make_op_FlowShop.h>
|
||||
// how to initialize the population
|
||||
#include <do/make_pop.h>
|
||||
// the stopping criterion
|
||||
#include <do/make_continue_moeo.h>
|
||||
// outputs (stats, population dumps, ...)
|
||||
#include <do/make_checkpoint_moeo.h>
|
||||
// evolution engine (selection and replacement)
|
||||
#include <do/make_ea_moeo.h>
|
||||
// simple call to the algo
|
||||
#include <do/make_run.h>
|
||||
// checks for help demand, and writes the status file and make_help; in libutils
|
||||
void make_help(eoParser & _parser);
|
||||
// definition of the representation
|
||||
#include <FlowShop.h>
|
||||
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
try
|
||||
{
|
||||
|
||||
eoParser parser(argc, argv); // for user-parameter reading
|
||||
eoState state; // to keep all things allocated
|
||||
|
||||
|
||||
/*** the representation-dependent things ***/
|
||||
|
||||
// The fitness evaluation
|
||||
eoEvalFuncCounter<FlowShop>& eval = do_make_eval(parser, state);
|
||||
// the genotype (through a genotype initializer)
|
||||
eoInit<FlowShop>& init = do_make_genotype(parser, state);
|
||||
// the variation operators
|
||||
eoGenOp<FlowShop>& op = do_make_op(parser, state);
|
||||
|
||||
|
||||
/*** the representation-independent things ***/
|
||||
|
||||
// initialization of the population
|
||||
eoPop<FlowShop>& pop = do_make_pop(parser, state, init);
|
||||
// definition of the archive
|
||||
moeoArchive<FlowShop> arch;
|
||||
// stopping criteria
|
||||
eoContinue<FlowShop>& term = do_make_continue_moeo(parser, state, eval);
|
||||
// output
|
||||
eoCheckPoint<FlowShop>& checkpoint = do_make_checkpoint_moeo(parser, state, eval, term, pop, arch);
|
||||
// algorithm
|
||||
eoAlgo<FlowShop>& algo = do_make_ea_moeo(parser, state, eval, checkpoint, op, arch);
|
||||
|
||||
|
||||
/*** Go ! ***/
|
||||
|
||||
// help ?
|
||||
make_help(parser);
|
||||
|
||||
// first evalution
|
||||
apply<FlowShop>(eval, pop);
|
||||
|
||||
// printing of the initial population
|
||||
cout << "Initial Population\n";
|
||||
pop.sortedPrintOn(cout);
|
||||
cout << endl;
|
||||
|
||||
// run the algo
|
||||
do_run(algo, pop);
|
||||
|
||||
// printing of the final population
|
||||
cout << "Final Population\n";
|
||||
pop.sortedPrintOn(cout);
|
||||
cout << endl;
|
||||
|
||||
// printing of the final archive
|
||||
cout << "Final Archive\n";
|
||||
arch.sortedPrintOn(cout);
|
||||
cout << endl;
|
||||
|
||||
|
||||
}
|
||||
catch (exception& e)
|
||||
{
|
||||
cout << e.what() << endl;
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
|
||||
###### General ######
|
||||
--help=0 # -h : Prints this message
|
||||
--stopOnUnknownParam=1 # Stop if unkown param entered
|
||||
# --seed=1182849833 # -S : Random number seed
|
||||
|
||||
###### Evolution Engine ######
|
||||
--popSize=20 # -P : Population Size
|
||||
--updateArch=1 # Update the archive at each gen.
|
||||
--fitness=FastNonDominatedSorting # -F : Fitness assignment scheme: Dummy, FastNonDominatedSorting or IndicatorBased
|
||||
--indicator=Epsilon # -i : Binary indicator for IndicatorBased: Epsilon, Hypervolume
|
||||
--rho=1.1 # -r : reference point for the hypervolume indicator
|
||||
--kappa=0.05 # -k : Scaling factor kappa for IndicatorBased
|
||||
--diversity=Dummy # -D : Diversity assignment scheme: Dummy, Sharing(nicheSize) or Crowding
|
||||
--comparator=FitnessThenDiversity # -C : Comparator scheme: FitnessThenDiversity, DiversityThenFitness or Aggregative
|
||||
--selection=DetTour(2) # -S : Selection scheme: DetTour(T), StochTour(t) or Random
|
||||
--replacement=Elitist # -R : Replacement scheme: Elitist, Environmental or Generational
|
||||
--nbOffspring=100% # -O : Number of offspring (percentage or absolute)
|
||||
|
||||
###### Output ######
|
||||
--resDir=Res # Directory to store DISK outputs
|
||||
--eraseDir=1 # erase files in dirName if any
|
||||
--printPop=0 # Print sorted pop. every gen.
|
||||
--storeArch=0 # Store the archive's objective vectors at each gen.
|
||||
--contribution=0 # Store the contribution of the archive at each gen.
|
||||
--entropy=0 # Store the entropy of the archive at each gen.
|
||||
|
||||
###### Persistence ######
|
||||
--Load= # -L : A save file to restart from
|
||||
--recomputeFitness=0 # -r : Recompute the fitness after re-loading the pop.?
|
||||
--saveFrequency=0 # Save every F generation (0 = only final state, absent = never)
|
||||
--saveTimeInterval=0 # Save every T seconds (0 or absent = never)
|
||||
--status=./FlowShopEA.status # Status file
|
||||
|
||||
###### Representation ######
|
||||
--BenchmarkFile=benchmarks/020_10_01.txt # -B : Benchmark file name (benchmarks are available at www.lifl.fr/~liefooga/benchmarks) REQUIRED
|
||||
|
||||
###### Stopping criterion ######
|
||||
--maxGen=100 # -G : Maximum number of generations (0 = none)
|
||||
--maxEval=0 # -E : Maximum number of evaluations (0 = none)
|
||||
--maxTime=0 # -T : Maximum running time in seconds (0 = none)
|
||||
--CtrlC=1 # -C : Terminate current generation upon Ctrl C
|
||||
|
||||
###### Variation Operators ######
|
||||
--crossRate=1 # Relative rate for the only crossover
|
||||
--shiftMutRate=0.5 # Relative rate for shift mutation
|
||||
--exchangeMutRate=0.5 # Relative rate for exchange mutation
|
||||
--pCross=0.25 # -c : Probability of Crossover
|
||||
--pMut=0.35 # -m : Probability of Mutation
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
SUBDIRS = flowshop
|
||||
|
||||
noinst_PROGRAMS = FlowShopEA
|
||||
|
||||
FlowShopEA_SOURCES = FlowShopEA.cpp
|
||||
|
||||
LDADD = ${EO_DIR}/src/libeo.a ${EO_DIR}/src/utils/libeoutils.a $(top_srcdir)/src/core/libmoeo.a flowshop/libflowshop.a
|
||||
|
||||
INCLUDES = -Iflowshop -I${EO_DIR}/src/ -I$(top_srcdir)/src/
|
||||
|
||||
AM_CXXFLAGS = -Wall -ansi -pedantic
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
20
|
||||
5
|
||||
873654221
|
||||
0
|
||||
468
|
||||
54 79 16 66 58
|
||||
1
|
||||
325
|
||||
83 3 89 58 56
|
||||
2
|
||||
923
|
||||
15 11 49 31 20
|
||||
3
|
||||
513
|
||||
71 99 15 68 85
|
||||
4
|
||||
1070
|
||||
77 56 89 78 53
|
||||
5
|
||||
690
|
||||
36 70 45 91 35
|
||||
6
|
||||
602
|
||||
53 99 60 13 53
|
||||
7
|
||||
289
|
||||
38 60 23 59 41
|
||||
8
|
||||
873
|
||||
27 5 57 49 69
|
||||
9
|
||||
342
|
||||
87 56 64 85 13
|
||||
10
|
||||
764
|
||||
76 3 7 85 86
|
||||
11
|
||||
268
|
||||
91 61 1 9 72
|
||||
12
|
||||
1158
|
||||
14 73 63 39 8
|
||||
13
|
||||
646
|
||||
29 75 41 41 49
|
||||
14
|
||||
1111
|
||||
12 47 63 56 47
|
||||
15
|
||||
965
|
||||
77 14 47 40 87
|
||||
16
|
||||
703
|
||||
32 21 26 54 58
|
||||
17
|
||||
1205
|
||||
87 86 75 77 18
|
||||
18
|
||||
334
|
||||
68 5 77 51 68
|
||||
19
|
||||
1111
|
||||
94 77 40 31 28
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
20
|
||||
5
|
||||
379008056
|
||||
0
|
||||
517
|
||||
26 59 78 88 69
|
||||
1
|
||||
461
|
||||
38 62 90 54 30
|
||||
2
|
||||
832
|
||||
27 44 64 47 61
|
||||
3
|
||||
653
|
||||
88 10 49 83 35
|
||||
4
|
||||
933
|
||||
95 23 47 84 53
|
||||
5
|
||||
811
|
||||
55 64 20 9 98
|
||||
6
|
||||
966
|
||||
54 47 61 30 94
|
||||
7
|
||||
448
|
||||
63 68 93 11 33
|
||||
8
|
||||
577
|
||||
23 54 36 92 77
|
||||
9
|
||||
1122
|
||||
45 9 47 63 31
|
||||
10
|
||||
666
|
||||
86 30 70 62 54
|
||||
11
|
||||
1189
|
||||
43 31 54 75 71
|
||||
12
|
||||
470
|
||||
43 92 87 48 78
|
||||
13
|
||||
475
|
||||
40 7 13 23 9
|
||||
14
|
||||
462
|
||||
37 14 40 85 79
|
||||
15
|
||||
866
|
||||
54 95 34 23 51
|
||||
16
|
||||
392
|
||||
35 76 55 4 76
|
||||
17
|
||||
310
|
||||
59 82 13 31 56
|
||||
18
|
||||
719
|
||||
43 91 11 13 80
|
||||
19
|
||||
1221
|
||||
50 37 5 98 72
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
20
|
||||
10
|
||||
587595453
|
||||
0
|
||||
1250
|
||||
74 28 89 60 54 92 9 4 25 15
|
||||
1
|
||||
1371
|
||||
21 3 52 88 66 11 8 18 15 84
|
||||
2
|
||||
637
|
||||
58 27 56 26 12 54 88 25 91 8
|
||||
3
|
||||
616
|
||||
4 61 13 58 57 97 72 28 49 30
|
||||
4
|
||||
917
|
||||
21 34 7 76 70 57 27 95 56 95
|
||||
5
|
||||
937
|
||||
28 76 32 98 82 53 22 51 10 79
|
||||
6
|
||||
1435
|
||||
58 64 32 29 99 65 50 84 62 9
|
||||
7
|
||||
1197
|
||||
83 87 98 47 84 77 2 18 70 91
|
||||
8
|
||||
1301
|
||||
31 54 46 79 16 51 49 6 76 76
|
||||
9
|
||||
637
|
||||
61 98 60 26 41 36 82 90 99 26
|
||||
10
|
||||
749
|
||||
94 76 23 19 23 53 93 69 58 42
|
||||
11
|
||||
1223
|
||||
44 41 87 48 11 19 96 61 83 66
|
||||
12
|
||||
887
|
||||
97 70 7 95 68 54 43 57 84 70
|
||||
13
|
||||
1316
|
||||
94 43 36 78 58 86 13 5 64 91
|
||||
14
|
||||
1330
|
||||
66 42 26 77 30 40 60 75 74 67
|
||||
15
|
||||
1380
|
||||
6 79 85 90 5 56 11 4 14 3
|
||||
16
|
||||
767
|
||||
37 88 7 24 5 79 37 38 18 98
|
||||
17
|
||||
574
|
||||
22 15 34 10 39 74 91 28 48 4
|
||||
18
|
||||
1398
|
||||
99 49 36 85 58 24 84 4 96 71
|
||||
19
|
||||
1179
|
||||
83 72 48 55 31 3 67 80 86 62
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
20
|
||||
10
|
||||
1401007982
|
||||
0
|
||||
1279
|
||||
80 59 59 31 30 53 93 90 65 64
|
||||
1
|
||||
1481
|
||||
13 83 70 64 88 19 79 92 97 38
|
||||
2
|
||||
1157
|
||||
64 85 76 11 14 99 88 35 27 44
|
||||
3
|
||||
1391
|
||||
77 85 10 9 22 62 77 13 25 46
|
||||
4
|
||||
763
|
||||
17 70 65 32 93 88 94 75 61 66
|
||||
5
|
||||
1456
|
||||
78 35 19 58 48 93 39 55 24 31
|
||||
6
|
||||
900
|
||||
82 2 77 98 10 34 74 80 97 48
|
||||
7
|
||||
1047
|
||||
4 76 86 95 7 72 46 67 61 27
|
||||
8
|
||||
1355
|
||||
72 46 21 25 14 42 17 3 75 82
|
||||
9
|
||||
1262
|
||||
93 72 75 4 91 65 30 93 92 51
|
||||
10
|
||||
1329
|
||||
68 69 96 45 5 39 62 54 73 90
|
||||
11
|
||||
562
|
||||
25 46 3 60 43 79 77 67 21 63
|
||||
12
|
||||
684
|
||||
67 3 50 87 30 9 43 25 29 85
|
||||
13
|
||||
567
|
||||
80 57 57 31 79 26 98 77 3 36
|
||||
14
|
||||
765
|
||||
43 71 66 1 39 72 48 38 96 69
|
||||
15
|
||||
808
|
||||
93 77 84 96 34 29 14 98 51 67
|
||||
16
|
||||
999
|
||||
21 33 98 22 77 36 45 96 26 81
|
||||
17
|
||||
548
|
||||
33 49 55 95 81 48 25 20 44 18
|
||||
18
|
||||
577
|
||||
14 59 70 73 11 57 98 15 56 81
|
||||
19
|
||||
704
|
||||
30 82 32 77 10 95 30 36 31 72
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
20
|
||||
20
|
||||
479340445
|
||||
0
|
||||
1696
|
||||
50 78 36 85 9 75 46 73 71 7 49 3 60 12 75 31 70 20 88 9
|
||||
1
|
||||
1273
|
||||
90 56 43 88 92 64 94 3 49 40 49 53 88 47 19 61 78 78 30 41
|
||||
2
|
||||
1546
|
||||
39 9 10 60 98 96 6 56 36 33 15 59 15 46 60 47 41 38 34 22
|
||||
3
|
||||
1882
|
||||
34 43 19 98 44 95 19 73 87 64 18 7 26 17 87 32 9 26 33 34
|
||||
4
|
||||
1117
|
||||
66 84 55 4 51 22 20 80 8 5 65 65 11 43 27 34 47 64 21 83
|
||||
5
|
||||
1181
|
||||
81 73 48 99 8 41 51 82 25 25 55 58 16 16 48 69 94 62 7 55
|
||||
6
|
||||
1416
|
||||
27 66 85 53 31 26 85 36 76 89 1 24 55 91 72 32 26 11 94 3
|
||||
7
|
||||
1635
|
||||
48 38 70 21 15 33 92 98 73 95 79 55 59 94 88 1 65 38 10 8
|
||||
8
|
||||
1723
|
||||
46 83 82 33 47 68 43 90 80 58 10 26 81 73 48 1 17 68 73 75
|
||||
9
|
||||
1932
|
||||
68 57 39 53 31 9 75 46 6 83 37 40 53 89 59 80 42 37 85 30
|
||||
10
|
||||
1219
|
||||
48 97 91 63 80 81 70 10 6 28 77 89 92 12 74 19 59 74 82 57
|
||||
11
|
||||
1521
|
||||
92 52 82 18 83 28 70 46 33 35 80 94 23 58 86 57 80 9 62 65
|
||||
12
|
||||
1322
|
||||
78 77 85 45 20 61 36 65 79 74 79 51 55 25 49 98 7 65 99 89
|
||||
13
|
||||
1057
|
||||
84 13 17 29 84 69 31 83 10 5 84 74 79 24 94 37 75 16 67 60
|
||||
14
|
||||
1922
|
||||
93 12 6 43 69 37 76 75 93 6 93 54 13 55 15 31 63 38 61 90
|
||||
15
|
||||
1130
|
||||
39 2 54 41 49 57 63 47 65 9 21 86 89 1 95 51 96 85 10 84
|
||||
16
|
||||
1411
|
||||
43 65 87 80 93 36 89 61 26 3 85 22 2 67 41 66 7 50 4 74
|
||||
17
|
||||
1840
|
||||
1 93 85 4 39 80 46 28 73 2 64 83 17 3 94 38 10 62 70 17
|
||||
18
|
||||
1741
|
||||
65 39 4 31 13 96 25 59 42 35 46 19 97 1 15 62 47 39 31 2
|
||||
19
|
||||
1377
|
||||
87 1 72 19 88 74 88 22 18 41 35 44 41 71 71 72 38 97 49 19
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
50
|
||||
5
|
||||
1328042058
|
||||
0
|
||||
1290
|
||||
75 26 48 26 77
|
||||
1
|
||||
2352
|
||||
87 37 4 67 94
|
||||
2
|
||||
362
|
||||
13 25 92 4 9
|
||||
3
|
||||
305
|
||||
11 95 92 14 57
|
||||
4
|
||||
262
|
||||
41 49 72 93 29
|
||||
5
|
||||
1250
|
||||
43 12 45 54 79
|
||||
6
|
||||
2170
|
||||
93 59 5 21 55
|
||||
7
|
||||
1601
|
||||
69 17 98 20 73
|
||||
8
|
||||
2039
|
||||
80 46 93 6 65
|
||||
9
|
||||
1628
|
||||
13 20 17 18 86
|
||||
10
|
||||
483
|
||||
24 52 79 75 25
|
||||
11
|
||||
285
|
||||
72 44 11 25 39
|
||||
12
|
||||
1092
|
||||
38 92 16 16 76
|
||||
13
|
||||
936
|
||||
81 75 89 77 24
|
||||
14
|
||||
2349
|
||||
83 95 81 28 38
|
||||
15
|
||||
473
|
||||
88 33 92 24 5
|
||||
16
|
||||
2325
|
||||
26 10 45 15 91
|
||||
17
|
||||
747
|
||||
6 45 61 77 29
|
||||
18
|
||||
970
|
||||
89 2 39 36 22
|
||||
19
|
||||
434
|
||||
67 62 28 16 27
|
||||
20
|
||||
1258
|
||||
70 62 94 32 39
|
||||
21
|
||||
2405
|
||||
30 82 87 46 31
|
||||
22
|
||||
862
|
||||
89 29 23 21 46
|
||||
23
|
||||
298
|
||||
30 29 1 81 18
|
||||
24
|
||||
2014
|
||||
68 94 55 28 93
|
||||
25
|
||||
2608
|
||||
21 20 91 70 58
|
||||
26
|
||||
1737
|
||||
78 42 67 89 85
|
||||
27
|
||||
2214
|
||||
46 80 91 54 58
|
||||
28
|
||||
1910
|
||||
99 94 4 96 97
|
||||
29
|
||||
2245
|
||||
10 35 60 62 10
|
||||
30
|
||||
2211
|
||||
17 8 38 46 79
|
||||
31
|
||||
547
|
||||
23 41 25 60 93
|
||||
32
|
||||
2237
|
||||
83 65 90 19 2
|
||||
33
|
||||
1327
|
||||
47 4 93 97 87
|
||||
34
|
||||
700
|
||||
86 71 13 13 17
|
||||
35
|
||||
1011
|
||||
18 30 65 7 18
|
||||
36
|
||||
2001
|
||||
67 14 25 44 10
|
||||
37
|
||||
1230
|
||||
46 32 34 7 50
|
||||
38
|
||||
1020
|
||||
4 50 47 73 8
|
||||
39
|
||||
1918
|
||||
14 30 98 15 26
|
||||
40
|
||||
1001
|
||||
4 27 91 66 14
|
||||
41
|
||||
1383
|
||||
20 98 11 70 21
|
||||
42
|
||||
1229
|
||||
88 39 46 97 15
|
||||
43
|
||||
2594
|
||||
50 84 50 33 10
|
||||
44
|
||||
403
|
||||
84 65 77 97 85
|
||||
45
|
||||
1515
|
||||
58 12 5 64 46
|
||||
46
|
||||
431
|
||||
93 58 14 73 42
|
||||
47
|
||||
1971
|
||||
76 45 47 28 18
|
||||
48
|
||||
939
|
||||
50 49 80 4 36
|
||||
49
|
||||
2028
|
||||
30 15 45 87 2
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
50
|
||||
10
|
||||
1958948863
|
||||
0
|
||||
793
|
||||
46 61 3 51 37 79 83 22 27 24
|
||||
1
|
||||
2280
|
||||
52 87 1 24 16 93 87 29 92 47
|
||||
2
|
||||
939
|
||||
79 51 58 21 42 68 38 99 75 39
|
||||
3
|
||||
2591
|
||||
45 25 85 57 47 75 38 25 94 66
|
||||
4
|
||||
1540
|
||||
97 73 33 69 94 37 86 98 18 41
|
||||
5
|
||||
2386
|
||||
10 93 71 51 14 44 67 55 41 46
|
||||
6
|
||||
812
|
||||
44 28 58 50 94 34 23 80 37 24
|
||||
7
|
||||
2524
|
||||
24 90 56 51 34 39 19 82 58 23
|
||||
8
|
||||
1370
|
||||
85 94 64 21 72 76 97 33 56 68
|
||||
9
|
||||
1319
|
||||
75 59 43 19 36 62 78 68 20 50
|
||||
10
|
||||
2388
|
||||
66 64 48 63 88 74 66 47 2 93
|
||||
11
|
||||
961
|
||||
49 2 69 91 51 28 67 74 39 22
|
||||
12
|
||||
2831
|
||||
95 16 96 11 41 78 7 26 91 64
|
||||
13
|
||||
2790
|
||||
61 35 35 6 71 43 23 61 81 81
|
||||
14
|
||||
2076
|
||||
19 53 82 31 94 98 67 95 33 94
|
||||
15
|
||||
2519
|
||||
47 40 53 63 99 83 8 55 14 97
|
||||
16
|
||||
1981
|
||||
84 81 64 36 11 91 77 11 88 54
|
||||
17
|
||||
695
|
||||
13 26 11 39 97 27 71 42 22 82
|
||||
18
|
||||
2133
|
||||
11 85 61 57 44 6 85 72 36 11
|
||||
19
|
||||
1871
|
||||
19 4 36 47 77 82 29 14 65 91
|
||||
20
|
||||
1495
|
||||
98 4 53 56 69 60 49 8 79 23
|
||||
21
|
||||
754
|
||||
2 10 87 65 91 44 3 98 23 32
|
||||
22
|
||||
783
|
||||
85 63 88 59 38 43 94 90 66 26
|
||||
23
|
||||
984
|
||||
44 96 10 4 25 76 76 36 5 22
|
||||
24
|
||||
2004
|
||||
7 55 32 10 87 99 95 75 15 12
|
||||
25
|
||||
2269
|
||||
73 71 38 12 7 66 48 69 51 23
|
||||
26
|
||||
1771
|
||||
19 66 25 62 66 11 4 26 2 34
|
||||
27
|
||||
2030
|
||||
69 94 24 43 54 35 37 24 81 87
|
||||
28
|
||||
2603
|
||||
12 7 90 49 86 52 82 55 12 59
|
||||
29
|
||||
2150
|
||||
73 15 7 54 49 8 57 98 40 2
|
||||
30
|
||||
2157
|
||||
85 11 11 87 3 40 61 86 59 38
|
||||
31
|
||||
2187
|
||||
23 99 49 29 48 62 6 30 32 84
|
||||
32
|
||||
937
|
||||
53 37 2 2 44 25 97 92 16 62
|
||||
33
|
||||
728
|
||||
16 50 76 18 93 24 5 94 87 10
|
||||
34
|
||||
510
|
||||
88 56 17 75 37 30 27 66 78 11
|
||||
35
|
||||
2786
|
||||
8 69 32 39 82 1 95 47 41 93
|
||||
36
|
||||
2134
|
||||
26 22 39 77 31 73 46 3 43 57
|
||||
37
|
||||
1046
|
||||
42 56 9 69 59 27 92 41 94 81
|
||||
38
|
||||
2849
|
||||
58 67 83 15 78 16 46 41 1 10
|
||||
39
|
||||
1956
|
||||
63 63 69 78 33 91 52 47 93 40
|
||||
40
|
||||
2456
|
||||
7 96 67 68 36 33 8 89 22 62
|
||||
41
|
||||
1105
|
||||
2 74 28 37 3 11 11 28 93 49
|
||||
42
|
||||
1560
|
||||
44 4 88 22 58 99 7 39 62 90
|
||||
43
|
||||
1745
|
||||
38 42 23 41 10 2 54 80 53 34
|
||||
44
|
||||
2216
|
||||
24 40 91 92 98 60 72 47 30 11
|
||||
45
|
||||
1157
|
||||
76 30 71 67 6 90 57 57 34 81
|
||||
46
|
||||
1317
|
||||
85 93 3 24 44 36 85 74 27 51
|
||||
47
|
||||
2372
|
||||
61 36 26 87 62 62 22 38 30 21
|
||||
48
|
||||
777
|
||||
32 25 41 91 24 15 87 59 54 39
|
||||
49
|
||||
972
|
||||
90 87 96 31 94 3 65 5 77 27
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
50
|
||||
20
|
||||
1539989115
|
||||
0
|
||||
2509
|
||||
52 63 82 16 63 94 79 22 80 96 53 54 71 27 95 3 92 80 61 74
|
||||
1
|
||||
2039
|
||||
95 99 21 26 55 34 21 6 13 3 19 67 90 93 53 80 62 38 86 38
|
||||
2
|
||||
3096
|
||||
42 69 79 46 59 89 93 24 64 50 99 25 59 49 54 78 11 55 16 4
|
||||
3
|
||||
2950
|
||||
75 70 95 66 35 62 32 55 77 57 62 77 82 63 22 32 83 34 42 31
|
||||
4
|
||||
1249
|
||||
44 53 46 76 21 47 8 48 17 66 88 38 22 65 84 53 87 85 14 62
|
||||
5
|
||||
2481
|
||||
57 21 23 31 59 66 45 57 78 84 93 98 88 34 54 43 66 44 92 39
|
||||
6
|
||||
3193
|
||||
89 10 40 36 78 76 37 78 82 98 34 96 35 10 2 85 98 47 67 97
|
||||
7
|
||||
3253
|
||||
53 31 95 8 25 15 78 5 4 55 72 20 49 56 80 19 42 66 77 57
|
||||
8
|
||||
2123
|
||||
84 80 87 37 30 18 26 50 72 70 42 15 78 51 84 48 23 19 46 9
|
||||
9
|
||||
2390
|
||||
62 18 37 21 38 54 98 83 93 32 65 36 69 97 66 49 45 66 41 54
|
||||
10
|
||||
1764
|
||||
91 5 24 3 78 24 17 70 68 31 39 65 76 52 25 66 52 61 78 13
|
||||
11
|
||||
2940
|
||||
14 18 24 76 79 55 25 21 25 64 79 97 2 46 16 22 6 60 3 47
|
||||
12
|
||||
1635
|
||||
95 17 65 67 58 96 21 71 67 11 9 27 14 16 79 37 3 98 72 6
|
||||
13
|
||||
3171
|
||||
89 71 62 5 44 10 28 58 80 9 26 25 3 50 90 51 64 82 95 70
|
||||
14
|
||||
2670
|
||||
4 90 19 47 38 12 68 36 43 32 72 61 22 96 51 82 55 79 53 19
|
||||
15
|
||||
2932
|
||||
95 93 67 72 76 96 24 50 93 58 29 24 26 85 29 59 97 71 59 97
|
||||
16
|
||||
2054
|
||||
2 14 66 66 70 53 62 31 21 98 36 97 44 61 29 88 83 28 34 41
|
||||
17
|
||||
3238
|
||||
97 49 6 56 72 92 89 86 33 95 48 61 1 76 90 77 42 74 66 1
|
||||
18
|
||||
2466
|
||||
68 52 65 95 85 77 60 29 14 25 57 75 4 30 83 19 81 27 42 57
|
||||
19
|
||||
2384
|
||||
20 7 59 49 8 6 64 30 30 4 95 92 16 90 83 32 92 33 63 60
|
||||
20
|
||||
3473
|
||||
33 78 2 47 10 91 38 93 59 45 93 73 55 42 19 52 68 13 27 62
|
||||
21
|
||||
3290
|
||||
51 57 67 26 84 14 90 49 83 60 79 21 43 88 95 9 46 9 92 14
|
||||
22
|
||||
2086
|
||||
98 41 82 81 42 41 87 83 85 87 88 29 87 37 87 96 56 12 8 90
|
||||
23
|
||||
2560
|
||||
8 75 90 56 67 30 1 89 85 31 77 3 35 43 12 23 88 51 65 76
|
||||
24
|
||||
3253
|
||||
85 98 30 76 20 85 99 44 70 1 94 96 76 88 34 64 50 16 34 12
|
||||
25
|
||||
3205
|
||||
86 93 63 66 24 17 34 38 35 96 39 51 98 91 23 22 13 49 6 89
|
||||
26
|
||||
2534
|
||||
73 33 5 36 75 23 9 62 2 22 74 26 78 14 44 37 23 83 42 37
|
||||
27
|
||||
2039
|
||||
4 75 93 53 23 60 22 45 76 95 46 44 81 63 30 3 13 48 39 35
|
||||
28
|
||||
2273
|
||||
40 68 53 26 33 76 74 22 46 73 17 56 48 65 82 52 49 13 2 91
|
||||
29
|
||||
2062
|
||||
98 33 85 52 60 39 14 85 72 77 30 31 25 74 83 44 18 78 7 69
|
||||
30
|
||||
1909
|
||||
12 60 81 29 20 85 14 39 69 30 62 64 81 71 42 11 50 96 85 55
|
||||
31
|
||||
2432
|
||||
59 82 73 36 75 10 84 98 46 88 77 38 27 8 56 21 94 77 32 48
|
||||
32
|
||||
2624
|
||||
44 24 34 68 83 65 75 56 3 14 43 44 84 39 89 85 71 68 14 56
|
||||
33
|
||||
3325
|
||||
46 99 74 21 26 15 37 68 57 22 98 46 59 95 38 6 64 88 74 84
|
||||
34
|
||||
3427
|
||||
2 4 13 71 92 55 32 84 71 93 48 66 98 82 96 40 31 77 59 22
|
||||
35
|
||||
1318
|
||||
41 97 78 61 29 41 29 77 77 48 14 31 14 17 10 68 21 76 95 51
|
||||
36
|
||||
1539
|
||||
28 24 35 71 39 28 32 67 33 10 45 48 32 38 3 30 2 73 48 43
|
||||
37
|
||||
3223
|
||||
83 50 20 69 14 93 89 53 49 7 25 27 95 69 53 35 63 92 37 50
|
||||
38
|
||||
1703
|
||||
28 55 16 28 74 88 12 46 59 14 98 82 30 17 97 58 58 72 59 62
|
||||
39
|
||||
1051
|
||||
21 91 48 86 66 27 47 24 82 91 30 51 13 24 11 31 36 87 4 61
|
||||
40
|
||||
1512
|
||||
80 46 12 27 86 77 19 52 59 5 90 90 68 66 65 11 64 66 42 10
|
||||
41
|
||||
2589
|
||||
71 58 11 41 10 81 97 96 70 43 92 63 19 75 47 11 52 98 93 87
|
||||
42
|
||||
3248
|
||||
4 17 80 86 27 19 7 2 76 30 35 85 57 52 76 6 8 40 32 99
|
||||
43
|
||||
2047
|
||||
60 47 9 55 8 76 12 88 10 79 13 36 65 59 22 59 94 31 30 40
|
||||
44
|
||||
3333
|
||||
34 82 24 17 7 55 43 33 65 39 75 69 13 4 17 64 51 75 16 91
|
||||
45
|
||||
1760
|
||||
55 6 76 62 97 67 89 27 19 34 55 67 63 73 14 65 36 45 95 64
|
||||
46
|
||||
2333
|
||||
53 15 32 96 84 65 14 49 77 77 80 81 26 56 11 23 82 98 58 62
|
||||
47
|
||||
2400
|
||||
96 91 35 59 56 8 33 78 86 81 67 18 96 19 69 80 30 90 12 53
|
||||
48
|
||||
2142
|
||||
37 74 66 53 61 18 56 82 21 11 3 81 53 39 91 75 17 4 95 33
|
||||
49
|
||||
1231
|
||||
37 42 48 93 9 56 57 65 75 10 93 72 94 51 53 63 21 23 21 16
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue