Implemented a real neighborhood for mo

mo/src/neighborhood/moRealNeighbor.h

@@ -0,0 +1,87 @@
+#ifndef __moRealNeighbor_h__
+#define __moRealNeighbor_h__
+
+#include <mo>
+#include <eo>
+#include <edo>
+
+//! A neighbor as produced by a moRealNeighborhood
+/*!
+ * In a real neighborhood, the move is just a translation vector, of the same type than a solution.
+ */
+
+template <class EOT, class Fitness=typename EOT::Fitness>
+class moRealNeighbor : public moNeighbor<EOT, Fitness>
+{
+protected:
+    //! The move to be applied
+    EOT _translation;
+
+    edoBounder<EOT> * _bounder;
+
+
+public:
+
+    moRealNeighbor<EOT,Fitness>() : _bounder( NULL ) {  }
+
+    //! Returns the solution attached to this neighbor
+    EOT translation() { return _translation; }
+
+    //! Set the translation
+    void translation( EOT translation ) { _translation = translation; }
+
+
+    void bounder( edoBounder<EOT> * bounder ) { _bounder = bounder; }
+
+    /**
+     * Assignment operator
+     * @param _neighbor the neighbor to assign
+     * @return a neighbor equal to the other
+     */
+    virtual moNeighbor<EOT, Fitness>& operator=(const moNeighbor<EOT, Fitness>& _neighbor) {
+        fitness( _neighbor.fitness() );
+        return (*this);
+    }
+
+    /*!
+     * Move a solution to the solution of this neighbor
+     * @param _solution the related solution
+     */
+    virtual void move(EOT & _solution)
+    {
+        assert( _solution.size() == _translation.size() );
+
+        for( unsigned int i=0, size= _solution.size(); i<size; ++i ) {
+            _solution[i] += _translation[i];
+        }
+
+
+        if( _bounder != NULL ) {
+            (*_bounder)( _solution );
+        }
+
+	_solution.invalidate();
+    }
+
+
+    /**
+     * Test equality between two neighbors
+     * @param _neighbor a neighbor
+     * @return if _neighbor and this one are equals
+     */
+    virtual bool equals(moRealNeighbor<EOT>& _neighbor) {
+        return _neighbor.translation() == _translation;
+    }
+
+    /**
+     * Return the class Name
+     * @return the class name as a std::string
+     */
+    virtual std::string className() const {
+        return "moRealNeighbor";
+    }
+};
+
+
+#endif // __moRealNeighbor_h__
+

mo/src/neighborhood/moRealNeighborhood.h

@@ -0,0 +1,78 @@
+
+#ifndef __moRealNeighborhood_h__
+#define __moRealNeighborhood_h__
+
+#include <mo>
+#include <eoFunctor.h> // FIXME: Why don't we use eoFunctorBase on the mother classes
+#include "moRealNeighbor.h"
+
+template<class Distrib, class Neighbor>
+class moRealNeighborhood : public moRndNeighborhood< Neighbor >, public eoFunctorBase
+{
+public:
+    typedef typename Distrib::EOType EOT;
+
+protected:
+    Distrib & _distrib;
+    edoSampler<Distrib> & _sampler;
+    edoBounder<EOT> & _bounder;
+
+public:
+
+    moRealNeighborhood( Distrib & distrib, edoSampler<Distrib> & sampler, edoBounder<EOT> & bounder ) : _distrib(distrib), _sampler(sampler), _bounder(bounder) {}
+
+    /**
+     * It alway remains at least a solution in an infinite neighborhood
+     * @param _solution the related solution
+     * @return true
+     */
+    virtual bool hasNeighbor(EOT &)
+    {
+        return true;
+    }
+
+    /**
+     * Draw the next neighbor
+     * @param _solution the solution to explore
+     * @param _current the next neighbor
+     */
+    virtual void next(EOT &, Neighbor & _current)
+    {
+        _current.bounder( &_bounder );
+
+        // Draw a translation in the distrib, using the sampler
+        _current.translation( _sampler( _distrib ) );
+    }
+
+
+    /**
+     * Initialization of the neighborhood
+     * @param _solution the solution to explore
+     * @param _current the first neighbor
+     */
+    virtual void init(EOT & _solution, Neighbor & _current)
+    {
+        // there is no difference between an init and a random draw
+        next( _solution, _current );
+    }
+    /**
+     * There is always a solution in an infinite neighborhood
+     * @param _solution the solution to explore
+     * @return true
+     */
+    virtual bool cont(EOT &)
+    {
+        return true;
+    }
+
+    /**
+     * Return the class Name
+     * @return the class name as a std::string
+     */
+    virtual std::string className() const {
+        return "moRealNeighborhood";
+    }
+
+};
+
+#endif // __moRealNeighborhood_h__