gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/examples/packing.cc

@@ -0,0 +1,211 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:06:52 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3517 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/**
+ * \name Specifications for packing problems
+ *
+ * \relates Packing
+ */
+//@
+/// Packing problem specification
+class PackingSpec {
+public:
+  int x; int y;
+  int n; const int* s;
+  PackingSpec(int x0, int y0, const int s0[]) :
+    x(x0), y(y0), s(s0) {
+    int i = 0;
+    while (s[i]) i++;
+    n = i;
+  }
+};
+
+static const int s0_s[] = {2,2,2,2,0};
+static const PackingSpec s0(4,4,s0_s);
+
+static const int s1_s[] = {3,2,2,1,1,1,0};
+static const PackingSpec s1(5,4,s1_s);
+
+static const int s2_s[] = {6,4,4,4,2,2,2,2,0};
+static PackingSpec s2(10,10,s2_s);
+
+static const int s3_s[] = {9,8,8,7,5,4,4,4,4,4,3,3,3,2,2,1,1,0};
+static const PackingSpec s3(20,20,s3_s);
+
+static const int s4_s[] = {18,15,14,10,9,8,7,4,1,0};
+static const PackingSpec s4(32,33,s4_s);
+
+static const int s5_s[] = {25,24,23,22,19,17,11,6,5,3,0};
+static const PackingSpec s5(65,47,s5_s);
+
+static const int s6_s[] = {50,42,37,35,33,29,27,25,24,19,18,
+			   17,16,15,11,9,8,7,6,4,2,0};
+static const PackingSpec s6(112,112,s6_s);
+
+static const int s7_s[] = {81,64,56,55,51,43,39,38,35,33,31,30,29,20,
+			   18,16,14,9,8,5,4,3,2,1,0};
+static const PackingSpec s7(175,175,s7_s);
+
+static const PackingSpec* specs[] = {&s0,&s1,&s2,&s3,&s4,&s5,&s6,&s7};
+static const unsigned int n_examples = sizeof(specs) / sizeof(PackingSpec*);
+//@}
+
+/**
+ * \brief %Example: packing squares into a rectangle
+ *
+ * \ingroup Example
+ */
+class Packing : public Example {
+protected:
+  /// Specification used
+  const PackingSpec& s;
+  /// Array of x-coordinates of squares
+  IntVarArray x;
+  /// Array of y-coordinates of squares
+  IntVarArray y;
+public:
+  /// Actual model
+  Packing(const Options& opt)
+    : s(*specs[opt.size]),
+      x(this,s.n,0,s.x-1), y(this,s.n,0,s.y-1) {
+
+    // Restrict position according to square size
+    for (int i=s.n; i--; ) {
+      rel(this, x[i], IRT_LQ, s.x-s.s[i]);
+      rel(this, y[i], IRT_LQ, s.y-s.s[i]);
+    }
+
+    // Squares do not overlap
+    for (int i=0; i<s.n; i++)
+      for (int j=i+1; j<s.n; j++)
+	post(this, tt(~(x[j]-x[i] >= s.s[i]) || ~(x[i]-x[j] >= s.s[j]) ||
+		      ~(y[j]-y[i] >= s.s[i]) || ~(y[i]-y[j] >= s.s[j])));
+
+    /*
+     * Symmetry breaking
+     *
+     */
+    for (int i=s.n-1; i--; )
+      if (s.s[i] == s.s[i+1])
+	rel(this, x[i], IRT_LQ, x[i+1]);
+
+    /*
+     * Capacity constraints
+     *
+     */
+    if (opt.naive) {
+      IntArgs sa(s.n,s.s);
+      BoolVarArgs b(s.n);
+      for (int cx=0; cx<s.x; cx++) {
+	for (int i=0; i<s.n; i++) {
+	  BoolVar b_cx(this,0,1);
+	  dom(this, x[i], cx-s.s[i]+1, cx, b_cx);
+	  b[i] = b_cx;
+	}
+	linear(this, sa, b, IRT_EQ, s.y);
+      }
+      for (int cy=0; cy<s.y; cy++) {
+	for (int i=0; i<s.n; i++) {
+	  BoolVar b_cy(this,0,1);
+	  dom(this, y[i], cy-s.s[i]+1, cy, b_cy);
+	  b[i] = b_cy;
+	}
+	linear(this, sa, b, IRT_EQ, s.x);
+      }
+    } else {
+      IntArgs m(s.n), dh(s.n);
+      for (int i = s.n; i--; ) {
+	m[i]  = 0;
+	dh[i] = s.s[i];
+      }
+      IntVarArgs e(s.n);
+      IntArgs limit(1);
+      {
+	// x-direction
+	for (int i = s.n; i--; ) {
+	  IntVar ei(this, 0, s.x);
+	  e[i] = ei;
+	}
+	limit[0] = s.y;
+	cumulatives(this, m, x, dh, e, dh, limit,  true);
+	cumulatives(this, m, x, dh, e, dh, limit, false);
+      }
+      {
+	// y-direction
+	for (int i = s.n; i--; ) {
+	  IntVar ei(this, 0, s.y);
+	  e[i] = ei;
+	}
+	limit[0] = s.x;
+	cumulatives(this, m, y, dh, e, dh, limit,  true);
+	cumulatives(this, m, y, dh, e, dh, limit, false);
+      }
+    }
+
+    branch(this, x, BVAR_MIN_MIN, BVAL_MIN);
+    branch(this, y, BVAR_MIN_MIN, BVAL_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  Packing(bool share, Packing& s) : Example(share,s), s(s.s) {
+    x.update(this, share, s.x);
+    y.update(this, share, s.y);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Packing(share,*this);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    for (int i=0; i<s.n; i++)
+      std::cout << "(" << x[i] << "," << y[i] << ") ";
+    std::cout << std::endl;
+  }
+};
+
+/** \brief Main-function
+ *  \relates Packing
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Packing");
+  opt.naive = true;
+  opt.size  = 7;
+  opt.parse(argc,argv);
+  if (opt.size >= n_examples) {
+    std::cerr << "Error: size must be between 0 and " << n_examples - 1
+	      << std::endl;
+    return 1;
+  }
+  Example::run<Packing,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/partition.cc

@@ -0,0 +1,126 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:06:52 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3517 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "examples/support.hh"
+
+/**
+ * \brief %Example: partition numbers into two groups
+ *
+ * \ingroup Example
+ */
+class Partition : public Example {
+protected:
+  /// First group of numbers
+  IntVarArray x;
+  /// Second group of numbers
+  IntVarArray y;
+public:
+  /// Actual model
+  Partition(const Options& opt)
+    : x(this,opt.size,1,2*opt.size),
+      y(this,opt.size,1,2*opt.size) {
+    const int n = opt.size;
+    // Break symmetries by ordering numbers in each group
+    for (int i = n-1; i--; ) {
+      rel(this, x[i], IRT_LE, x[i+1]);
+      rel(this, y[i], IRT_LE, y[i+1]);
+    }
+    rel(this, x[0], IRT_LE, y[0]);
+
+    IntVarArgs xy(2*n);
+    for (int i = n; i--; ) {
+      xy[i] = x[i]; xy[n+i] = y[i];
+    }
+    distinct(this, xy, opt.icl);
+    IntArgs c(2*n);
+    for (int i = n; i--; ) {
+      c[i] = 1; c[n+i] = -1;
+    }
+    linear(this, c, xy, IRT_EQ,0);
+
+    // Array of products
+    IntVarArray sxy(this,2*n,1,4*n*n);
+    IntVarArgs sx(n);
+    IntVarArgs sy(n);
+
+    for (int i = n; i--; ) {
+      mult(this,x[i],x[i],sxy[i]);   sx[i] = sxy[i];
+      mult(this,y[i],y[i],sxy[n+i]); sy[i] = sxy[n+i];
+    }
+    linear(this, c,sxy,IRT_EQ,0);
+
+    // Redundant
+    linear(this, x, IRT_EQ, 2*n*(2*n+1)/4);
+    linear(this, y, IRT_EQ, 2*n*(2*n+1)/4);
+    linear(this, sx, IRT_EQ, 2*n*(2*n+1)*(4*n+1)/12);
+    linear(this, sy, IRT_EQ, 2*n*(2*n+1)*(4*n+1)/12);
+    branch(this, xy, BVAR_SIZE_MIN, BVAL_MIN);
+  }
+
+  /// Constructor used during cloning \a s
+  Partition(bool share, Partition& s) : Example(share,s) {
+    x.update(this, share, s.x);
+    y.update(this, share, s.y);
+  }
+  /// Copying during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Partition(share,*this);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    int a, b;
+    a = b = 0;
+    for (int i = 0; i < x.size(); i++) {
+      a += x[i].val();
+      b += x[i].val()*x[i].val();
+      std::cout << x[i] << ", ";
+    }
+    std::cout << " = " << a << ", " << b << std::endl << "\t";
+    a = b = 0;
+    for (int i = 0; i < y.size(); i++) {
+      a += y[i].val();
+      b += y[i].val()*y[i].val();
+      std::cout << y[i] << ", ";
+    }
+    std::cout << " = " << a << ", " << b << std::endl;
+  }
+};
+
+/**
+ * \brief Main-functiona
+ * \relates Partition
+ */
+int
+main(int argc, char** argv) {
+  Options o("Partition");
+  o.size = 32;
+  o.icl  = ICL_DOM;
+  o.parse(argc,argv);
+  Example::run<Partition,DFS>(o);
+  return 0;
+}
+
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/photo.cc

@@ -0,0 +1,155 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:06:52 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3517 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/// Specifications for the Photo example
+class PhotoSpec {
+public:
+  const int  n_names; ///< Number of people on picture
+  const int  n_prefs; ///< Number of preferences
+  const int* prefs;   ///< Array of preferences
+  PhotoSpec(const int n_n, const int n_p, const int* p)
+    : n_names(n_n), n_prefs(n_p), prefs(p) {}
+};
+
+/// Preferences for small example
+static const int s_prefs[] = {
+  0,2, 1,4, 2,3, 2,4, 3,0, 4,3, 4,0, 4,1
+};
+/// Small Photo example
+static const PhotoSpec p_small(5, 8, s_prefs);
+
+/// Preferences for large example
+static const int l_prefs[] = {
+  0,2, 0,4, 0,7, 1,4, 1,8, 2,3, 2,4, 3,0, 3,4,
+  4,5, 4,0, 5,0, 5,8, 6,2, 6,7, 7,8, 7,6
+};
+/// Large Photo example
+static const PhotoSpec p_large(9,17, l_prefs);
+
+/**
+ * \brief %Example: Placing people on a photo
+ *
+ * A group of people wants to take a group photo. Each person can give
+ * preferences next to whom he or she wants to be placed on the
+ * photo. The problem to be solved is to find a placement that
+ * satisfies as many preferences as possible.
+ *
+ * \ingroup Example
+ *
+ */
+class Photo : public Example {
+protected:
+  /// Photo specification
+  const PhotoSpec& spec;
+  /// Person's position on photo
+  IntVarArray      pos;
+  /// Number of satisfied preferences
+  IntVar           sat;
+
+public:
+  /// Actual model
+  Photo(const Options& opt) :
+    spec(opt.size == 0 ? p_small : p_large),
+    pos(this,spec.n_names, 0, spec.n_names-1),
+    sat(this,0,spec.n_prefs)
+  {
+    BoolVarArgs ful(spec.n_prefs);
+    // Map preferences to fulfilment
+    for (int i = spec.n_prefs; i--; ) {
+      int pa = spec.prefs[2*i+0];
+      int pb = spec.prefs[2*i+1];
+      ful[i] = post(this,
+		    ~(pos[pb]-pos[pa] == 1) ^
+		    ~(pos[pa]-pos[pb] == 1));
+    }
+    // Sum of fulfilment
+    {
+      IntVarArgs eq(spec.n_prefs+1);
+      IntArgs    c(spec.n_prefs+1);
+      eq[spec.n_prefs] = sat; c[spec.n_prefs] = -1;
+      for (int i = spec.n_prefs; i--; ) {
+	eq[i] = ful[i]; c[i] = 1;
+      }
+      linear(this, c, eq, IRT_EQ, 0);
+    }
+    distinct(this, pos, opt.icl);
+
+    // Break some symmetries
+    rel(this, pos[0], IRT_LE, pos[1]);
+
+    if (opt.naive) {
+      branch(this, pos, BVAR_NONE, BVAL_MIN);
+    } else {
+      branch(this, pos, BVAR_DEGREE_MAX, BVAL_MIN);
+    }
+  }
+
+  /// Constructor for cloning \a s
+  Photo(bool share, Photo& s) :
+    Example(share,s), spec(s.spec) {
+    pos.update(this, share, s.pos);
+    sat.update(this, share, s.sat);
+  }
+
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Photo(share,*this);
+  }
+
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\tpos[] = {";
+    for (int i = 0; i < spec.n_names; i++)
+      std::cout << pos[i] << ((i<spec.n_names-1)?",":"};\n");
+    std::cout << "\tsat: " << sat << std::endl;
+  }
+
+  /// Add constraint for next better solution
+  void
+  constrain(Space* s) {
+    rel(this, sat, IRT_GR, static_cast<Photo*>(s)->sat.val());
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates Photo
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Photo");
+  opt.solutions  = 0;
+  opt.size       = 1;
+  opt.iterations = 10;
+  opt.icl        = ICL_BND;
+  opt.parse(argc,argv);
+  Example::run<Photo,BAB>(opt);
+  return 0;
+}
+
+
+// STATISTICS: example-any
+