Added Marc's ES files and .dsp files for others

eo/src/eoESFullChrom.h

@@ -0,0 +1,270 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// eoESInd.h
+// (c) GeNeura Team, 1998 - EEAAX 1999
+/* 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
+             Marc.Schoenauer@polytechnique.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef _EOESFULLCHROM_H
+#define _EOESFULLCHROM_H
+
+// STL libraries
+#include <vector>		// For vector<>
+#include <stdexcept>
+#include <strstream>
+#include <iostream>		// for ostream
+
+// EO includes
+#include <eoVector.h>
+#include <eoRNG.h>
+/**@name Chromosomes for evolution strategies
+Each chromosome in an evolution strategies is composed of a vector of floating point
+values plus a vector of sigmas, that are added to them during mutation and a vector of correlations
+*/ 
+//@{
+
+
+/**@name individuals for evolution strategies  -MS- 22/10/99
+Each individual in an evolution strategy is composed of 
+   a vector of floating point values 
+   a vector of std deviations
+   a vector of rotation angles (for correlated mutations)
+
+THese individuals CANNOT BE IMPLEMENTED as vectors of anything 
+      at least in the case of correlated mutations
+*/ 
+//@{
+
+template <typename fitT = float >
+class eoESFullChrom  : public eoVector<double, fitT> {	
+    public:
+/// constructor
+    eoESFullChrom(  unsigned _num_genes = 1, 
+	      unsigned _num_sigma = 1, unsigned _num_correl = 0,
+	      bool _verbose = false,  
+	      double _ObjMin = 0, double _ObjMax = 1, 
+	      double _StdDevInit = 0.3 ):
+    eoVector<double, fitT>(_num_genes),
+    //    ObjVar( _num_genes ), now an eoVector<double>
+    StdDev( _num_sigma ), 
+    CorCff( _num_correl ),
+    verbose( _verbose ),
+    ObjMin( _ObjMin ),
+    ObjMax(_ObjMax ),
+    StdDevInit( _StdDevInit ) {}
+  
+    /// copy constructor
+    eoESFullChrom( const eoESFullChrom& _eo ):
+    eoVector<double, fitT> ( _eo ), // ObjVar ( _eo.ObjVar ), 
+    StdDev ( _eo.StdDev ), CorCff( _eo.CorCff ), verbose( _eo.verbose ),
+    ObjMin( _eo.ObjMin ), ObjMax(_eo.ObjMax ), StdDevInit( _eo.StdDevInit ) {}
+
+	
+  /* another constructor, for compatibility reasons */
+  eoESFullChrom(istream& _s) {cout << "Not Yet implemented\n";exit(1);};
+
+  /* And now the useful constructor: from a parser (should be in the
+     factory, if such a thing exists one day for eoESFullChrom 
+   */
+  eoESFullChrom(Parser & parser) : StdDev(0), CorCff(0) {
+    parser.AddTitle("Description of ES individuals");
+    int num_genes, num_sigma;
+    bool correlated_mutations;
+    try {
+      num_genes = parser.getInt("-Io", "--NbObjVar", "2", 
+				 "Number of Object Variables" );
+      num_sigma = parser.getInt("-Is", "--NbSigma", "1", 
+				 "Number of Standard Deviations" );
+      correlated_mutations = parser.getBool("-Ic", "--Correlated", 
+				  "Correlated mutation?" );
+      ObjMin = parser.getFloat("-Im", "--min", "0", 
+			      "Minimum value for object variables" );
+      ObjMax = parser.getFloat("-IM", "--max", "1", 
+			      "Maximum value for object variables" );
+      StdDevInit = parser.getFloat("-II", "--SigmaInit", "0.3", 
+			       "Initial value for std. dev. (scaled by range)" );
+      verbose = parser.getBool("-Iv", "--verbose",
+		"Verbose listing of ES individuals (mutation parameters");
+    }
+    catch (exception & e)
+      {
+	cout << e.what() << endl;
+	parser.printHelp();
+	exit(1);
+      }
+
+    // consistency tests
+    if (! num_sigma) {		   // no std dev??? EXCEPTION
+      throw invalid_argument( "No standard deviation: choose another representation please" );
+    }
+    if (num_sigma > num_genes) {
+      cout << "WARNING, Number of Standard Deviations > Number of Object Variables\nAdjusted!\n";
+      num_sigma = num_genes;
+      // modify the Param value - so .status is OK
+      char sloc[20];
+      sprintf(sloc, "%d", num_genes);
+      parser.setParamValue("--NbSigma", sloc);
+    }
+    // adjust the sizes!!!
+    resize(num_genes);
+    if (num_sigma)
+      StdDev.resize(num_sigma);
+    if (correlated_mutations) {
+      if (num_sigma < num_genes) {
+	cout << "WARNING less Std Dev. than number of variables + Correlated mutations\n";
+	cout << "Though possible, this is a strange setting" << endl;
+      }
+      // nb of rotation angles: N*(N-1)/2 (in general!)
+      CorCff.resize ( (2*num_genes - num_sigma)*(num_sigma - 1) / 2 );
+    }
+  };
+
+
+  /// Operator =
+  const eoESFullChrom& operator = ( const eoESFullChrom& _eo ) {
+    if ( this  != &_eo ) {
+      // Change EO part
+      eoVector<double, fitT>::operator = (_eo);
+      
+      // Change this part
+      //	      ObjVar = _eo.ObjVar;
+      StdDev = _eo.StdDev;
+      CorCff = _eo.CorCff;
+      verbose =  _eo.verbose;
+      ObjMin = _eo.ObjMin;
+      ObjMax = _eo.ObjMax;
+      StdDevInit = _eo.StdDevInit;
+    }
+    return *this;
+  }
+
+  /// destructor
+  virtual ~eoESFullChrom() {}
+  
+  /// 
+  double getStdDev( unsigned _i ) const {
+    if ( _i >= length() ) 
+      throw out_of_range( "out_of_range when reading StdDev");
+    return StdDev[ _i ];
+  }
+
+  ///
+  void setStdDev( unsigned _i, double _val ) {
+    if ( _i < length() ) {
+      StdDev[_i] = _val;
+    } else 
+      throw out_of_range( "out_of_range when writing StdDev");
+  }
+  
+  /// 
+  double getCorCff( unsigned _i ) const {
+    if ( _i >= length() ) 
+      throw out_of_range( "out_of_range when reading CorCff");
+    return CorCff[ _i ];
+  }
+
+  ///
+  void setCorCff( unsigned _i, double _val ) {
+    if ( _i < length() ) {
+      CorCff[_i] = _val;
+    } else 
+      throw out_of_range( "out_of_range when writing CorCff");
+  }
+  
+  ///
+  void insertGene( unsigned _i, double _val ) {
+      throw FixedLengthChromosome();
+  };
+  
+  ///
+  void deleteGene( unsigned _i ) {
+      throw FixedLengthChromosome();
+  };
+  
+  ///
+    unsigned length() const { return size();}/* formerly ObjVar.size() */
+    unsigned StdDevLength() const { return StdDev.size();}
+    unsigned CorCffLength() const { return CorCff.size();}
+
+
+  /** Print itself: inherited from eoObject implementation. 
+      Instance from base classes are processed in
+      base classes, so you don´t have to worry about, for instance, fitness.
+  @param _s the ostream in which things are written*/
+  virtual void printOn( ostream& _s ) const{
+      copy( begin(), end(), ostream_iterator<double>( _s, " ") );
+      // The formatting instructinos shoudl be left to the caller
+      //      _s << "\n";       
+      if (verbose) {
+	  _s << "\n\tStd Dev. " ;
+	  copy( StdDev.begin(), StdDev.end(), ostream_iterator<double>( _s, " ") );
+	  if (CorCff.size()) {
+	      _s << "\n\t";
+	      copy( CorCff.begin(), CorCff.end(), ostream_iterator<double>( _s, " ") );
+	  }
+      }
+  };
+
+  /** This exception should be thrown when trying to insert or delete a gene
+  in a fixed length chromosome  
+  */
+  class FixedLengthChromosome : public exception {
+
+  public:
+    /**
+       * Constructor
+       */
+    FixedLengthChromosome()
+	: exception() { };
+
+    ~FixedLengthChromosome() {};
+  };
+  
+  // accessors
+  double getObjMin() const {return ObjMin;}
+  double getObjMax() const {return ObjMax;}
+  double getStdDevInit () const {return StdDevInit;}
+
+  /** Inherited from eoObject 
+      @see eoObject
+  */
+  virtual string className() const {return "eoESFullChrom";};
+
+private:
+    //	vector<double>	    ObjVar;	/* object variable vector */
+// or shoudl the class be subclass of EOVector<double> ???
+
+	vector<double>	    StdDev;	/* standard deviation vector */
+	vector<double>	    CorCff;	/* correlation coefficient vector */
+
+    bool verbose;		/* Print std deviations or not */
+
+  /** the range is used for mutation AND random initialization, 
+     * while the StdDevInit is used only for random initialization
+     * this in a little inconsistent!
+     */
+    double ObjMin, ObjMax;	/* Range for Object variables */
+    double StdDevInit;		/* Initial value of Standard Deviations */
+
+};
+
+#endif
+