From 9d7a258e04af7e93657f70f32e4075d081bd84d8 Mon Sep 17 00:00:00 2001
From: Mirko Maischberger <mirko.maischberger@gmail.com>
Date: Tue, 20 Oct 2009 20:33:28 +0000
Subject: [PATCH] Permutation subsequence inversion neighborhood.

---
 metslib/mets.cc                  |  8 ++++----
 metslib/mets.h                   | 30 +++++++++++++++++++++++++-----
 test/permutation_problem_test.cc | 24 ++++++++++++------------
 3 files changed, 41 insertions(+), 21 deletions(-)

diff --git a/metslib/mets.cc b/metslib/mets.cc
index 0d6090c..0052626 100644
--- a/metslib/mets.cc
+++ b/metslib/mets.cc
@@ -49,7 +49,7 @@ mets::swap_elements::operator==(const mets::mana_move& o) const
 //________________________________________________________________________
 
 void
-mets::swap_subsequence::apply(mets::feasible_solution& s)
+mets::invert_subsequence::apply(mets::feasible_solution& s)
 { 
   mets::permutation_problem& sol = 
     reinterpret_cast<mets::permutation_problem&>(s);
@@ -62,11 +62,11 @@ mets::swap_subsequence::apply(mets::feasible_solution& s)
 }
 
 bool
-mets::swap_subsequence::operator==(const mets::mana_move& o) const
+mets::invert_subsequence::operator==(const mets::mana_move& o) const
 {
   try {
-    const mets::swap_subsequence& other = 
-      dynamic_cast<const mets::swap_subsequence&>(o);
+    const mets::invert_subsequence& other = 
+      dynamic_cast<const mets::invert_subsequence&>(o);
     return (this->p1 == other.p1 && this->p2 == other.p2);
   } catch (std::bad_cast& e) {
     return false;
diff --git a/metslib/mets.h b/metslib/mets.h
index cde0515..ba29236 100644
--- a/metslib/mets.h
+++ b/metslib/mets.h
@@ -394,12 +394,12 @@ namespace mets {
   ///
   /// @see mets::permutation_problem, mets::mana_move
   ///
-  class swap_subsequence : public mets::mana_move 
+  class invert_subsequence : public mets::mana_move 
   {
   public:  
 
     /// @brief A move that swaps from and to.
-    swap_subsequence(int from, int to) 
+    invert_subsequence(int from, int to) 
       : p1(from), p2(to) 
     { }
     
@@ -417,7 +417,7 @@ namespace mets {
     /// tabu list.
     mana_move* 
     clone() const 
-    { return new swap_subsequence(p1, p2); }
+    { return new invert_subsequence(p1, p2); }
     
     /// @brief An hash function used by the tabu list (the hash value is
     /// used to insert the move in an hash set).
@@ -437,8 +437,8 @@ namespace mets {
     int p1; ///< the first element to swap
     int p2; ///< the second element to swap
 
-    template <typename> 
-    friend class swap_neighborhood;
+    // template <typename> 
+    // friend class invert_full_neighborhood;
   };
 
   
@@ -665,6 +665,26 @@ namespace mets {
 
   };
 
+  /// @brief Generates a the full subsequence inversion neighborhood.
+  class invert_full_neighborhood : public mets::move_manager
+  {
+  public:
+    invert_full_neighborhood(int size) : move_manager()
+    {
+      for(int ii(0); ii!=size; ++ii)
+	for(int jj(0); jj!=size; ++jj)
+	  if(ii != jj)
+	    moves_m.push_back(new invert_subsequence(ii,jj));
+    } 
+
+    /// @brief Dtor.
+    ~invert_full_neighborhood() { }
+
+    /// @brief Selects a different set of moves at each iteration.
+    void refresh(mets::feasible_solution& s) { }
+
+  };
+
   /// @}
 
   /// @brief Functor class to permit hash_set of moves (used by tabu list)
diff --git a/test/permutation_problem_test.cc b/test/permutation_problem_test.cc
index 507a4cf..6f0d661 100644
--- a/test/permutation_problem_test.cc
+++ b/test/permutation_problem_test.cc
@@ -45,53 +45,53 @@ int main()
 	return 1;
       }
   }
-  // test swap_subsequence (1)
+  // test invert_subsequence (1)
   {
     p pi(10);
-    mets::swap_subsequence move(0,9);
+    mets::invert_subsequence move(0,9);
     move.apply(pi);
 
     int check[]={9,8,7,6,5,4,3,2,1,0};
     if(pi.pi_m != std::vector<int>(&check[0], &check[10]))
       {
-	cerr << "Failed swap_subsequence (1)." << endl;
+	cerr << "Failed invert_subsequence (1)." << endl;
 	return 1;
       }
   }
-  // test swap_subsequence (2)
+  // test invert_subsequence (2)
   {
     p pi(9);
-    mets::swap_subsequence move(0,8);
+    mets::invert_subsequence move(0,8);
     move.apply(pi);
 
     int check[]={8,7,6,5,4,3,2,1,0};
 
     if(pi.pi_m != std::vector<int>(&check[0], &check[9]))
       {
-	cerr << "Failed swap_subsequence (2)." << endl;
+	cerr << "Failed invert_subsequence (2)." << endl;
 	return 1;
       }
   }
 
-  // test swap_subsequence (3)
+  // test invert_subsequence (3)
   {
     p pi(9);
-    mets::swap_subsequence move(2,5);
+    mets::invert_subsequence move(2,5);
     move.apply(pi);
 
     int check[]={0,1,5,4,3,2,6,7,8};
 
     if(pi.pi_m != std::vector<int>(&check[0], &check[9]))
       {
-	cerr << "Failed swap_subsequence (3)." << endl;
+	cerr << "Failed invert_subsequence (3)." << endl;
 	return 1;
       }
   }
 
-  // test swap_subsequence (4)
+  // test invert_subsequence (4)
   {
     p pi(9);
-    mets::swap_subsequence move(5,2);
+    mets::invert_subsequence move(5,2);
     move.apply(pi);
 
     int check[]={7,6,5,3,4,2,1,0,8};
@@ -102,7 +102,7 @@ int main()
 
     if(pi.pi_m != std::vector<int>(&check[0], &check[9]))
       {
-	cerr << "Failed swap_subsequence (4)." << endl;
+	cerr << "Failed invert_subsequence (4)." << endl;
 	return 1;
       }
   }