Cost-based variants for circuit

Christian Schulte · Christian Schulte · commit 0bee47e8828d · 2009-07-20T14:58:11.000Z
git-svn-id: file:///Users/tack/GecodeGitMigration/gecode-svn-mirror/gecode/trunk@9381 e85b7adc-8362-4630-8c63-7469d557c915
diff --git a/changelog.in b/changelog.in
@@ -72,13 +72,20 @@ Date: ?
 [DESCRIPTION]
 The next release.
 
+[ENTRY]
+Module: graph
+What:   new
+Rank:   minor
+[DESCRIPTION]
+Cost-based variants for circuit added.
+
 [ENTRY]
 Module: set
 What:   change
 Rank:   minor
 [DESCRIPTION]
-The element constraint with an integer index variable now throws an exception 
-if used with an empty array.
+The element constraint with an integer index variable now throws
+an exception if used with an empty array.
 
 [ENTRY]
 Module: int
diff --git a/examples/tsp.cpp b/examples/tsp.cpp
@@ -178,6 +178,8 @@ namespace {
     int size(void) const;
     /// Return distance between node \a i and \a j
     int d(int i, int j) const;
+    /// Return distances
+    const int* d(void) const;
     /// Return estimate for maximal cost of a path
     int max(void) const;
   };
@@ -193,6 +195,10 @@ namespace {
   Problem::d(int i, int j) const {
     return _d[i*_n+j];
   }
+  inline const int*
+  Problem::d(void) const {
+    return _d;
+  }
   inline int
   Problem::max(void) const {
     int m=0;
@@ -234,31 +240,25 @@ class TSP : public MinimizeScript {
     : p(ps[opt.size()]),
       succ(*this, p.size(), 0, p.size()-1),
       total(*this, 0, p.max()) {
+    int n = p.size();
 
-    // Cost of each edge
-    IntVarArgs costs(p.size());
-    // Distances
-    IntArgs d(p.size());
+    // Cost matrix
+    IntArgs c(n*n, p.d());
 
-    // Setup costs for edges
-    for (int i=p.size(); i--; ) {
-      int m=0;
-      for (int j=p.size(); j--; ) {
-        d[j] = p.d(i,j);
-        m = std::max(m, d[j]);
-        if (d[j] == 0)
+    for (int i=n; i--; )
+      for (int j=n; j--; )
+        if (p.d(i,j) == 0)
           rel(*this, succ[i], IRT_NQ, j);
-      }
-      costs[i].init(*this,0,m);
-      // Propagate cost for chosen edge
-      element(*this, d, succ[i], costs[i]);
-    }
 
-    // Cost ist sume of all costs
-    linear(*this, costs, IRT_EQ, total);
+    // Cost of each edge
+    IntVarArgs costs(n);
+
+    // Initialize cost variables for edges
+    for (int i=n; i--; )
+      costs[i].init(*this, Int::Limits::min, Int::Limits::max);
 
-    // Enforce that the succesors yield a tour
-    circuit(*this, succ, opt.icl());
+    // Enforce that the succesors yield a tour with appropriate costs
+    circuit(*this, c, succ, costs, total, opt.icl());
 
     // Just assume that the circle starts forwards
     rel(*this, succ[0], IRT_LE, succ[1]);
diff --git a/gecode/graph.hh b/gecode/graph.hh
@@ -91,12 +91,62 @@ namespace Gecode {
    * other values for \a icl), where this refers to whether value or
    * domain consistent distinct in enforced on \a x.
    *
-   * Throws an exception of type Int::ArgumentSame, if \a x
-   * contains the same unassigned variable multiply.
+   * Throws the following exceptions:
+   *  - Int::ArgumentSame, if \a x contains the same unassigned variable 
+   *    multiply.
+   *  - Int::TooFewArguments, if \a x has no elements.
    */
   GECODE_GRAPH_EXPORT void
   circuit(Space& home, const IntVarArgs& x,
           IntConLevel icl=ICL_DEF);
+  /** \brief Post propagator such that \a x forms a circuit with costs \a y and \a z
+   *
+   * \a x forms a circuit if the graph with edges \f$i\to j\f$ where
+   * \f$x_i=j\f$ has a single cycle covering all nodes. The integer array
+   * \a c gives the costs of all possible edges where \f$c_{i*|x|+j}\f$ is 
+   * the cost of the edge \f$i\to j\f$. The variable \a z is the cost of 
+   * the entire circuit. The variables \a y define the cost
+   * of the edge in \a x: that is, if \f$x_i=j\f$ then \f$y_i=c_{i*n+j}\f$.
+   *
+   * Supports domain (\a icl = ICL_DOM) and value propagation (all
+   * other values for \a icl), where this refers to whether value or
+   * domain consistent distinct in enforced on \a x for circuit.
+   *
+   * Throws the following exceptions:
+   *  - Int::ArgumentSame, if \a x contains the same unassigned variable 
+   *    multiply.
+   *  - Int::TooFewArguments, if \a x has no elements.
+   *  - Int::ArgumentSizeMismacth, if \a x and \a y do not have the same
+   *    size or if \f$|x|\times|x|\neq|c|\f$.
+   */
+  GECODE_GRAPH_EXPORT void
+  circuit(Space& home, 
+          const IntArgs& c,
+          const IntVarArgs& x, const IntVarArgs& y, IntVar z,
+          IntConLevel icl=ICL_DEF);
+  /** \brief Post propagator such that \a x forms a circuit with cost \a z
+   *
+   * \a x forms a circuit if the graph with edges \f$i\to j\f$ where
+   * \f$x_i=j\f$ has a single cycle covering all nodes. The integer array
+   * \a c gives the costs of all possible edges where \f$c_{i*|x|+j}\f$ is 
+   * the cost of the edge \f$i\to j\f$. The variable \a z is the cost of 
+   * the entire circuit.
+   *
+   * Supports domain (\a icl = ICL_DOM) and value propagation (all
+   * other values for \a icl), where this refers to whether value or
+   * domain consistent distinct in enforced on \a x for circuit.
+   *
+   * Throws the following exceptions:
+   *  - Int::ArgumentSame, if \a x contains the same unassigned variable 
+   *    multiply.
+   *  - Int::TooFewArguments, if \a x has no elements.
+   *  - Int::ArgumentSizeMismacth, if \f$|x|\times|x|\neq|c|\f$.
+   */
+  GECODE_GRAPH_EXPORT void
+  circuit(Space& home, 
+          const IntArgs& c,
+          const IntVarArgs& x, IntVar z,
+          IntConLevel icl=ICL_DEF);
   //@}
 
 }
diff --git a/gecode/graph/circuit.cpp b/gecode/graph/circuit.cpp
@@ -43,9 +43,9 @@ namespace Gecode {
   circuit(Space& home, const IntVarArgs& x, IntConLevel icl) {
     if (x.same(home))
       throw Int::ArgumentSame("Graph::circuit");
-    if (home.failed()) return;
     if (x.size() == 0)
-      return;
+      throw Int::TooFewArguments("Graph::circuit");
+    if (home.failed()) return;
     ViewArray<Int::IntView> xv(home,x);
     if (icl == ICL_DOM) {
       GECODE_ES_FAIL(home,Graph::Circuit::Dom<Int::IntView>::post(home,xv));
@@ -54,6 +54,35 @@ namespace Gecode {
     }
   }
 
+  void
+  circuit(Space& home, const IntArgs& c, 
+          const IntVarArgs& x, const IntVarArgs& y, IntVar z, 
+          IntConLevel icl) {
+    int n = x.size();
+    if ((y.size() != n) || (c.size() != n*n))
+      throw Int::ArgumentSizeMismatch("Graph::circuit");
+    circuit(home, x, icl);
+    if (home.failed()) return;
+    IntArgs cx(n);
+    for (int i=n; i--; ) {
+      for (int j=0; j<n; j++)
+        cx[j] = c[i*n+j];
+      element(home, cx, x[i], y[i]);
+    }
+    linear(home, y, IRT_EQ, z);
+  }
+
+  void
+  circuit(Space& home, const IntArgs& c, 
+          const IntVarArgs& x, IntVar z, 
+          IntConLevel icl) {
+    if (home.failed()) return;
+    IntVarArgs y(x.size());
+    for (int i=x.size(); i--; )
+      y[i].init(home, Int::Limits::min, Int::Limits::max);
+    circuit(home, c, x, y, z);
+  }
+
 }
 
 // STATISTICS: graph-post
diff --git a/test/int/circuit.cpp b/test/int/circuit.cpp
@@ -80,6 +80,100 @@ namespace Test { namespace Int {
        }
      };
 
+     /// Simple test for circuit constraint with total cost
+     class CircuitCost : public Test {
+     public:
+       /// Create and register test
+       CircuitCost(int n, int min, int max, Gecode::IntConLevel icl)
+         : Test("Circuit::Cost::" + str(icl) + "::" + str(n),
+                n+1,min,max,false,icl) {
+         contest = CTL_NONE;
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n=x.size()-1;
+         for (int i=n; i--; )
+           if ((x[i] < 0) || (x[i] > n-1))
+             return false;
+         int reachable = 0;
+         {
+           int j=0;
+           for (int i=n; i--; ) {
+             j=x[j]; reachable |= (1 << j);
+           }
+         }
+         for (int i=n; i--; )
+           if (!(reachable & (1 << i)))
+             return false;
+         int c=0;
+         for (int i=n; i--; )
+           c += x[i];
+         return c == x[n];
+       }
+       /// Post circuit constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         int n=x.size()-1;
+         IntArgs c(n*n);
+         for (int i=0; i<n; i++)
+           for (int j=0; j<n; j++)
+             c[i*n+j]=j;
+         IntVarArgs y(n);
+         for (int i=0; i<n; i++)
+           y[i]=x[i];
+         circuit(home, c, y, x[n], icl);
+       }
+     };
+
+     /// Simple test for circuit constraint with full cost information
+     class CircuitFullCost : public Test {
+     public:
+       /// Create and register test
+       CircuitFullCost(int n, int min, int max, Gecode::IntConLevel icl)
+         : Test("Circuit::FullCost::" + str(icl) + "::" + str(n),
+                2*n+1,min,max,false,icl) {
+         contest = CTL_NONE;
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n=(x.size()-1) / 2;
+         for (int i=n; i--; )
+           if ((x[i] < 0) || (x[i] > n-1))
+             return false;
+         int reachable = 0;
+         {
+           int j=0;
+           for (int i=n; i--; ) {
+             j=x[j]; reachable |= (1 << j);
+           }
+         }
+         for (int i=n; i--; )
+           if (!(reachable & (1 << i)))
+             return false;
+         for (int i=n; i--; )
+           if ((x[i]/2) != x[n+i])
+             return false;
+         int c=0;
+         for (int i=n; i--; )
+           c += x[n+i];
+         return c == x[2*n];
+       }
+       /// Post circuit constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         int n=(x.size()-1)/2;
+         IntArgs c(n*n);
+         for (int i=0; i<n; i++)
+           for (int j=0; j<n; j++)
+             c[i*n+j]=(j/2);
+         IntVarArgs y(n), z(n);
+         for (int i=0; i<n; i++) {
+           y[i]=x[i]; z[i]=x[n+i];
+         }
+         circuit(home, c, y, z, x[2*n], icl);
+       }
+     };
+
      /// Help class to create and register tests
      class Create {
      public:
@@ -89,6 +183,10 @@ namespace Test { namespace Int {
            (void) new Circuit(i,0,i-1,Gecode::ICL_VAL);
            (void) new Circuit(i,0,i-1,Gecode::ICL_DOM);
          }
+         (void) new CircuitCost(4,0,9,Gecode::ICL_VAL);
+         (void) new CircuitCost(4,0,9,Gecode::ICL_DOM);
+         (void) new CircuitFullCost(3,0,3,Gecode::ICL_VAL);
+         (void) new CircuitFullCost(3,0,3,Gecode::ICL_DOM);
        }
      };
 
