git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1824 331e1502-861f-0410-8da2-ba01fb791d7f

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoAnytimeWeightStrategy.h

@@ -0,0 +1,101 @@
+/*
+* <moeoAnytimeWeightStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MOEOANYTIMEWEIGHTSTRAT_H_
+#define MOEOANYTIMEWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+#include <algorithm>
+#include <utility>
+#include <utils/rnd_generators.h>
+
+/**
+ * Change all weights according to a pattern ressembling to a "double strategy" 2 to 1 then 1 to 2.
+ * Can only be applied to 2 objectives vector problem
+ */
+template <class MOEOT>
+class moeoAnytimeWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+{
+	public:
+		/**
+		 * default constructor
+		 */
+		moeoAnytimeWeightStrategy():random(default_random),depth(0){}
+
+		/**
+		 * constructor with a given random generator, for algorithms wanting to keep the same generator for some reason
+		 * @param _random an uniform random generator
+		 */
+		moeoAnytimeWeightStrategy(UF_random_generator<double> &_random):random(_random), depth(0){}
+
+		/**
+		 *
+		 * @param _weights the weights to change
+		 * @param _moeot not used
+		 */
+		void operator()(std::vector<double>& _weights, const MOEOT& _moeot){
+			if (depth<2){
+				if (depth==0) toTest.push_back(0.5);
+				_weights[0]=depth;
+				_weights[1]=1-_weights[0];
+				depth++;
+				old1=0;
+				old2=1;
+				return;
+			}
+			if (!toTest.empty()){
+				_weights[0]=toTest.front();
+				_weights[1]=1-_weights[0];
+				toTest.erase(toTest.begin());
+				toTest.push_back((_weights[0]+old1)/2);
+				toTest.push_back((_weights[0]+old2)/2);
+				old2=old1;
+				old1=_weights[0];
+			}else{
+				std::cout<<"Error: Strange occurence in moeoAnytimeWeightStrategy "<<std::endl;
+			}
+		}
+
+	private:
+		double old1;
+		double old2;
+		UF_random_generator<double> &random;
+		UF_random_generator<double> default_random;
+		int depth;
+		std::list<double> toTest;
+};
+
+#endif

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoAugmentedQexploreWeightStrategy.h

@@ -0,0 +1,169 @@
+/*
+* <moeoAugmentedQexploreWeightStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MOEOAUGMENTEDQEXPLWEIGHTSTRAT_H_
+#define MOEOAUGMENTEDQEXPLWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+#include <algorithm>
+#include <utility>
+#include <utils/rnd_generators.h>
+
+/**
+ * Change all weights according to a pattern ressembling to a "double strategy" 2 to 1 then 1 to 2.
+ * Can only be applied to 2 objectives vector problem
+ */
+template <class MOEOT>
+class moeoAugmentedQexploreWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+{
+	public:
+		/**
+		 * default constructor
+		 */
+		moeoAugmentedQexploreWeightStrategy():depth(0),num(0),reset(true){
+			nums.resize(1,0);
+		}
+		/**
+		 *
+		 * @param _weights the weights to change
+		 * @param moeot a moeot, not used
+		 */
+		void operator()(std::vector<double> &_weights,const MOEOT &moeot){
+			int dim=moeot.objectiveVector().size();
+			bool res=false;
+			int max=dim-1;
+			if (depth==0) do_reset();
+			while (!res) {
+				res=translate(dim,_weights);
+				next_num(dim);
+				if (nums[0]>max){
+					do_reset();
+				}
+			}
+		}
+
+	private:
+
+		void next_num(int dim){
+			int max=dim-1;
+			int idx=nums.size()-1;
+			if (depth==0){
+				do_reset();
+			}else{
+				idx=nums.size()-1;
+				while(idx>0 && nums[idx]==max) idx--;
+				int to_assign=nums[idx]+1;
+				for (unsigned int i=idx;i<nums.size();i++){
+					nums[i]=to_assign;
+				}
+			}
+		}
+
+		bool translate(int dim, std::vector<double> &_weights){
+			_weights.clear();
+			_weights.resize(dim,0);
+			for (unsigned int i=0;i<nums.size();i++){
+				_weights[nums[i]]++;
+				if (depth>1 && _weights[nums[i]]==depth) {
+					return false;
+				}
+			}
+
+			bool accept_pow=false;
+			bool accept_prim=false;
+			for (unsigned int i=0;i<_weights.size();i++){
+				if (accept_pow || (_weights[i]!=1 && !is2pow(_weights[i]))) {
+					accept_pow=true;
+				}
+				if (accept_prim || (coprim(_weights[i],depth)))
+					accept_prim=true;
+
+				_weights[i]=(_weights[i]+0.0)/(0.0+depth);
+			}
+			return accept_prim && accept_pow;
+		}
+
+		void do_reset(){
+			if (depth==0) depth=1;
+			else depth=depth*2;
+			nums.resize(depth);
+			for (unsigned int i=0;i<nums.size();i++){
+				nums[i]=0;
+			}
+			reset=false;
+		}
+
+		int next_prime(int old){
+			int res=old;
+			bool prim=true;
+			do{
+				res+=1;
+				prim=true;
+				for (unsigned int i=2;i<=sqrt(res);i++){
+					if ((res%i)==0) prim=false;
+				}
+			}while (!prim);
+			return res;
+		}
+
+		bool coprim(int a, int b){
+			if (b==0){
+				return a==1;
+			}else {
+				return coprim(b,a%b);
+			}
+		}
+
+		bool is2pow(int a){
+			if (a==1 || a==0) {
+				return true;
+			}
+			else if ((a%2)!=0) {
+				return false;
+			}
+
+			else {
+				return is2pow(a/2);
+			}
+		}
+
+		std::vector<int> nums;
+		int depth,num;
+		bool reset;
+
+};
+
+#endif

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoDichoWeightStrategy.h

@@ -0,0 +1,153 @@
+/*
+ * <moeoDichoWeightStrategy.h>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2007
+ *
+ * Fran<-61><-89>ois Legillon
+ *
+ * This software is governed by the CeCILL license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ *
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited liability.
+ *
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ *
+ * ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+ * Contact: paradiseo-help@lists.gforge.inria.fr
+ *
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MOEODICHOWEIGHTSTRAT_H_
+#define MOEODICHOWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+#include <algorithm>
+#include <utility>
+#include <utils/rnd_generators.h>
+
+/**
+ * Change all weights according to a pattern ressembling to a "double strategy" 2 to 1 then 1 to 2.
+ * Can only be applied to 2 objectives vector problem
+ */
+template <class MOEOT>
+class moeoDichoWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+{
+	public:
+		/**
+		 * default constructor
+		 */
+		moeoDichoWeightStrategy():random(default_random),num(0){}
+
+		/**
+		 * constructor with a given random generator, for algorithms wanting to keep the same generator for some reason
+		 * @param _random an uniform random generator
+		 */
+		moeoDichoWeightStrategy(UF_random_generator<double> &_random):random(_random),num(0){}
+
+		/**
+		 *
+		 * @param _weights the weights to change
+		 * @param moeot a moeot, will be kept in an archive in order to calculate weights later
+		 */
+		void operator()(std::vector<double> &_weights,const MOEOT &moeot){
+			std::vector<double> res;
+			ObjectiveVector tmp;
+			_weights.resize(moeot.objectiveVector().size());
+			if (arch.size()<2){
+				//archive too small, we generate starting weights to populate it
+				//if no better solution is provided, we will toggle between (0,1) and (1,0)
+				arch(moeot);
+				if (num==0){
+					_weights[0]=0;
+					_weights[1]=1;
+					num++;
+				}else{
+					_weights[1]=0;
+					_weights[0]=1;
+					num=0;
+					std::sort(arch.begin(),arch.end(),cmpParetoSort());
+					it=arch.begin();
+				}
+				return;
+			}else{
+				if (it!=arch.end()){
+					tmp=(*it).objectiveVector();
+					it++;
+					if (it==arch.end()){
+						//we were at the last elements, recurse to update the archive
+						operator()(_weights,moeot);
+						return;
+					}
+					toAdd.push_back(moeot);
+					res=normal(tmp,(*it).objectiveVector());
+					_weights[0]=res[0];
+					_weights[1]=res[1];
+				}else{
+					//we only add new elements to the archive once we have done an entire cycle on it,
+					//to prevent iterator breaking
+					//then we reset the iterator, and we recurse to start over
+					arch(toAdd);
+					toAdd.clear();
+					std::sort(arch.begin(),arch.end(),cmpParetoSort());
+					it=arch.begin();
+					operator()(_weights,moeot);
+					return;
+				}
+			}
+
+		}
+
+
+
+	private:
+		typedef typename MOEOT::ObjectiveVector ObjectiveVector;
+
+		std::vector<double> normal(const ObjectiveVector &_obj1, const ObjectiveVector &_obj2){
+			std::vector<double> res;
+			double sum=0;
+			for (unsigned int i=0;i<_obj1.size();i++){
+				if (_obj1[i]>_obj2[i])
+					res.push_back(_obj1[i]-_obj2[i]);
+				else
+					res.push_back(_obj2[i]-_obj1[i]);
+				sum+=res[i];
+			}
+			for (unsigned int i=0;i<_obj1.size();i++) res[i]=res[i]/sum;
+			return res;
+		}
+		struct cmpParetoSort
+		{
+			//since we apply it to a 2dimension pareto front, we can sort every objectiveVector
+			// following either objective without problem
+			bool operator()(const MOEOT & a,const MOEOT & b) const
+			{
+				return b.objectiveVector()[0]<a.objectiveVector()[0];
+			}
+		};
+
+		UF_random_generator<double> &random;
+		UF_random_generator<double> default_random;
+		int num;
+		moeoUnboundedArchive<MOEOT> arch;
+		eoPop<MOEOT> toAdd;
+		typename eoPop<MOEOT>::iterator it;
+};
+
+#endif

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoDummyRefPointStrategy.h

@@ -0,0 +1,51 @@
+/*
+* <moeoDummyRefPointStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+*/
+//-----------------------------------------------------------------------------
+
+#ifndef MOEODUMMYREFPOINT_H_
+#define MOEODUMMYREFPOINT_H_
+
+/**
+ * dummy class for variable reference point strategies. do nothing 
+ */
+template <class MOEOT>
+class moeoDummyRefPointStrategy : public moeoVariableRefPointStrategy<MOEOT>
+  {
+	  public:
+		  virtual void operator()(typename MOEOT::ObjectiveVector &_obj, const MOEOT &_moeo ){}
+  };
+
+#endif 

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoDummyWeightStrategy.h

@@ -0,0 +1,61 @@
+/*
+* <moeoDummyWeightStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+*/
+//-----------------------------------------------------------------------------
+
+#ifndef MOEODUMMYWEIGHTSTRAT_H_
+#define MOEODUMMYWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+
+/**
+ * Dummy variable weight strategy. Fill the weight with equal values
+ */
+template <class MOEOT>
+class moeoDummyWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+  {
+	  public:
+		  /**
+		   * main function
+		   * @param _weights the weights to change
+		   * @param _moeot not used
+		   */
+		  void operator()(std::vector<double> &_weights,const MOEOT &_moeot){
+			  for (unsigned int i=0;i<_weights.size();i++){
+				  _weights[i]=(1.0/_weights.size());
+			  }
+		  }
+  };
+
+#endif

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoFixedTimeBothDirectionWeightStrategy.h

@@ -0,0 +1,87 @@
+/*
+* <moeoFixedTimeBothDirectionWeightStrategy>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MOEOFTBDWSWEIGHTSTRAT_H_
+#define MOEOFTBDWSWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+#include <algorithm>
+#include <utility>
+#include <utils/rnd_generators.h>
+
+/**
+ * Change all weights according to a "double strategy" pattern 2 to 1 then 1 to 2.
+ */
+template <class MOEOT>
+class moeoFixedTimeBothDirectionWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+{
+	public:
+		/**
+		 * default constructor 
+		 * @param _step how much we want the weight to change every iteration
+		 */
+		moeoFixedTimeBothDirectionWeightStrategy(double _step):step(_step),current(0),direction(false){}
+		/**
+		 * 
+		 * @param _weights the weights to change
+		 * @param moeot a moeot, not used
+		 */
+		void operator()(std::vector<double> &_weights,const MOEOT &moeot){
+			double res;
+			if (current==1){
+				res=1;
+				current=0;
+				direction=!direction;
+			}else res=current;
+			if (current+step>1){
+				current=1;
+			}else current+=step;
+			if (direction){
+			_weights[0]=res;
+			_weights[1]=1-res;
+			}else{
+			_weights[0]=1-res;
+			_weights[1]=res;
+			}
+		}
+
+	private:
+		double step;
+		double current;
+		bool direction;
+};
+
+#endif 

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoFixedTimeOneDirectionWeightStrategy.h

@@ -0,0 +1,80 @@
+/*
+* <moeoFixedTimeOneDirectionWeightStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MOEOFTODWSWEIGHTSTRAT_H_
+#define MOEOFTODWSWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+#include <algorithm>
+#include <utility>
+#include <utils/rnd_generators.h>
+
+/**
+ * Change all weights according to a simple strategy by adding a step every generation
+ */
+template <class MOEOT>
+class moeoFixedTimeOneDirectionWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+{
+	public:
+		/**
+		 * default constructor
+		 * @param _step how much we want the weight to change every iteration
+		 */
+		moeoFixedTimeOneDirectionWeightStrategy(double _step):step(_step),current(0){}
+		/**
+		 *
+		 * @param _weights the weights to change
+		 * @param moeot a moeot, not used
+		 */
+		void operator()(std::vector<double> &_weights,const MOEOT &moeot){
+			double res;
+			if (current==1){
+				res=1;
+				current=0;
+			}else res=current;
+			if (current+step>1){
+				current=1;
+			}else current+=step;
+			_weights[0]=res;
+			_weights[1]=1-res;
+		}
+
+	private:
+		double step;
+		double current;
+};
+
+#endif

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoQexploreWeightStrategy.h

@@ -0,0 +1,114 @@
+/*
+* <moeoQexploreWeightStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MOEOQEXPLWEIGHTSTRAT_H_
+#define MOEOQEXPLWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+#include <algorithm>
+#include <utility>
+#include <utils/rnd_generators.h>
+//#include <rnd_generators.h>
+/**
+ * Change all weights according to a pattern ressembling to a "double strategy" 2 to 1 then 1 to 2.
+ * Can only be applied to 2 objectives vector problem
+ */
+template <class MOEOT>
+class moeoQexploreWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+{
+	public:
+		/**
+		 * default constructor
+		 */
+		moeoQexploreWeightStrategy():random(default_random),depth(0),num(0){}
+		
+		/**
+		 * constructor with a given random generator, for algorithms wanting to keep the same generator for some reason
+		 * @param _random an uniform random generator
+		 */
+		moeoQexploreWeightStrategy(UF_random_generator<double> &_random):random(_random),depth(0),num(0){}
+		/**
+		 * 
+		 * @param _weights the weights to change
+		 * @param moeot a moeot, not used
+		 */
+		void operator()(std::vector<double> &_weights,const MOEOT &moeot){
+			if (depth==0){
+				if (num==0){
+					num++;
+					_weights[0]=0;
+					_weights[1]=1;
+				}else{
+					num=1;
+					depth=1;
+					_weights[0]=1;
+					_weights[1]=0;
+				}
+			}else{
+				while (num<depth && !coprim(depth,num)){
+					num++;
+				}
+				if (num>=depth){
+					depth++;
+					num=1;
+				}
+				_weights[0]=(num+0.0)/depth;
+				_weights[1]=1-(num+0.0)/depth;
+				num++;
+			}
+		}
+
+
+	private:
+
+		bool coprim(int a, int b){
+			if (b==0){
+				return a==1;
+			}else {
+				return coprim(b,a%b);
+			}
+		}
+
+		void next_num(){
+
+		}
+		UF_random_generator<double> &random;
+		UF_random_generator<double> default_random;
+		int depth,num,idx;
+		std::list<double> toTest;
+};
+
+#endif 

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoRandWeightStrategy.h

@@ -0,0 +1,83 @@
+/*
+* <moeoRandWeightStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+*/
+//-----------------------------------------------------------------------------
+
+#ifndef MOEORANDWEIGHTSTRAT_H_
+#define MOEORANDWEIGHTSTRAT_H_
+#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
+
+/**
+ * Change all weights randomly.
+ */
+template <class MOEOT>
+class moeoRandWeightStrategy: public moeoVariableWeightStrategy<MOEOT>
+  {
+	  public:
+		  /**
+		   * default constructor
+		   */
+		  moeoRandWeightStrategy():random(default_random){}
+
+		  /**
+		   * constructor with a given random generator, for algorithms wanting to keep the same generator for some reason
+		   * @param _random an uniform random generator
+		   */
+		  moeoRandWeightStrategy(UF_random_generator<double> &_random):random(_random){}
+
+		  /**
+		   * main function, fill the weight randomly
+		   * @param _weights the weights to change
+		   * @param _moeot not used
+		   */
+		  void operator()(std::vector<double> &_weights,const MOEOT &_moeot){
+			  double sum=0;
+			  for (unsigned int i=0;i<_weights.size();i++){
+				  double rnd=random(100000);
+				  sum+=rnd;
+				  _weights[i]=rnd;
+			  }
+			  //we divide by the sum in order to keep the weight sum equal to 1
+			  for (unsigned int i=0;i<_weights.size();i++){
+				  _weights[i]=_weights[i]/sum;
+			  }
+		  }
+
+	  private:
+		  UF_random_generator<double> &random;
+		  UF_random_generator<double> default_random;
+  };
+
+#endif

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoVariableRefPointStrategy.h

@@ -0,0 +1,51 @@
+/*
+* <moeoVariableRefPointStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+*/
+//-----------------------------------------------------------------------------
+
+#ifndef MOEOVARREFPOINT_H_
+#define MOEOVARREFPOINT_H_
+
+/**
+ * Abstract class for strategies for changing reference point, in a fitness assignment that use it.
+ */
+template <class MOEOT>
+class moeoVariableRefPointStrategy
+  {
+	  public:
+		  virtual void operator()(typename MOEOT::ObjectiveVector &_obj,const MOEOT &_moeo )=0;
+  };
+
+#endif 

trunk/paradiseo-moeo/src/scalarStuffs/utils/moeoVariableWeightStrategy.h

@@ -0,0 +1,51 @@
+/*
+* <moeoVariableWeightStrategy.h>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (C) OPAC Team, LIFL, 2002-2007
+*
+* François Legillon
+*
+* This software is governed by the CeCILL license under French law and
+* abiding by the rules of distribution of free software.  You can  use,
+* modify and/ or redistribute the software under the terms of the CeCILL
+* license as circulated by CEA, CNRS and INRIA at the following URL
+* "http://www.cecill.info".
+*
+* As a counterpart to the access to the source code and  rights to copy,
+* modify and redistribute granted by the license, users are provided only
+* with a limited warranty  and the software's author,  the holder of the
+* economic rights,  and the successive licensors  have only  limited liability.
+*
+* In this respect, the user's attention is drawn to the risks associated
+* with loading,  using,  modifying and/or developing or reproducing the
+* software by the user in light of its specific status of free software,
+* that may mean  that it is complicated to manipulate,  and  that  also
+* therefore means  that it is reserved for developers  and  experienced
+* professionals having in-depth computer knowledge. Users are therefore
+* encouraged to load and test the software's suitability as regards their
+* requirements in conditions enabling the security of their systems and/or
+* data to be ensured and,  more generally, to use and operate it in the
+* same conditions as regards security.
+* The fact that you are presently reading this means that you have had
+* knowledge of the CeCILL license and that you accept its terms.
+*
+* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+* Contact: paradiseo-help@lists.gforge.inria.fr
+*
+*/
+//-----------------------------------------------------------------------------
+
+#ifndef MOEOVARWEIGHT_H_
+#define MOEOVARWEIGHT_H_
+
+/**
+ * Abstract class for strategies for changing weight, in a aggregative fitness assignment.
+ */
+template <class MOEOT>
+class moeoVariableWeightStrategy
+  {
+	  public:
+		  virtual void operator()(std::vector<double> &_weights,const MOEOT &_moeo )=0;
+  };
+
+#endif