dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/test/int/sequence.cpp

@@ -0,0 +1,168 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     David Rijsman <David.Rijsman@quintiq.com>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     David Rijsman, 2009
+ *     Christian Schulte, 2009
+ *
+ *  Last modified:
+ *     $Date: 2010-04-08 20:35:31 +1000 (Thu, 08 Apr 2010) $
+ *     $Revision: 10684 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/int.hh"
+
+#include <gecode/minimodel.hh>
+#include <climits>
+
+namespace Test { namespace Int {
+
+   /// %Tests for sequence constraints
+   namespace Sequence {
+
+     /**
+      * \defgroup TaskTestIntSequence Sequence constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// %Base test for sequence
+     class SequenceTest : public Test {
+     protected:
+       Gecode::IntSet s;
+       int q,l,u;
+     public:
+       /// Create and register test
+       SequenceTest(const std::string& s, 
+                    const Gecode::IntSet& s0, int q0, int l0, int u0, 
+                    int size, int min, int max)
+         : Test("Sequence::"+s,size,min,max), s(s0), q(q0), l(l0), u(u0) {
+       }
+       /// %Test whether \a x is solutionin
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i< (x.size() - q + 1); i++ ) {
+           int total = 0;
+           for (int j=i; j < i + q; j++ ) {
+             if (s.in(x[j]))
+               total++;
+             if (total > u)
+               return false;
+           }
+           if ( total < l )
+             return false;
+         }
+         return true;
+       }
+     };
+     
+     
+     /// %Test for sequence with boolean variables
+     class SequenceBoolTest : public SequenceTest {
+     public:
+       /// Create and register test
+       SequenceBoolTest(const std::string& s, const Gecode::IntSet& s0, 
+                        int q0, int l0, int u0, int size)
+         : SequenceTest("Bool::"+s,s0,q0,l0,u0,size,0,1) {
+       }
+       
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         Gecode::BoolVarArgs c(x.size());
+         
+         for (int i=0; i<x.size(); i++) {
+           c[i]=Gecode::channel(home,x[i]);
+         }
+         
+         Gecode::sequence(home,c,s,q,l,u);
+       }
+     };
+     
+     /// %Test for sequence with boolean variables
+     class SequenceIntTest : public SequenceTest {
+     public:
+       /// Create and register test
+       SequenceIntTest(const std::string& s, const Gecode::IntSet& s0,
+                       int q0, int l0, int u0, int size, int min, int max)
+         : SequenceTest("Int::"+s,s0,q0,l0,u0,size,min,max) {
+       }
+       
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         Gecode::sequence(home,x,s,q,l,u);
+       }
+     };
+
+     /// Help class to create and register tests
+     class Create {
+     public:
+
+       /// Perform creation and registration
+       Create(void) {
+         using namespace Gecode;
+
+         IntSet a(0,0);
+         IntSet b(1,1);
+         IntSet c(2,2);
+         IntSet d(0,1);
+         IntArgs ie(2, 0,2);
+         IntSet e(ie);
+
+         (void) new SequenceBoolTest("A",a,3,2,2,6);
+         (void) new SequenceBoolTest("B",b,3,2,2,6);
+         (void) new SequenceBoolTest("C",b,6,2,2,6);
+         (void) new SequenceBoolTest("D",b,6,0,0,6);
+         (void) new SequenceBoolTest("E",b,6,6,6,6);
+
+
+         (void) new SequenceIntTest ("A",c,3,2,2,6,2,3);
+         (void) new SequenceIntTest ("B",c,3,2,2,6,2,4);
+         (void) new SequenceIntTest ("C",b,3,2,2,6,1,3);
+         (void) new SequenceIntTest ("D",c,3,0,0,3,1,3);
+         (void) new SequenceIntTest ("E",c,3,3,3,3,1,3);
+         (void) new SequenceIntTest ("F",c,3,2,2,10,2,3);
+
+         (void) new SequenceIntTest ("G",d,3,2,2,6,0,3);
+         (void) new SequenceIntTest ("H",d,3,2,2,6,0,4);
+         (void) new SequenceIntTest ("I",d,3,2,2,6,1,3);
+         (void) new SequenceIntTest ("J",e,3,0,0,6,0,3);
+         (void) new SequenceIntTest ("K",e,3,3,3,6,0,3);
+         (void) new SequenceIntTest ("L",e,3,2,2,6,0,3);
+
+       }
+     };
+
+     Create c;
+     //@}
+
+   }
+}}
+
+// STATISTICS: test-int

data/ext/libgecode3/vendor/gecode-3.7.3/test/int/sorted.cpp

@@ -0,0 +1,165 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2005
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2010-04-08 20:35:31 +1000 (Thu, 08 Apr 2010) $ by $Author: schulte $
+ *     $Revision: 10684 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/int.hh"
+
+namespace Test { namespace Int {
+
+   /// %Tests for sorted constraints
+   namespace Sorted {
+
+     /**
+      * \defgroup TaskTestIntSorted Sorted constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+
+     /// Relation for sorting integers in increasing order
+     class SortIntMin {
+     public:
+       /// %Test whether \a x is less than \a y
+       bool operator()(const int x, const int y) {
+         return x<y;
+       }
+     };
+
+     /// %Test sorted without permutation variables
+     class NoVar : public Test {
+     protected:
+       /// Number of variables to be sorted
+       static const int n = 3;
+     public:
+       /// Create and register test
+       NoVar(void) : Test("Sorted::NoVar",2*n,0,3) {}
+       /// %Test whether \a xy is solution
+       virtual bool solution(const Assignment& xy) const {
+         int x[n], y[n];
+         for (int i=0;i<3; i++) {
+           x[i]=xy[i]; y[i]=xy[n+i];
+         }
+
+         for (int i=0; i<n-1; i++)
+           if (y[i]>y[i+1])
+             return false;
+
+         SortIntMin sim;
+         Gecode::Support::quicksort<int,SortIntMin>(x,n,sim);
+
+         for (int i=0; i<n; i++)
+           if (x[i] != y[i])
+             return false;
+         return true;
+       }
+       /// Post constraint on \a xy
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& xy) {
+         Gecode::IntVarArgs x(n), y(n);
+         for (int i=0; i<n; i++) {
+           x[i]=xy[i]; y[i]=xy[n+i];
+         }
+         Gecode::sorted(home,x,y);
+       }
+     };
+
+
+     /// %Test sorted with permutation variables
+     class PermVar : public Test {
+     protected:
+       /// Number of variables to be sorted
+       static const int n = 3;
+     public:
+       /// Create and register test
+       PermVar(void) : Test("Sorted::PermVar",3*n,0,2) {}
+       /// %Test whether \a xyz is solution
+       virtual bool solution(const Assignment& xyz) const {
+         int x[n], y[n], z[n];
+         for (int i=0; i<n; i++) {
+           x[i]=xyz[i]; y[i]=xyz[n+i]; z[i]=xyz[2*n+i];
+         }
+         // check for permutation
+         for (int i=0; i<n; i++)
+           for (int j=i+1; j<n; j++)
+             if (z[i]==z[j])
+               return false;
+
+         // y must to be sorted
+         for (int i=0; i<n-1; i++)
+           if (y[i]>y[i+1])
+             return false;
+
+         // check whether permutation is in range
+         for (int i=0; i<n; i++)
+           if ((z[i] < 0) || (z[i] >= n))
+             return false;
+
+         // check whether permutation info is correct
+         for (int i=0; i<n; i++)
+           if (x[i] != y[z[i]])
+             return false;
+
+         // check for sorting
+         SortIntMin sim;
+         Gecode::Support::quicksort<int,SortIntMin>(x,n,sim);
+         for (int i=0; i<n; i++)
+           if (x[i] != y[i])
+             return false;
+
+         return true;
+       }
+       /// Post constraint on \a xyz
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& xyz) {
+         Gecode::IntVarArgs x(n), y(n), z(n);
+         for (int i=0; i<n; i++) {
+           x[i]=xyz[i]; y[i]=xyz[n+i]; z[i]=xyz[2*n+i];
+         }
+         Gecode::sorted(home,x,y,z);
+       }
+     };
+
+
+     NoVar novar;
+     PermVar permvar;
+     //@}
+
+   }
+}}
+
+// STATISTICS: test-int
+

data/ext/libgecode3/vendor/gecode-3.7.3/test/int/unary.cpp

@@ -0,0 +1,327 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2009
+ *
+ *  Last modified:
+ *     $Date: 2011-05-26 00:56:41 +1000 (Thu, 26 May 2011) $ by $Author: schulte $
+ *     $Revision: 12022 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/int.hh"
+
+#include <gecode/minimodel.hh>
+
+namespace Test { namespace Int {
+
+   /// %Tests for unary scheduling constraints
+   namespace Unary {
+
+     /**
+      * \defgroup TaskTestIntUnary Unary scheduling constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// %Test for unary constraint
+     class ManFixPUnary : public Test {
+     protected:
+       /// The processing times
+       Gecode::IntArgs p;
+       /// Get a reasonable maximal start time
+       static int st(const Gecode::IntArgs& p) {
+         int t = 0;
+         for (int i=p.size(); i--; )
+           t += p[i];
+         return t;
+       }
+     public:
+       /// Create and register test
+       ManFixPUnary(const Gecode::IntArgs& p0, int o)
+         : Test("Unary::Man::Fix::"+str(o)+"::"+str(p0),
+                p0.size(),o,o+st(p0)), 
+           p(p0) {
+         testsearch = false;
+         contest = CTL_NONE;
+       }
+       /// Create and register initial assignment
+       virtual Assignment* assignment(void) const {
+         return new RandomAssignment(arity,dom,500);
+       }
+       /// %Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<x.size(); i++)
+           for (int j=i+1; j<x.size(); j++)
+             if ((x[i]+p[i] > x[j]) && (x[j]+p[j] > x[i]))
+               return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         Gecode::unary(home, x, p);
+       }
+     };
+
+     /// %Test for unary constraint with optional tasks
+     class OptFixPUnary : public Test {
+     protected:
+       /// The processing times
+       Gecode::IntArgs p;
+       /// Thereshold for taking a task as optional
+       int l;
+       /// Get a reasonable maximal start time
+       static int st(const Gecode::IntArgs& p) {
+         int t = 0;
+         for (int i=p.size(); i--; )
+           t += p[i];
+         return t;
+       }
+     public:
+       /// Create and register test
+       OptFixPUnary(const Gecode::IntArgs& p0, int o)
+         : Test("Unary::Opt::Fix::"+str(o)+"::"+str(p0),
+                2*p0.size(),o,o+st(p0)), p(p0), l(o+st(p)/2) {
+         testsearch = false;
+         contest = CTL_NONE;
+       }
+       /// Create and register initial assignment
+       virtual Assignment* assignment(void) const {
+         return new RandomAssignment(arity,dom,500);
+       }
+       /// %Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size() / 2;
+         for (int i=0; i<n; i++)
+           if (x[n+i] > l)
+             for (int j=i+1; j<n; j++)
+               if(x[n+j] > l)
+                 if ((x[i]+p[i] > x[j]) && (x[j]+p[j] > x[i]))
+                   return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         int n=x.size() / 2;
+         Gecode::IntVarArgs s(n);
+         Gecode::BoolVarArgs m(n);
+         for (int i=0; i<n; i++) {
+           s[i]=x[i];
+           m[i]=Gecode::expr(home, (x[n+i] > l));
+         }
+         Gecode::unary(home, s, p, m);
+       }
+     };
+
+
+     /// %Test for unary constraint
+     class ManFlexUnary : public Test {
+     protected:
+       /// Minimum processing time
+       int _minP;
+       /// Maximum processing time
+       int _maxP;
+       /// Offset for start times
+       int off;
+     public:
+       /// Create and register test
+       ManFlexUnary(int n, int minP, int maxP, int o)
+         : Test("Unary::Man::Flex::"+str(o)+"::"+str(n)+"::"
+                +str(minP)+"::"+str(maxP),
+                2*n,0,n*maxP), _minP(minP), _maxP(maxP), off(o) {
+         testsearch = false;
+         testfix = false;
+         contest = CTL_NONE;
+       }
+       /// Create and register initial assignment
+       virtual Assignment* assignment(void) const {
+         return new RandomMixAssignment(arity/2,dom,arity/2,
+                                        Gecode::IntSet(_minP,_maxP),500);
+       }
+       /// %Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size()/2;
+         for (int i=0; i<n; i++)
+           for (int j=i+1; j<n; j++)
+             if ((x[i]+x[n+i] > x[j]) && (x[j]+x[n+j] > x[i]))
+               return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         Gecode::IntVarArgs s(x.size()/2);
+         Gecode::IntVarArgs px(x.slice(x.size()/2));
+         Gecode::IntVarArgs e(home,x.size()/2,
+                              Gecode::Int::Limits::min,
+                              Gecode::Int::Limits::max);
+         for (int i=s.size(); i--;) {
+           s[i] = expr(home, off+x[i]);
+           rel(home, s[i]+px[i] == e[i]);
+           rel(home, _minP <= px[i]);
+           rel(home, _maxP >= px[i]);
+         }
+         Gecode::unary(home, s, px, e);
+       }
+     };
+
+     /// %Test for unary constraint with optional tasks
+     class OptFlexUnary : public Test {
+     protected:
+       /// Minimum processing time
+       int _minP;
+       /// Maximum processing time
+       int _maxP;
+       /// Offset for start times
+       int off;
+       /// Thereshold for taking a task as optional
+       int l;
+       /// Get a reasonable maximal start time
+       static int st(const Gecode::IntArgs& p) {
+         int t = 0;
+         for (int i=p.size(); i--; )
+           t += p[i];
+         return t;
+       }
+     public:
+       /// Create and register test
+       OptFlexUnary(int n, int minP, int maxP, int o)
+         : Test("Unary::Opt::Flex::"+str(o)+"::"+str(n)+"::"
+                +str(minP)+"::"+str(maxP),
+                3*n,0,n*maxP), _minP(minP), _maxP(maxP), off(o),
+                l(n*maxP/2) {
+         testsearch = false;
+         testfix = false;
+         contest = CTL_NONE;
+       }
+       /// Create and register initial assignment
+       virtual Assignment* assignment(void) const {
+         return new RandomMixAssignment(2*(arity/3),dom,arity/3,
+                                        Gecode::IntSet(_minP,_maxP),500);
+       }
+       /// %Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size() / 3;
+         for (int i=0; i<n; i++)
+           if (x[n+i] > l)
+             for (int j=i+1; j<n; j++)
+               if(x[n+j] > l)
+                 if ((x[i]+x[2*n+i] > x[j]) && (x[j]+x[2*n+j] > x[i]))
+                   return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         int n=x.size() / 3;
+
+         Gecode::IntVarArgs s(n);
+         Gecode::IntVarArgs px(n);
+         Gecode::IntVarArgs e(home,n,
+                              Gecode::Int::Limits::min,
+                              Gecode::Int::Limits::max);
+         for (int i=n; i--;) {
+           s[i] = expr(home, off+x[i]);
+           px[i] = x[2*n+i];
+           rel(home, s[i]+px[i] == e[i]);
+           rel(home, _minP <= px[i]);
+           rel(home, _maxP >= px[i]);
+         }
+         Gecode::BoolVarArgs m(n);
+         for (int i=0; i<n; i++)
+           m[i]=Gecode::expr(home, (x[n+i] > l));
+         Gecode::unary(home, s, px, e, m);
+       }
+     };
+
+     Gecode::IntArgs p1(4, 2,2,2,2);
+     ManFixPUnary mfu10(p1,0);
+     ManFixPUnary mfu1i(p1,Gecode::Int::Limits::min);
+     OptFixPUnary ofu10(p1,0);
+     OptFixPUnary ofu1i(p1,Gecode::Int::Limits::min);
+     ManFlexUnary mflu10(4,0,2,0);
+     ManFlexUnary mflu1i(4,0,2,Gecode::Int::Limits::min);
+     ManFlexUnary mflu101(4,1,3,0);
+     ManFlexUnary mflu1i1(4,1,3,Gecode::Int::Limits::min);
+     OptFlexUnary oflu10(4,0,2,0);
+     OptFlexUnary oflu1i(4,0,2,Gecode::Int::Limits::min);
+
+     Gecode::IntArgs p10(5, 2,2,0,2,2);
+     ManFixPUnary mfu010(p10,0);
+     ManFixPUnary mfu01i(p10,Gecode::Int::Limits::min);
+     OptFixPUnary ofu010(p10,0);
+     OptFixPUnary ofu01i(p10,Gecode::Int::Limits::min);
+     ManFlexUnary mflu010(5,0,2,0);
+     ManFlexUnary mflu01i(5,0,2,Gecode::Int::Limits::min);
+     OptFlexUnary oflu010(5,0,2,0);
+     OptFlexUnary oflu01i(5,0,2,Gecode::Int::Limits::min);
+
+     Gecode::IntArgs p2(4, 4,3,3,5);
+     ManFixPUnary mfu20(p2,0);
+     ManFixPUnary mfu2i(p2,Gecode::Int::Limits::min);
+     OptFixPUnary ofu20(p2,0);
+     OptFixPUnary ofu2i(p2,Gecode::Int::Limits::min);
+     ManFlexUnary mflu20(4,3,5,0);
+     ManFlexUnary mflu2i(4,3,5,Gecode::Int::Limits::min);
+     OptFlexUnary oflu20(4,3,5,0);
+     OptFlexUnary oflu2i(4,3,5,Gecode::Int::Limits::min);
+
+     Gecode::IntArgs p20(6, 4,0,3,3,0,5);
+     ManFixPUnary mfu020(p20,0);
+     ManFixPUnary mfu02i(p20,Gecode::Int::Limits::min);
+     OptFixPUnary ofu020(p20,0);
+     OptFixPUnary ofu02i(p20,Gecode::Int::Limits::min);
+     ManFlexUnary mflu020(6,0,5,0);
+     ManFlexUnary mflu02i(6,0,5,Gecode::Int::Limits::min);
+     OptFlexUnary oflu020(6,0,5,0);
+     OptFlexUnary oflu02i(6,0,5,Gecode::Int::Limits::min);
+
+     Gecode::IntArgs p3(6, 4,2,9,3,7,5);
+     ManFixPUnary mfu30(p3,0);
+     ManFixPUnary mfu3i(p3,Gecode::Int::Limits::min);
+     OptFixPUnary ofu30(p3,0);
+     OptFixPUnary ofu3i(p3,Gecode::Int::Limits::min);
+     ManFlexUnary mflu30(6,2,7,0);
+     ManFlexUnary mflu3i(6,2,7,Gecode::Int::Limits::min);
+     OptFlexUnary oflu30(6,2,7,0);
+     OptFlexUnary oflu3i(6,2,7,Gecode::Int::Limits::min);
+
+     Gecode::IntArgs p30(8, 4,0,2,9,3,7,5,0);
+     ManFixPUnary mfu030(p30,0);
+     ManFixPUnary mfu03i(p30,Gecode::Int::Limits::min);
+     OptFixPUnary ofu030(p30,0);
+     OptFixPUnary ofu03i(p30,Gecode::Int::Limits::min);
+     ManFlexUnary mflu030(8,0,9,0);
+     ManFlexUnary mflu03i(8,0,9,Gecode::Int::Limits::min);
+     OptFlexUnary oflu030(8,0,9,0);
+     OptFlexUnary oflu03i(8,0,9,Gecode::Int::Limits::min);
+
+     //@}
+
+   }
+}}
+
+// STATISTICS: test-int