Committing at last the long awaited test for Sharing

eo/test/t-eoSharing.cpp

@@ -0,0 +1,236 @@
+//-----------------------------------------------------------------------------
+
+// to avoid long name warnings
+#ifdef _MSC_VER
+#pragma warning(disable:4786)
+#endif
+
+#include <vector.h>
+#include <stream.h>
+#include <stdexcept>  // runtime_error 
+
+// general
+#include <eo>
+#include <utils/eoDistance.h>
+//-----------------------------------------------------------------------------
+
+struct Dummy : public EO<double>
+{
+    typedef double Type;
+  void printOn(std::ostream & _os) const
+  {
+      EO<double>::printOn(_os);
+      cout << " " << xdist ;
+  }
+  double xdist;
+};
+
+class
+eoDummyDistance : public eoDistance<Dummy>
+{
+  double operator()(const Dummy & _v1, const Dummy & _v2)
+  {
+    double r= _v1.xdist - _v2.xdist;
+    return sqrt(r*r);
+  }
+};
+
+
+bool operator==(const Dummy & _d1, const Dummy & _d2)
+{
+  return _d1.fitness() == _d2.fitness();
+}
+
+struct eoDummyPop : public eoPop<Dummy>
+{
+public :
+    eoDummyPop(int s=0) { resize(s); }
+};
+
+// helper - DOES NOT WORK if different individuals have same fitness!!!
+template <class EOT>
+unsigned isInPop(EOT & _indi, eoPop<EOT> & _pop)
+{
+  for (unsigned i=0; i<_pop.size(); i++)
+    if (_pop[i] == _indi)
+      return i;
+  return _pop.size();
+}
+
+unsigned int pSize;		// global variable, bouh!
+std::string fitnessType;		// yes, a global variable :-)
+eoDummyPop parentsOrg;
+
+template <class EOT>
+void testSelectMany(eoSelect<EOT> & _select, std::string _name)
+{
+    unsigned i;
+  std::cout << "\n\n" << fitnessType + _name << std::endl;
+  std::cout << "===============\n"; 
+
+    eoDummyPop parents(parentsOrg);
+    eoDummyPop offspring(0);
+
+    // do the selection
+    _select(parents, offspring);
+
+    //    cout << "Pop offspring \n" << offspring << endl;
+
+    // compute stats
+    std::vector<unsigned> nb(parents.size(), 0);
+    for (i=0; i<offspring.size();  i++)
+      {
+	unsigned trouve = isInPop<Dummy>(offspring[i], parents);
+	if (trouve == parents.size()) // pas trouve
+	  throw std::runtime_error("Pas trouve ds parents");
+	nb[trouve]++;
+       }
+    // dump to file so you can plot using gnuplot - dir name is hardcoded!
+    std::string fName = "ResSelect/" + fitnessType + _name + ".select";
+    std::ofstream os(fName.c_str());
+    for (i=0; i<parents.size();  i++)
+      {
+	std::cout << i << " -> " << ( (double)nb[i])/offspring.size() << std::endl;
+	os << i << " " << ( (double)nb[i])/offspring.size() << std::endl;
+      }
+
+}
+
+template <class EOT>
+void testSelectOne(eoSelectOne<EOT> & _select, eoHowMany & _offspringRate,
+		   eoHowMany & _fertileRate, std::string _name)
+{
+  eoTruncatedSelectOne<EOT> truncSelect(_select, _fertileRate);
+  eoSelectMany<EOT> percSelect(truncSelect, _offspringRate);
+  testSelectMany<EOT>(percSelect, _name);
+}
+
+
+//-----------------------------------------------------------------------------
+
+int the_main(int argc, char **argv)
+{ 
+  eoParser parser(argc, argv);
+
+  // random seed
+    eoValueParam<uint32>& seedParam = parser.createParam(uint32(0), "seed", "Random number seed", 'S');
+    if (seedParam.value() == 0)
+	seedParam.value() = time(0);
+    rng.reseed(seedParam.value());
+
+
+  // pSize global variable !
+  eoValueParam<unsigned> pSizeParam = parser.createParam(unsigned(10), "parentSize", "Parent size",'P');
+  pSize = pSizeParam.value();
+
+  eoHowMany oRate = parser.createParam(eoHowMany(1.0), "offsrpringRate", "Offsrpring rate (% or absolute)",'O').value();
+
+  eoHowMany fRate = parser.createParam(eoHowMany(1.0), "fertileRate", "Fertility rate (% or absolute)",'F').value();
+
+
+  double nicheSize = parser.createParam(0.1, "nicheSize", "Paramter Sigma for Sharing",'\0').value();
+
+  eoParamParamType & peakParam = parser.createParam(eoParamParamType("2(1,2)"), "peaks", "Description of the peaks: N(nb1,nb2,...,nbN)", 'p').value();
+
+  // the number of peaks: first item of the paramparam
+  unsigned peakNumber = atoi(peakParam.first.c_str());
+  if (peakNumber < 2)
+      {
+	std::cerr << "WARNING, nb of peaks must be larger than 2, using 2" << std::endl;
+	peakNumber = 2;
+      }
+
+  vector<unsigned> nbIndiPerPeak(peakNumber);
+  unsigned i, sum=0;
+
+  // the second item is a vector<string> containing all values
+  if (!peakParam.second.size())   // no other parameter : equal peaks
+      {
+	std::cerr << "WARNING, no nb of indis per peaks, using equal nbs" << std::endl;
+	for (i=0; i<peakNumber; i++)
+	  nbIndiPerPeak[i] = pSize/peakNumber;
+      }
+    else	  // parameters passed by user 
+      if (peakParam.second.size() != peakNumber)
+	{
+	  std::cerr << "ERROR, not enough nb of indis per peaks" << std::endl;
+	  exit(1);
+	}
+      else    // now we have in peakParam.second all numbers
+	{
+	  for (i=0; i<peakNumber; i++)
+	    sum += ( nbIndiPerPeak[i] = atoi(peakParam.second[i].c_str()) );
+	  // now normalize
+	  for (i=0; i<peakNumber; i++)
+	    nbIndiPerPeak[i] = nbIndiPerPeak[i] * pSize / sum;
+	}
+
+  // compute exact total
+  sum = 0; 	  
+  for (i=0; i<peakNumber; i++)
+    sum += nbIndiPerPeak[i];
+  if (sum != pSize)
+    {
+      pSize = pSizeParam.value() = sum;
+      std::cerr << "WARNING, adjusting pSize to " << pSize << std::endl;
+    }
+	  
+    make_help(parser); 
+
+    // hard-coded directory name ...
+    std::cout << "Testing the Sharing\n";
+    std::cout << " There will be " << peakNumber << " peaks";
+    std::cout << " with respective pops ";
+    for (i=0; i<peakNumber; i++)
+      std::cout << nbIndiPerPeak[i] << ", ";
+    std::cout << "\n Peaks are at distance 1 from one-another (dim 1),\n";
+      std::cout << " fitness of each peak is nb of peak, and\n";
+      std::cout << " fitness of individuals = uniform[fitness of peak +- 0.01]\n\n";
+
+      std::cout << "The resulting file (in dir ResSelect), contains \n";
+    std::cout << " the empirical proba. for each indi to be selected." << std::endl;
+    system("mkdir ResSelect");
+
+    // initialize parent population
+    parentsOrg.resize(pSize);
+
+    // all peaks of equal size in fitness, with different nn of individuals
+    unsigned index=0;
+    for (unsigned nbP=0; nbP<peakNumber; nbP++)
+      for (i=0; i<nbIndiPerPeak[nbP]; i++)
+	{
+	  parentsOrg[index].fitness(nbP+1 + 0.02*eo::rng.uniform() - 0.01);
+	  parentsOrg[index].xdist = nbP+1 + 0.02*eo::rng.uniform() - 0.01;
+	  index++;
+	}
+
+    std::cout << "Initial population\n" << parentsOrg << std::endl;
+
+    char fileName[1024];
+
+// the selection procedures under test
+    //    eoDetSelect<Dummy> detSelect(oRate);
+    //    testSelectMany(detSelect, "detSelect");
+
+    // Sharing using the perf2Worth construct
+    // need a distance for that
+    eoDummyDistance dist;
+    eoSharingSelect<Dummy> newSharingSelect(nicheSize, dist);
+    sprintf(fileName,"Niche_%g",nicheSize);
+    testSelectOne<Dummy>(newSharingSelect, oRate, fRate, fileName);
+
+    return 1;
+}
+
+int main(int argc, char **argv)
+{
+    try
+    {
+        the_main(argc, argv);
+    }
+    catch(std::exception& e)
+    {
+        std::cout << "Exception: " << e.what() << std::endl;
+        return 1;
+    }
+}