CHANGES

//------------------------------------------------------------------------------------------------------
* Version 1.11, "Hendaye" - March 16, 2026

We have restarted development of the Geneva library!

Recommended versions:
- Boost version 1.90 or higher is required. You may try with Boost 1.89 (untested). Note that the
  Boost.System library linkage has been removed from the build-system, as that library is now header-only. So
  in order to get Geneva to compiler with older Boost versions you may have to modify the build-system (see
  the various instances of CommonGenevaBuild.cmake).
- CMake version 3.27 or higher is required
- GCC is recommended to be at least version 13, clang should be at least version 18.
  Earlier versions might work if C++20 is sufficiently supported
- We suggest to use Ubuntu 24.04 LTS as the host platform if you plan to use the CUDA example.

********************** INCOMPATIBILITIES / PLEASE NOTE *************************

- Geneva now uses C++20 constructs, hence you need a compiler that supports this.
  It is thus also recommended to compile Boost with C++20 support, to be consistent

************************* Misc *************************************************

- Where CUDA is available, random numbers will now be calculated on the GPU
- A new CUDA example has been added
- boost::optional, boost::any, boost::filesystem, boost::variant have been replaced
  by their C++17 counterparts
- Benchmarks for courtier and geneva have been moved to their own benchmarks top-level
  directory and are no longer considered to be tests
- An extensive CUDA example has been implemented

********************************************************************************

Current issues with this development release:
- The C++ standard is not set centrally, but individually for each library

//------------------------------------------------------------------------------------------------------
* Version 1.10, "Genova" - March 10, 2020

Recommended versions:
- Boost version 1.70 or higher is required.
- CMake version 3.1 or higher is required.
- GCC is recommended to be at least 5.1, earlier versions
  might work if C++14 is sufficiently supported.

The main changes for this release include:

************************ LICENSE CHANGE / PLEASE NOTE **************************

 - Geneva is now released under the Apache License, version 2.0.
   A small number of files (copied from, or based on external code)
   are still covered by the Boost Software License v1, as before.

********************************************************************************

New features:
 - Geneva has a new Websocket consumer, based on the new Boost library Beast.

Architectural changes:
 - Rework of the executor and broker hierarchy.
 - Geneva now uses "#pragma once" instead of include guards. Chances are,
   that this will not affect anyone as compilers that support C++14 will
   most likely also understand this (non-standard) directive. This is the
   case for all recent GCC- and CLang-compilers as well as MSVC++.

********************** INCOMPATIBILITIES / PLEASE NOTE *************************

 - Changed Gem::Common::serializationMode::SERIALIZATIONMODE_XML to
   Gem::Common::serializationMode::XML, similar for TEXT and BINARY.
 - GThreadPool will no longer initialize itself with the number of hardware
   threads when called with a number of threads == 0. This had let to many
   threadpools each claiming as many threads as there were (logical) cores
   in the CPU. Note that the threadpool will throw when called with
   nThreads == 0, so you might want to adapt your configuration files.
 - Removal of a number of deprecated functions from GParameterSet:
    * setDirtyFlag() --> use mark_as_due_for_processing()
    * isDirty()      --> use (this->is_due_for_processing() || this->has_errors())
    * isClean()      --> use is_processed()
    * registerSecondaryResult()    --> use setResult()
    * getNumberOfFitnessCriteria() --> use getNStoredResults()
    * setNumberOfFitnessCriteria() --> use setNStoredResults()
    * getCachedFitness()      --> use raw/transformed_fitness()
    * transformedFitness()    --> use transformed_fitness()
    * fitness()               --> use raw/transformed_fitness() and process()
    * fitnessVec()            --> use raw_fitness_vec() and/or transformed_fitness_vec()
    * transformedFitnessVec() --> use transformed_fitness_vec()
    * markAsInvalid()         --> use force_set_error()
    * markedAsInvalidByUser() --> use has_errors()
   These functions have been marked as deprecated for a long time.
 - Removed set/getPerItemCrossOverProbability() from GParameterSet. This
   is a characteristic of Evolutionary Algorithms (and related optimization
   algorithms) and is handled there, through the amalgamationLikelihood
   property.
 - Removed the old checkReleationShipWith()-hierarchy completely, in favour
   of the compare()-hierarchy. If your individuals or custom optimization
   algorithms still implement this, you need to remove and replace it with
   the compare()-function.
 - The poorly named GStdThreadGroup was renamed to GThreadGroup.
 - GStdSimpleVectorInterfaceT was renamed to GPODVectorT.
 - GPtrVectorT was renamed to GPtrVectorT.
 - The signature of
   G_OptimizationAlgorithm_Base::GBasePluggableOM::informationFunction and
   derivatives was changed to
   (infoMode, G_OptimizationAlgorithm_Base const * const) to better protect
   the passed information. This should have no effect on you unless you have
   created custom pluggable optimization monitors.
 - Some public virtual functions were replaced by private or protected
   alternatives. The base-class then holds a wrapper function calling the
   virtual function. This has happened to follow common C++ coding practice.
   Throughout Geneva:
     * name() --> name_() / private
     * addConfigurationOptions() --> addConfigurationOptions_() / protected
     * compare() --> compare_() / protected (note: you need to add a friend
       declaration, see e.g. the example individuals)
   G_OptimizationAlgorithm_Base and derivatives:
     * resetToOptimizationStart() --> resetToOptimizationStart_() / protected
     * getNProcessableItems() --> getNProcessableItems_() / private
     * cycleLogic() --> cycleLogic_() / private
     * actOnStalls() --> actOnStalls_() / private
   GParameterBase and derivatives:
     * adaptImpl() --> adapt_() / private
   G_Interface_OptimizerT and derivatives (all optimization algorithms and Go2):
     * optimize(offset) --> optimize_(offset) / private
     * runFitnessCalculation() --> runFitnessCalculation_() / private
     * getBestGlobalIndividual() --> getBestGlobalIndividual_() / private
     * getBestGlobalIndividuals() --> getBestGlobalIndividuals_() / private
     * getBestIterationIndividual() --> getBestIterationIndividual_() / private
     * getBestIterationIndividuals() --> getBestIterationIndividuals_() / private
     * getAlgorithmPersonalityType() --> getAlgorithmPersonalityType_() / private
     * getAlgorithmName() --> getAlgorithmName_() / private
     * getIteration() --> getIteration_() / private
   GCommonInterfaceT and derivatives:
     * modify_GUnitTests() --> modify_GUnitTests_() / protected
     * specificTestsNoFailureExpected_GUnitTests() -->
       specificTestsNoFailureExpected_GUnitTests_() / protected
     * specificTestsFailuresExpected_GUnitTests() -->
       specificTestsFailuresExpected_GUnitTests_() / protected
   GBasePluggableOM:
     * informationFunction() --> informationFunction_() / private

   As the base class still holds a public wrapper function, this might have
   no effect on you unless you have overloaded these functions in your own
   code. One case where this may be is if you have used the GStarterIndividual
   from example 10 as the basis for your own individuals. In this case the
   test-functions need to be renamed and moved to the protected section (see
   GCommonInterfaceT above).
 - The virtual customHalt() is now called customHalt_() in line with Geneva
   conditions, and has moved to the private section of
   G_OptimizationAlgorithm_Base and derivatives.

********************************************************************************


//------------------------------------------------------------------------------------------------------
* Version 1.9.0-GSI, "Novara" - January 19, 2018

  This is a release made for GSI Darmstadt and was used in production
  for their research. GSIs main platform is Linux. No tests have been
  made on other platforms than Linux.

Recommended versions:
- Boost: 1.62; Minimum Boost version: 1.59.
- CMake version 3.1 or higher is required.
- GCC is recommended to be at least 5.1, earlier versions might
  work if C++14 is sufficiently supported.

The main changes for this release include:

******************************* PLEASE NOTE ************************************

 - There was a slight change for the API of GFactoryT. Retrieving an object
   as a (derived) type now requires a call to get_as<derived_type> instead
   of get<derived_type>, as otherwise the compiler confuses an overload of
   get() in classes derived from GFactoryT.
 - In order to register pre- and post-processors, factories for individuals
   should now be derived from GParameterSetFactory instead of
   GFactoryT<GParmeterSet>. See the GFunctionIndividualFactory inside of
   GFunctionIndividual.hpp/.cpp for an example.
 - Removed GOptimizationMonitorT and derivatives, as these were redundant
   and the same functionality is available through pluggable optimization
   monitors. This may require re-implementation of custom, user-defined
   GOptimizationMonitorT-derivatives as a pluggable optimization monitor.
   Note that the logic of both is the same so that most of the work should
   be possible via "cut & paste".
 - Optimization algorithms have been consolidated into a single class each.
   Formerly, e.g. in the case of evolutionary algorithms, there was a
   GBaseEA, GMultiThreadedEA, GSerialEA and GBrokerEA-class. By default,
   all evaluation now happens through the broker, which in turn decides
   about the type of parallelisation used. Evolutionary algorithms still
   have a multi-threaded mode implemented inside of the class, so that
   meta-optimization is better supported. Users should however use the
   optimization algorithms that communicate through the broker.
 - Boost 1.58 is NOT recommended, due to severe bugs affecting Geneva
   (Serialization, UUID).
 - As Geneva must now be compiled in C++14 mode and Boost is a mixture
   of header-only- and binary-libraries, it is highly recommended to also
   compile Boost in C++14-mode.
 - Many classes were given better names. E.g., the main optimization base
   class has been renamed to G_OptimizationAlgorithm_Base.

********************************************************************************

 - Made GBasePluggableOM<> independent of G_OptimizationAlgorithm_Base<>.
   The monitor base class is no longer an embedded class of
   G_OptimizationAlgorithm_Base<>. If you develop your own optimization
   monitors, you need to derive them from a new class -- see the collection
   in GPluggableOptimizationMonitorsT.hpp for examples.
 - Added the option to specify a minimum number of iterations and a minimum
   time that the optimization should run. Only interactive halt-criteria
   (Ctrl-C, "touched halt") are observed, as long as the minimum number of
   iterations / timeframe are not met. Examine the sample config files for
   these options and add them to your own files. You may also let Geneva
   generate fresh files for you.
 - Modified the code so that it compiles under Windows 10 / MSVC 14 . Note
   that Windows-related problems still remain.
 - Gave GHistogram1D the ability to automatically detect the data range.
 - Added a pluggable optimization monitor for processing timings (as a
   1D-histogram as well as as a function of the iteration with a 2D-histogram;
   the module will also generate a CSV file).
 - Added a class for serializable function objects.
 - Added the option to register (serializable) function options with
   GParameterSet-derivatives for pre- and postprocessing in conjunction
   with the evaluation.
 - Added a post-processor for running a sub-optimization on an individual.
 - Gave GDataCollector1T and GDataCollector2T (and with them GHistogram1D
   and GHistogram2D) the ability to automatically detect ranges.
 - Added the option to set the initial wait factor of GBrokerExecutorT in
   the config file of optimization algorithms.
 - The maximum size of GBoundedBufferT is now defined via a value template
   parameter, and unbounded buffers are possible (set the capacity to 0).
 - Renamed class GBrokerConnector2T to GBrokerExecutorT.
 - Reworked the entire broker architecture in order to make it more scalable.
 - Removed all thread_local usages from Geneva.
     * The ramdomInit()-function of GParameterBase derivatives must now be
       called with a GRandomBase-argument, i.e. it must be supplied with a
       random number generator. This happens to get rid of thread_local
       variables which have turned out to be a problem under Windows if
       custom parameter types are introduced, their randomInit_() function
       now also needs to receive a GRandomBase-argument.
     * Moved away from GThread (interruptible threads), as this could only
       be implemented via thread_local.
     * Added a thread group solely based on std::thread and moved GThreadPool
       to this implementation.
 - Renamed GBoostThreadConsumerT to GStdThreadConsumerT, as it is now based
   on std::thread.
 - Gave Go2 a new command line option --maxClientDuration which allows to
   limit the maximum runtime of a client. Note that the actual runtime may
   be longer, as a running workload will not be interrupted.
 - Renamed the GBrokerSelfCommunication-test to GConsumerPerformance and
   added the new ws-consumer for debugging purposes.
 - Consumers must now be registered in one go. Once this registration has
   taken place, no new consumers may be registered. This happens so that the
   broker may reliably retrieve information about registered consumers just
   once before an optimization run rather than having to check repeatedly.
 - Eliminated the need for new optimization algorithms to specify the
   submission return mode. GExecutorT now retrieves this information from
   the broker, which in turn retrieves it from registered consumers.
 - Added a new example showing how to integrate OpenCL with Geneva.
 - Exceptions are now thrown at the error-location rather than being raised
   by the global logger.


//------------------------------------------------------------------------------------------------------
* Version 1.8, "Torino" - August 13, 2016

Recommended versions:
- Boost: 1.59; Minimum Boost version: 1.57.
- CMake Version 3.1 or higher is required.
- GCC is recommended to be at least 5.1, earlier versions might
  work if C++14 is sufficiently supported.

The main changes for this release include:

******************************* PLEASE NOTE ************************************

Support for C++ standards prior to C++14 was dropped. This allowed the
following changes. NOTE THAT SOME OF THESE MAY REQUIRE CHANGES ON YOUR
OWN CODE.

 - std::sort is now based on lambda expressions rather than on function
   objects.
 - boost::bind was replaced with std::bind or C++11 lambda expressions.
 - boost::shared_ptr was replaced with std::shared_ptr. As a consequence
   the Go2 interface had to be changed. If you want to define your own
   command line options, you may now transfer a
   boost::program_options::options_description object. This simplifies
   the specification of user-defined command line options, but you will
   have to change your main() function, if you have used the old
   Go2-interface before.
 - Pluggable optimization monitors may now be registered solely through
   their std::shared_ptr, making the interface more logical.
 - std::thread, std::chrono, C++14 atomics and std::array were used
   instead of their Boost counterparts.
 - Boost 1.58 ist NOT recommended, due to a severe bug affecting Geneva.

********************************************************************************

 - Gem::Common::GSerializableI was renamed GCommonInterfaceT and now
   holds a lot of functionality formerly located in GObject. This was
   done so that other classes (including those found in the "Common"
   library) may profit from the serialization and testing infrastructure.
 - Moved from boost::tuple to std::tuple and associated functions
   (make_tuple, std::get, etc.).
 - Moved all boost::*int*_t to their C++11 counterparts.
 - Added a G_DEPRECATED macro so sole old functions may remain,
   but are marked as deprecated. Such functions may go away without
   further notice in future versions of Geneva.
 - Rework of the Hap random library. Unless you use Hap directly, this
   should not affect you. GRandomT now has the normal engine-interface
   of C++11/14 random number engines. Generation of most random
   distributions is done using standard functions. A seperate,
   standard-compliant distribution was added for bi_normal_distribution.
 - Support for CMake 2.8 was dropped, for building Geneva at least
   CMake version 3.1 is now required.
 - Ported to Boost 1.59.


//------------------------------------------------------------------------------------------------------
* Version 1.6.1, "Ivrea - Via Arduino" - April 20, 2015

Recommended version of Boost: 1.57; Minimum Boost version: 1.53.

The main changes for this release include:

******************************* PLEASE NOTE ************************************

 - Geneva now requires the Boost::atomic component of Boost. You will
   need to install this additional component if your Boost installation
   is not a complete one, for instance in the case of a system-provided
   Boost in some Linux distributions.
 - The minimal BOOST version required for compiling Geneva is now v1.53.

********************************************************************************

 - Rework of the GThreadPool class: threads are now started upon the
   first task submission, so default-constructed (unused) pools do not
   start a plethora of idle threads. The pool may now be resized while
   threads are already running.
 - Rework of the GRandomFactory / GRandomT-combo. In particular, "unused"
   random numbers are now recycled and given back to the random factory.
   The overhead of the creation of random packages should be reduced, as
   the corresponding objects do not usually need to be re-allocated anymore.
 - Random numbers are now distributed to parameter objects and adaptors
   via thread local storage.
 - The checkRelationshipWith-hierarchy was removed, in favour of a new
   'compare()' API. This is used for unit tests, in particular of
   indivuduals. GObject still contains a 'checkRelationshipWith()' function
   which in turn calls compare, so that the change should not affect users.
 - Ported to Boost 1.58. Please note that Boost 1.58 seems to have a
   serialization-related bug, so that we currently do NOT recommend to
   use this Boost version.

//------------------------------------------------------------------------------------------------------
* Version 1.6, "Ivrea" - March 10, 2015

The main changes for this release include:

****************************** BREAKING CHANGES ********************************

 - Geneva now explicitely requires the Boost::unit_test_framework and the
   Boost::random components of Boost, as these are required at link time.
   You will need to install these additional components if your Boost
   installation is not a complete one, for instance in the case of a
   system-provided Boost in some Linux distributions.
 - The FindBoost.cmake module is not shipped with Geneva anymore, as it may
   interfere with using the system-provided version which often contains
   some system-specific fixes. Furthermore, it was actually not needed
   anymore, as we currently require at least CMake 2.8 which comes with
   a good enough version of that module.
 - When optimization algorithms are instantiated directly rather than
   through the Go2-class, it is now necessary to explicity initialize Geneva
   using the GenevaInitializer class. See 06_GDirectEA for an example of how
   this is done. With this change, static Geneva libraries may now be built
   where needed.
 - If you register a signal handler, please use now G_SIGHUP instead of
   SIGHUP to get portable code.
 - Removed the (currently unused) GCanvas32 class, as it results in a
   (justified) overflow warning under MS Windows.

********************************************************************************

 - Added native, experimental support for MS Windows using the
   Visual C++ compiler, allowing both static and dynamic libraries.
 - Step sizes in Geneva's gradient descent implementation are now given in
   permille of the allowed or expected value range of the parameters. Steps
   in each direction used to calculate the gradient are now scaled according
   to this value range.
 - Calculations in Geneva's gradient descent implementation are now carried
   out as long double to preserve accuracy, where possible.
 - Moved all filesystem I/O to the Boost::filesystem library.
 - Fixed Launchpad bug #1427577 --> "best past" of EA not transfered to SA.

//------------------------------------------------------------------------------------------------------
* Version 1.4.1, "Fénis" - January 23, 2015

The main changes for this release include:

****************************** BREAKING CHANGES ********************************

 - The method addConfigurationOptions() has lost the (unnecessary)
   "showOrigin" parameter.
 - The handling of the BOOST location variables in the Geneva configuration
   file "scripts/genevaConfig.gcfg" was changed. The changes are minor, but
   you will need to adapt your current configuration. Read the configuration
   file comments for more details. Thanks to these changes, if a binary OS
   Boost installation is available, the "prepareBuild.sh" script will now be
   able to configure a default Geneva build without requiring any
   configuration file.

********************************************************************************

 - Removed GExternalSetterIndividual in favour of a more versatile
   enforceFitnessUpdate().
 - Fixed Bug #1399716 in Launchpad --> Calling go & "ea" & "sa" crashed.
 - Introduced a more versatile syntax for configuration options in
   GParserBuilder. You can now say things like:
     gpb.registerFileParameter<boost::uint32_t>(...) << "my comment";
 - Added an option to override default values of configuration options
   that were set by a parent class (needed for GParserBuilder).
 - Added support for MS Windows using the Cygwin environment.
 - Restructured the build system, creating a new shared CMake module
   "CommonGenevaBuild" which may be used to build independent Geneva
   applications as well as any of the Geneva examples or tests out of
   the main tree. This module is also used for the normal Geneva build.
   The "IndependentBuild" CMake module was removed.
 - The build-system now allows for libraries, headers and other files
   to be installed in independent locations: to that aim, you may define
   the variables INSTALL_PREFIX_LIBS, INSTALL_PREFIX_INCLUDES,
   INSTALL_PREFIX_DOCS, and INSTALL_PREFIX_DATA when running cmake.

//------------------------------------------------------------------------------------------------------
* Version 1.4, "Aosta" - August 8, 2014

The main changes for this release include:

****************************** BREAKING CHANGES ********************************

 - Constraint objects now use a new nomenclature to flag valid and invalid
   checks. Values > 1 are considered to be "invalid" as before. Values < 0
   are now flagged as invalid (with an automatic calculation of an
   "invalidity"), unless the "allowNegative" parameter of the constraint
   objects has been set. In this case negative values are still considered
   to be valid in constraint objects.
 - Removed single precision floating point classes, as these were
   practically never used and are realistically unneded in the presence
   of double precision types. This might later be replaced by a
   compile-time #define of the base floating point type.
 - The CMakeLists.txt file of the 10_GStarter example can no longer be
   used for builds independent of the Geneva main source tree. Instead,
   if you want to build Example #10 independently (for example in order
   to build your own code on top), rename CMakeLists.txt-independent to
   CMakeLists.txt . This allows independent builds. All other Geneva
   examples can only be built inside of the Geneva source tree.
   CMakeLists.txt-independent should however give you a good starting
   point to make other examples independent from the main Geneva source
   tree.
 - As we do not have any testing facilities for older MacOS versions, and
   most users will upgrade to the newest version anyway, support for MacOS
   is now constrained to the latest version including all updates (i.e.,
   10.9 Mavericks, at the time of this release). Note that support for
   this OS is still experimental.
 - The CMAKE version required for compiling Geneva is now v2.8.

********************************************************************************

- The formula parser will now throw custom exceptions when invalid
  calculations (such as a division by 0) were requested. This allows
  you to deal with invalid parameters to your formulas more easily.
- MUCOMMANU-modes (single-eval and pareto) will now be the same as
  MUPLUSNU in the first iteration. All individuals will be evaluated
  in MUCOMMANU-mode in the first iteration.
- The adapt() call of individuals (used particularly in evolutionary
  algorithms) will now optionally take into account the validity of a
  given parameter set. I.e., if the parameter set does not satisfy the
  predefined constraints, adapt() will try a configurable number of times
  to find a parameter set that does satisfy the constraints. Alternatively,
  users may rely on the replacement-fitness calculated by Geneva for
  invalid solutions.
- The script "prepareBuild.sh" can now be called multiple times: it will
  do a "make clean-all" if a Makefile is found in the build-directory.
- The build-system was restructured and improved to simplify adding new
  platforms and to make it more modular.
- Added a target "make doc" to create reference documentation for the
  entire Geneva source tree.

The main bug fixes for this release include:
- Under certain circumstances, work items could be added more than once
  to the priority queue defining the best solutions found.

Recommended version of Boost: 1.55; Minimum Boost version: 1.48.

//------------------------------------------------------------------------------------------------------
* Version 1.2, "Mont Blanc" - March 22, 2014

The main changes for this release include:

****************************** BREAKING CHANGES ********************************

 - Sigma values of gauss adaption are now relative to the allowed or
   preferred value range of a parameter type. Values are given as a
   percentage of this value range. E.g., a sigma value of 0.1 and an
   allowed parameter range of [-50, 50] will result in the gaussian
   distribution using a "real" sigma value of 10.
 - The minimal BOOST version required for compiling Geneva is now v1.48.

********************************************************************************

 - Added a simple parser that allows to evaluate mathematical formulas
   like "sin({{var1}})*pow(2.,3.)".
 - Introduced a method to deal with dependent boundary conditions
   a.k.a. "constraints" (double parameters only at the moment).
 - Added three possibilities to treat invalid parameter sets (i.e.,
   parameter sets that violate a number of predefined constraints).
 - In this context, introduced a "transformed" and a "raw" fitness.
   The latter comes from the user's evaluation function, the former
   makes sure that individuals which violate one or more constraints
   still get a useful evaluation, without having to call the
   evaluation function.
 - Added a new "per-item" cross-over method to evolutionary algorithms.
 - Added a new mechanism to update adaptors in EA when optimization
   has stalled.
 - Based collection of best individuals on a priority queue and
   centralized the code for most cases (multi-populations and
   multi-criterion optimization need separate treatment).
 - Added a parser for parameter descriptions of the kind
   "d(MY_DPAR_01,-10.3,12.8,100)" to facilitate parameter scans from
   the command line (or in batch mode).
 - Added a new option to GParameterScan to randomly initialize a predefined
   number of work items. This "brute force" approach may help to find a
   good starting point. E.g., for the example 01_GSimpleOptimizer one
   may now run './GSimpleOptimizer -a "ps,ea" --parameterSpec="s(1000)"'.
   This would result in a random scan of 1000 work items. The best
   individuals found will then form the start values of an evolutionary
   algorithm.
 - Added further command line options (when using Go2), such as the
   maximum number of iterations or the maximum time for each algorithm
   type. Some options are now hidden and are only shown upon explicit
   request.
 - Added the ability to catch a SIGHUP signal and let
   G_OptimizationAlgorithm_Base<> exit gracefully, without discarding results.
   This requires that GObject::sigHupHandler is registered as a signal
   handler, which needs to be done by the user, e.g. in main().
 - In networked execution, the server now tells the client how long it
   should sleep before reconnecting. Repeated idle calls are so avoided,
   reducing the network load.
 - Added two functions for calculating a line best describing a set
   of data points.
 - Updated the GParallelisationOverhead test so that it automatically
   calculates the speed-up.
 - Added the possibility to specify the path to configuration files in
   an environment variable (GENEVA_CONFIG_BASENAME). Set this variable
   to the "/"-terminated path of a directory containg the "./config"
   sub-directory where the configuration files are to be found.
 - Added an option to enforce a specific C++ standard for the
   compilation procedure.
 - Starting with this version, stable release versions get an even
   minor version number.
 - Experimental port to MacOS 10.9.
 - Ported to Boost 1.55.

Recommended version of Boost: 1.55; Minimum Boost version: 1.48.

//------------------------------------------------------------------------------------------------------
* Version 1.0, "Chamonix" - August 31, 2013

The main changes for this release include:
 - Gave Go2 the ability to accept custom command line options from the user.
 - Updated all examples and tests.

Recommended version of Boost: 1.54; Minimum Boost version: 1.41.

//-----------------------------------------------------------------------------------------------------
* Version 0.9.11, "Route de Chamonix" - August 14, 2013

The main changes for this release include:
 - Added a parameter scan algorithm.
 - Separated Simulated Annealing from Evolutionary Algorithms, making
   it a first-class citizen.
 - Separated multi-populations from Evolutionary Algorithms, making
   them a first class citizen.
 - Evolutionary Algorithms are now based on GParameterSet (just like all
   other "basic" optimization algorithms, except for multi-populations).
 - Reworked the entire broker architecture (GBrokerExecutorT was replaced
   by GBrokerExecutorT, and the GBrokerT class as well as the
   GAsioSerialTCPConsumerT classes have been refactored).
 - The broker, as implemented, now acts solely on GParameterSet-derivatives.
   This simplifies the architecture.
 - Renamed GIndividual to the more fitting "GOptimizableEntity".
 - Removed the deprecated GIndividualFactoryT class in favor of the more
   general GFactoryT.
 - Gave optimization algorithm factories a common base class so generic
   access becomes easier.
 - Added global stores for GParameterSet-based consumers, optimization
   algorithms and corresponding monitor classes.
 - GParameterSet and GOptimizableEntity no longer depend on any specific
   optimization algorithms. As a consequence, all major concepts are now
   separated from each other, allowing for a far more independent development
   style. Adding new algorithms and also consumers has become far easier.
 - Gave GParameterBase objects a name to facilitate work with the
   GExternalEvaluatorIndividual. A name to a parameter makes it much easier
   to work with XML files and to identify the important variables.
 - Simplified the optimization monitor infrastructure.
 - Added pluggable optimization monitors that allow to easily monitor
   common properties of all optimization algorithms. In this context,
   added a monitor that allows to plot one or two variables together with
   their fitness for all individuals touched during the optimization.
 - Centralized conversion of smart pointers using a Gem::Common function.
 - Removed non-portable "long double" functions from
   GMathHelperFunctions.hpp/cpp.
 - Moved GConstrainedValueLimitT<T> from "max()" to "lowest()/highest()".
 - Added a simple logging framework, including exception handling, that
   allows to stream information to be logged.
 - Gave gemfony_error_condition the ability to be streamed.
 - Removed the deprecated utilities directory and application.
 - Removed most manual creation of ROOT output files in favor
   of GPlotDesigner.
 - Gave GPlotDesigner the ability to create 3D output through a new
   class GGraph3D.
 - Gave GPlotDesigner the ability to add more than one plot to the
   same sub-canvas.
 - Removed the deprecated Go class in favor of Go2 and updated all examples.
 - Made Go2 independent from specific optimization algorithms and consumers,
   thus broadening its scope. Note that during this rework, also most
   command line parameters have been changed, and that command line
   parameters specific to consumers are extracted at run-time from each
   consumer. If you are running Geneva through a script, this might mean
   that you need to adapt this script.
 - Added a new example "GStarter" meant as a starting point for the
   users' own projects.
 - Added an example that illustrates meta-optimization (i.e. usage of
   an evolutionary algorithm to optimize the configuration parameters
   of an optimization algorithm.
 - Added pluggable objects that allow to check parameter sets for validity,
   to be used in an infrastructure for dealing with multi-parameter constraints.
 - Instrumented most Geneva optimization classes with C++11 override
   statements, wrapped into defines so the code can be used with
   C++98-compilers. This allows to rule out a further class of errors,
   hence making the code more robust.
 - Ported to MacOS X (still highly experimental).
 - Ported to Boost 1.54.

Recommended version of Boost: 1.54; Minimum Boost version: 1.41.

//-----------------------------------------------------------------------------------------------------
* Version 0.9.10, "Route Blanche" - September 30, 2012

The main changes for this release include:
 - Streamlined the use of the workOn function family in GBrokerExecutorT.
 - Added an easier means to create ROOT plots from within Geneva
   ("GPlotDesigner").
 - Made constructors of simple collections more consistent with std::vector.
 - Added a custom threadpool library, as a temporary replacement until
   an official Boost threadpool library becomes available. Removed usage
   of external threadpool library from the code.
 - Added a test-suite capable of comparing the minimization capabilities
   of all implemented algorithms in all parallelization modes, thus
   providing a means to further improve our algorithms.
 - Support for automatic testing with CTest.
 - Support for compiling with Clang.
 - Ported to Boost 1.51.

//-----------------------------------------------------------------------------------------------------
* Version 0.9.9, "Route d'Annemasse" - December 17, 2011

The main changes for this release include:
 - Full documentation available at http://www.gemfony.eu
   (go to Infopool -> Manuals).

//-----------------------------------------------------------------------------------------------------
* Version 0.9.3, "Route de Bonneville" - November 10, 2011

The main changes for this release include:
 - Switched configuration files to JSON format, making it possible to
   create JavaScript based GUI interfaces for configuration files
 - Simplified and centralized creation and parsing of configuration
   options, so users may more easily configure their applications.
 - Introduced a new wrapper class Go2 that allows to aggregate
   different optimization algorithms, making the best results of the
   first algorithms available to their successors. Algorithms can now
   either be added in main() -- in which case the parallelization mode
   chosen for the corresponding objects is used -- or on the command
   line, in which case the parallelization mode can be modified on demand.
 - Introduced a new interface class G_Interface_OptimizerT, as the basis
   of G_OptimizationAlgorithm_Base and various wrapper classes.
 - Removed all std::pair in favor of boost::tuple (the future std::tuple).
 - Some renaming of variables. E.g.: renamed 'recoSchemes' to the
   more appropriate 'duplicationScheme', dito for this enums constants.
 - Renamed public cpp variables according to the library they
   are used in, GEM_<LIB>_<VAR>.
 - Renamed the cpp variable GENEVATESTING to GEM_TESTING.
 - Bumped the minimal Boost version to 1.41.
 - Forced Boost.Filesystem v3 for Boost >= 1.44.

//------------------------------------------------------------------------------------------------------
* Version 0.9.2, "Route de Meyrin" - August 4, 2011

The main changes for this release include:
 - Added the ability to individuals to store secondary evaluation
   criteria in addition the main criterion.
 - Added a first version of multi-criterion ("pareto front")
   optimization to Geneva's Evolutionary Algorithms.
 - Added a serial consumer, so all execution modes can now be handled
   independently from the optimization algorithms.
 - Added explicit initialization and finalization code so we know when
   objects get constructed or destroyed in the presence of singletons.
 - Added forced termination code if the library is linked with Boost
   versions affected by the termination problem in conjunction with gcc.
 - Added a mechanism to deposit data at a remote site, so it doesn't
   need to be (de-)serialized in each iteration. Note that, if you use
   this feature together with check-pointing, you need to make sure
   that un-serialized data is loaded.
 - Replaced the publicly visible waitFactor by minimum and maximum
   values for the waitFactor variable. It will now be updated
   automatically.
 - Renamed the former serial GSwarm class to the more logical
   GSerialSwarm, similarly GEvolutionaryAlgorithm -> GSerialEA, and
   GGradientDescent -> GSerialGD.
 - Added an option that allows an evolutionary algorithm population
   to grow up to a user-defined limit, so one can start with small
   populations and still have good coverage of the parameter space
   close to the optimum. This is meant to shorten optimization runs
   in multi-threaded mode, if the population size is much larger than
   the number of available compute units.
 - Renovated gradient descents and swarms.
 - Added a means to recursively extract lower and upper boundaries
   and initialization ranges from GParameterBase-derivatives.
 - Moved the GBrokerConnector to the courtier library, making it a
   template class and thus independent of the optimization code.
 - Removed the GINDIVIDUALBROKER macro for clarity reasons.
 - Moved much of the Broker-Populations functionality into the
   GBrokerConnector, thus making it more generic and the population
   classes easier to understand.
 - Removed remaining dependencies of the courtier lib on the core
   optimization framework.
 - Moved scripts to their own subdirectory.
 - Added individual tests for the common and courtier libs.
 - Adapted to Boost 1.47.

//------------------------------------------------------------------------------------------------------
* Version 0.9.1, "Route Cockroft" - February 12, 2011

The main changes for this release include:
 - Implemented Simulated Annealing, as part of Evolutionary Algorithms.
   NOTE: This SA implementation is still rather untested, use with care
   at this point.
 - Made sure that parameter objects always have an adaptor loaded. Before
   this it was empty by default.
 - Moved from BOOST_CLASS_EXPORT to the BOOST_CLASS_EXPORT_KEY and
   BOOST_CLASS_EXPORT_IMPLEMENTATION combo for serialization (except for
   Boost 1.40, where these macros didn't exist).
 - Added a new collection class GConstrainedDoubleCollection that allows
   to apply common upper and lower limits to a set of double values.
 - Made the adaptor hierarchy more consistent and added a "bi-gaussian"
   adaptor.
 - Cleaned up the GRandomBase/T and GRandomT classes, including an
   interface change.
 - Introduced more verbatim exceptions.
 - Cleaned up the header files from surplus includes.
 - Started to clean up and add examples, in line with the documentation.
 - Updated obsolete Doxygen settings to reflect new doxygen versions.
 - Bumped the minimal Boost version to 1.40.

Recommended version of Boost: 1.43

//------------------------------------------------------------------------------------------------------
* Version 0.9, "Alice" - November 24, 2010

The main changes for this release include:
 - Implemented gradient descents in all modes (serial, multi-threaded and
   networked).
 - Created a wrapper around all optimization algorithms in all modes
   (serial, multithreaded, networked) that much lowers the entry threshold
   to use Geneva. This wrapper class is called Go.
 - Introduced the GOptimizationMonitorT class (and derivatives) to allow
   easier access to information about the optimization process, plus
   visualization of the optimization progress out of the box.
 - Added a set of functions that allows to extract or set all parameters
   of type double, boost::int32_t or boolean with a single call from an
   individual, in the sequence in which they were registered. E.g., if
   a GDoubleObject, GBooleanCollection and a GConstrainedDouble have been
   registered in this order, it would be possible to just extract or set
   all double values in one go, while leaving the GBooleanCollection
   unchanged.
 - Made it a property of the GParameterSet class, instead of the
   optimization algorithm, whether GParameterSet's evaluation function
   should be maximized or minimized.
 - Added the GParserBuilder class that allows to easily create parsers
   for configuration files "on the fly".
 - Moved the GSerializableI class from the Geneva to the Common library.
 - Worked around a problem in conjunction with g++ 4.1.2 (a compiler bug,
   really).

Recommended version of Boost: 1.43

//------------------------------------------------------------------------------------------------------
* Version 0.8.4, "Route Bell" - September 23, 2010

The main changes for this release include:
 - Revised GAsioSerialTCPConsumerT.
 - Fixed an important bug in the broker infrastructure. As a result of that
   problem, the server sometimes didn't shut down properly at the end
   of networked optimization.

//------------------------------------------------------------------------------------------------------
* Version 0.8.3, "Delphi" - September 19, 2010

The main changes for this release include:
 - Renamed GCommunicationEnums to GCourtierEnums for greater consistency
   with the library name.
 - Completed the unit tests for data types (GParameterBase derivatives,
   adaptors, GParameterSet and related classes). From the optimization-related
   classes only the algorithms are still lacking complete unit test
   coverage. However, through their heavy use in the actual optimization
   problems they are nevertheless quite well tested. Corresponding tests
   will be added when the need arises or time permits.

//------------------------------------------------------------------------------------------------------
* Version 0.8.2, "Route De Broglie" - September 8, 2010

The main changes for this release include:
 - Gave GParameterSet objects the ability to distribute its local random
   number generator to the GParameterBase objects stored in it.
 - Renamed GDouble to GDoubleObject, GInt32 to GInt32Object, GBoolean to
   GBooleanObject, GConstrainedDouble to GConstrainedDoubleObject and
   GConstrainedInt32 to GConstrainedInt32Object for better consistency with
   class names like GDoubleObjectCollection and GDoubleCollection.
 - Renamed GParameterBaseWithAdaptorsT<T>::adaptor_cast<adaptor_type> to
   getAdaptor<adaptor_type>.
 - Renamed GParameterSet::pc_at<> to at<> for consistency reasons.
 - Added many additional tests.

//------------------------------------------------------------------------------------------------------
* Version 0.8.1, "PS 197" - August 28, 2010

The main changes for this release include:
 - Implemented swarm algorithms in all three modes (serial execution,
   multi-threaded and networked). Note that this implementation still needs
   to mature further so that it is recommend for the curious only.
 - Refactored the GBoundedDouble and GBoundedInt32 classes, which are now
   named GConstrainedDouble and GConstrainedInt32 and are based on generic
   floating-point- and integer-aware classes.
 - Moved the GBoundedBufferWithIdT class from the Courtier to the Common
   library.
 - Implemented many new test functions.
 - Organized the tests in sub-folders corresponding to each tested library.
 - Improved the examples' build-files to allow all the examples to compile
   out of tree.

//------------------------------------------------------------------------------------------------------
* Version 0.8, "Prevessin" - August 4, 2010

The main changes for this release include:
 - Separated code into the libraries Hap (random number production),
   Courtier (brokerage and networking), Geneva (optimization algorithms),
   Dataexchange (communication with external evaluation programs) and
   Common (common code needed by all other libraries), each with its own
   namespace. Includes should now be prefixed with the (sub)library name.
 - Reworked the test framework implementing the tests directly inside the
   tested classes. This allows for better testing of private members and
   virtual classes, and at the same time simplifies the code maintenance.
 - Replaced all calls to mutate() (and associated functions) with calls to
   adapt() in order to reflect different naming schemes in different
   optimization algorithms.
 - Added an iterator to GStdPtrVectorInterface that lets users iterate only
   over specific derived objects of the stored base-objects.
 - Removed ability to assign joint adaptors to entire collections in favor
   of all-local adaptors, in order to facilitate the inner design and usage
   of the library.
 - Added a GParameterObjectCollection that allows to arbitrarily mix any
   GParameterBase object in the same collection.
 - Removed GBoostThreadConsumer dependency on GIndividual, making it a
   template class GStdThreadConsumerT.
 - Removed GAsioTCPConsumer dependency on GIndividual, making it a template
   class GAsioSerialTCPConsumerT.
 - Removed the GIndividualBroker class, the GINDIVIDUALBROKER macro was
   moved to GIndividual.hpp.
 - Renamed GenevaExceptions file to GExceptions and renamed
   Gem::Geneva::geneva_error_condition to Gem::Common::gemfony_error_condition,
   in order to better separate different libraries.
 - Replaced usage of GDataExchangeException by Gem::Common::gemfony_error_condition.
 - Gave GParameterBase-derivatives and GParameterSet objects the ability
   to randomly initialize a given set of data elements contained in them.
 - Update to CMake 2.8, ported to Boost 1.43.
 - Made compilation of test code optional.
 - Moved the sample programs in the 'associated' folder together with
   the other examples.

//------------------------------------------------------------------------------------------------------
* Version 0.7, "Route Arago" - March 1, 2010

The main changes for this release include:
 - Removed all direct dependencies of GIndividual objects from the
   optimization algorithm in order to allow the implementation of
   additional algorithms, based on the same data structures and
   parallelization framework.
 - Gave the GAsioTCPConsumer the ability to automatically determine the
   number of listener threads. Should improve scalability of the server
   on systems with many cores.
 - Added GDelayIndividual in order to allow measurement of the overhead
   incurred through the parallelization.
 - Reworked GExternalEvaluator example to be more usable in a production
   environment (e.g. added a configuration file instead of command
   line options).
 - Refactored GIndividualSet (now named GOptimizationAlgorithm) to
   become the base class of a hierarchy of iteration-based optimization
   algorithms. The class now encapsulates functionality common to all of
   these algorithms, such as the main loop and different stop criteria.
 - Gave GIndividual knowledge about the currently best known fitness of
   all individuals.
 - Gave GIndividual knowledge about the number of optimization cycles
   without improvement.
 - Renamed GBasePopulation to GEvolutionaryAlgorithm, GBrokerPopulation
   to GBrokerEA and GBoostThreadPopulation to GMultiThreadedEA.
 - Implemented a new way to select views of vectors of
   boost::shared_ptr<GIndividual>, including automatic conversion
   "attachViewTo<>()".
 - Allowed adaptors to choose from "always mutate", "never mutate" and
   "mutate with a certain likelihood".
 - Added compilation warnings when using Boost 1.39 or Boost 1.41, which
   seem to have issues wrt. Geneva, possibly in the serialization library.
 - Reworked the test framework, including renovation of gobject_conversion<>.
 - Reworked the clone framework to use boost::shared_ptr instead of "raw"
   GObject* pointers.
 - Reworked the load framework so that public accessible load functions
   is shared pointers.
 - Removed GChar and related classes, as these can be implemented better
   through integer classes.
 - Cleaned up and renovated the example's hierarchy.
 - Added a build script to facilitate building the Geneva library.

//------------------------------------------------------------------------------------------------------
* Version 0.6, "Route Enrico Fermi" - September 1, 2009

The main changes for this release include:
 - Added option to GBasePopulation to stop optimizing after a user-defined
   number of stalls.
 - Allowed to selectively switch off mutations (i.e. value changes) for
   GParameterBase derivatives.
 - Gave GBrokerPopulation the ability to dynamically adapt the waitFactor_
   variable upon request.
 - Added a new selection scheme MUNU1PRETAIN to GBasePopulation. In this
   scheme, the best parent of the last generation is retained, unless a
   better child was found. The other parents are replaced by the best
   children. This is a hybrid between the MUPLUSNU_SINGLEEVAL and MUCOMMANU_SINGLEEVAL modes.
 - Added micro-training environment to GBasePopulation (and derivatives).
   When the optimization stalls, parents may perform structural updates.
   As these will very likely lead to a decrease in quality, a one-time
   selection policy of MUPLUSNU_SINGLEEVAL is used.
 - Added the option to set an arbitrary start generation. This is useful
   when intermediate results are written out, whose file name is based on
   the current generation. Files can continue to be written out with
   sequential generation numbers, even if the optimization was started
   anew, e.g. using a checkpoint file.
 - Added the option to prevent the data of unsuccessful mutation attempts
   to be returned to the server. The goal is to lessen the network traffic.
   On the down-side, the MUCOMMANU_SINGLEEVAL and MUNU1PRETAIN selection mode also
   need sub-optimal results and might work less efficient, when this
   setting is enabled.
 - Prevented GBrokerPopulation from becoming an individual inside of
   itself. Doesn't make sense and will likely not work.
 - Added the option to let Geneva automatically determine a suitable
   number of processing threads in GBoostThreadPopulation (set the number
   of threads to 0 using GBoostThreadPopulation::setNThreads() to use
   this feature).

//------------------------------------------------------------------------------------------------------
* Version 0.5.3, "Building 39" - July 6, 2009

The main changes for this release include:
 - Made the library compile (mostly clean) with the Intel 10.1 compiler.
 - Made the library compile cleanly with the old GNU g++ 3.4.6.
 - Made the package size produced by the GRandomFactory changeable at
   run-time.
 - Allow for random numbers to be produced locally in each GRandom object,
   if desired. This makes it possible to assign many more parameters to
   an individual.
 - Moved away from the Boost random number generator for local generation
   mode due to its large memory requirements.
 - Added possibility to compile the library/executables statically.
 - Added Philipp Henkel's threadpool library to the Geneva distribution
   (with his kind permission), in order to ease the compilation procedure.
 - Added the CMake 2.6.4 FindBoost.cmake macro to the Geneva distribution
   in order to ease the compilation procedure. There should now be no need
   to upgrade older 2.6.x CMake distributions, whose FindBoost.cmake
   seemed to have had a problem.
 - Removed the former GLogger framework. It was only used in a few places
   and hasn't been updated for a while. When the Boost.Logging library will
   pass its review, it will be used in Geneva instead.
 - Added the ability to GParameterTColletionT to use a common adaptor for
   all of its GParameterT objects. Note: Needs some more testing.
 - GSeed will now first try to get an initial seed from /dev/urandom, if
   available, and will then set the seed to a predefined value upon failure.
 - Removed GRandom from GObject, providing individual GRandom objects only
   for GAdaptorT and GIndividualSet. This results in a greatly reduced
   memory consumption at very little expense to functionality.
 - Made the network clients ask the server for a seed for their local random
   number generator, so we are sure that each client uses a different random
   number sequence.
 - Reworked test suite so that it now uses manual test registration rather
   than automatic test cases. Needed in order to let the GRandomFactory
   tests be performed in the beginning.
 - Renamed the installed library to geneva-opt, so that it doesn't clash
   with other, similarly named libraries on the system.
 - Improved the check-pointing infrastructure (toFile/fromFile) in GObject.
 - Added ability to GBasePopulation to checkpoint the nParents' best
   individuals in regular intervals.

//------------------------------------------------------------------------------------------------------
* Version 0.5.2, "Building 38" - April 20, 2009

The main changes for this release include:
 - Created a unit test framework for most classes in Geneva.
 - Added modules for the "standardized" exchange of data with external
   evaluation programs.
 - Added new container for bounded doubles, as well as a bounded int32.
 - Made vector-wrapper more complete and derived classes with vector
   interface from a common vector wrapper base class.

//------------------------------------------------------------------------------------------------------
* Version 0.5.1, "Ferney-Voltaire" - March 20, 2009

Again a long list of changes, too long to mention here. Check the SVN
pages for details. Development is still very dynamic.

October 23, 2008: Too many changes have been made in the software to be
named here. This was partially in the course of searching for problems
that in the end turned out not to be on Geneva's side. We nevertheless
believe that the library has improved a lot. Not the least, we have
started to integrate the Boost.Test suite of unit testing tools. We will
aim at listing major changes in the code here in the future, as they
occur.

//------------------------------------------------------------------------------------------------------
* Version 0.5, "Meyrin" - September 15, 2008

Complete revision of the entire project. Also moved from GNU autotools
to CMake. Directory structure of SVN repository has been revised.

//------------------------------------------------------------------------------------------------------
* Version 0.4, "CERN-barracks" - July 7, 2008

Initial public release.