gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/test/int/basic.cc

@@ -0,0 +1,77 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-29 08:39:39 +0100 (Fri, 29 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6362 $
+ *
+ *  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 basic setup
+   namespace Basic {
+   
+     /**
+      * \defgroup TaskTestIntBasic Basic setup
+      * \ingroup TaskTestInt
+      */
+     //@{
+   
+     /// Test whether testing infrastructure for integer variables works
+     class Basic : public Test {
+     public:
+       /// Initialize test
+       Basic(void)
+         : Test("Basic",3,-3,3,true) {}
+       /// Check whether \a x is a solution
+       virtual bool solution(const Assignment&) const {
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space*, Gecode::IntVarArray&) {
+       }
+       /// Post reified constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray&, 
+                         Gecode::BoolVar b) {
+         Gecode::rel(home, b, Gecode::IRT_EQ, 1);
+       }
+     };
+   
+     Basic b;
+     //@}
+   
+   }
+}}
+
+// STATISTICS: test-int

data/ext/gecode-2.2.0/test/int/bool.cc

@@ -0,0 +1,340 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-25 00:16:01 +0100 (Mon, 25 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6288 $
+ *
+ *  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 Boolean constraints
+   namespace Bool {
+
+     inline int
+     check(int x0, Gecode::BoolOpType op, int x1) {
+       switch (op) {
+       case Gecode::BOT_AND: return x0 & x1;
+       case Gecode::BOT_OR:  return x0 | x1;
+       case Gecode::BOT_IMP: return !x0 | x1;
+       case Gecode::BOT_EQV: return x0 == x1;
+       case Gecode::BOT_XOR: return x0 != x1;
+       default: GECODE_NEVER;
+       }
+       GECODE_NEVER;
+       return 0;
+     }
+
+     /**
+      * \defgroup TaskTestIntBool Boolean constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// Test for binary Boolean operation
+     class BinXYZ : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXYZ(Gecode::BoolOpType op0) 
+         : Test("Bool::Bin::XYZ::"+str(op0),3,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == x[2];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         rel(home, 
+             channel(home,x[0]), op, channel(home,x[1]), 
+             channel(home,x[2]));
+       }
+     };
+     
+     /// Test for binary Boolean operation with shared variables
+     class BinXXY : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXXY(Gecode::BoolOpType op0) 
+         : Test("Bool::Bin::XXY::"+str(op0),2,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[0]) == x[1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, b, channel(home,x[1]));
+       }
+     };
+     
+     /// Test for binary Boolean operation with shared variables
+     class BinXYX : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXYX(Gecode::BoolOpType op0) 
+         : Test("Bool::Bin::XYX::"+str(op0),2,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == x[0];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, channel(home,x[1]), b);
+       }
+     };
+     
+     /// Test for binary Boolean operation with shared variables
+     class BinXYY : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXYY(Gecode::BoolOpType op0) 
+         : Test("Bool::Bin::XYY::"+str(op0),2,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == x[1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[1]);
+         rel(home, channel(home,x[0]), op, b, b);
+       }
+     };
+     
+     /// Test for binary Boolean operation with shared variables
+     class BinXXX : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXXX(Gecode::BoolOpType op0) 
+         : Test("Bool::Bin::XXX::"+str(op0),1,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[0]) == x[0];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, b, b);
+       }
+     };
+     
+     /// Test for binary Boolean operation with constant
+     class BinConstXY : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+       /// Integer constant
+       int c;
+     public:
+       /// Construct and register test
+       BinConstXY(Gecode::BoolOpType op0, int c0) 
+         : Test("Bool::Bin::XY::"+str(op0)+"::"+str(c0),2,0,1), 
+           op(op0), c(c0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == c;
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         rel(home, channel(home,x[0]), op, channel(home,x[1]), c);
+       }
+     };
+     
+     /// Test for binary Boolean operation with shared variables and constant
+     class BinConstXX : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+       /// Integer constant
+       int c;
+     public:
+       /// Construct and register test
+       BinConstXX(Gecode::BoolOpType op0, int c0) 
+         : Test("Bool::Bin::XX::"+str(op0)+"::"+str(c0),1,0,1), 
+           op(op0), c(c0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[0]) == c;
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, b, c);
+       }
+     };
+     
+     /// Test for Nary Boolean operation
+     class Nary : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       Nary(Gecode::BoolOpType op0, int n) 
+         : Test("Bool::Nary::"+str(op0)+"::"+str(n),n+1,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int b = check(x[0],op,x[1]);
+         for (int i=2; i<x.size()-1; i++)
+           b = check(b,op,x[i]);
+         return b == x[x.size()-1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs b(x.size()-1);
+         for (int i=x.size()-1; i--; )
+           b[i]=channel(home,x[i]);
+         rel(home, op, b, channel(home,x[x.size()-1]));
+       }
+     };
+     
+     /// Test for Nary Boolean operation
+     class NaryShared : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       NaryShared(Gecode::BoolOpType op0, int n) 
+         : Test("Bool::Nary::Shared::"+str(op0)+"::"+str(n),n,0,1), 
+           op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int b = check(x[0],op,x[1]);
+         for (int i=2; i<x.size(); i++)
+           b = check(b,op,x[i]);
+         return b == x[x.size()-1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs b(x.size());
+         for (int i=x.size(); i--; )
+           b[i]=channel(home,x[i]);
+         rel(home, op, b, b[x.size()-1]);
+       }
+     };
+     
+     /// Test for Nary Boolean operation with constant
+     class NaryConst : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+       /// Integer constant
+       int c;
+     public:
+       /// Construct and register test
+       NaryConst(Gecode::BoolOpType op0, int n, int c0) 
+         : Test("Bool::Nary::"+str(op0)+"::"+str(n)+"::"+str(c0),n,0,1), 
+           op(op0), c(c0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int b = check(x[0],op,x[1]);
+         for (int i=2; i<x.size(); i++)
+           b = check(b,op,x[i]);
+         return b == c;
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs b(x.size());
+         for (int i=x.size(); i--; )
+           b[i]=channel(home,x[i]);
+         rel(home, op, b, c);
+       }
+     };
+     
+     /// Help class to create and register tests
+     class Create {
+     public:
+       /// Perform creation and registration
+       Create(void) {
+         using namespace Gecode;
+         for (BoolOpTypes bots; bots(); ++bots) {
+           (void) new BinXYZ(bots.bot());
+           (void) new BinXXY(bots.bot());
+           (void) new BinXYX(bots.bot());
+           (void) new BinXYY(bots.bot());
+           (void) new BinXXX(bots.bot());
+           (void) new BinConstXY(bots.bot(),0);
+           (void) new BinConstXY(bots.bot(),1);
+           (void) new BinConstXX(bots.bot(),0);
+           (void) new BinConstXX(bots.bot(),1);
+           (void) new Nary(bots.bot(),2);
+           (void) new Nary(bots.bot(),6);
+           (void) new Nary(bots.bot(),10);
+           (void) new NaryShared(bots.bot(),2);
+           (void) new NaryShared(bots.bot(),6);
+           (void) new NaryShared(bots.bot(),10);
+           (void) new NaryConst(bots.bot(),2,0);
+           (void) new NaryConst(bots.bot(),6,0);
+           (void) new NaryConst(bots.bot(),10,0);
+           (void) new NaryConst(bots.bot(),2,1);
+           (void) new NaryConst(bots.bot(),6,1);
+           (void) new NaryConst(bots.bot(),10,1);
+         }
+       }
+     };
+   
+     Create c;
+     //@}
+   
+   }
+}}
+
+// STATISTICS: test-int
+

data/ext/gecode-2.2.0/test/int/channel.cc

@@ -0,0 +1,238 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-08-20 18:02:33 +0200 (Wed, 20 Aug 2008) $ by $Author: schulte $
+ *     $Revision: 7665 $
+ *
+ *  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 channel constraints
+   namespace Channel {
+   
+     /**
+      * \defgroup TaskTestIntChannel Channel constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// Simple test for channel (testing all variables)
+     class ChannelFull : public Test {
+     private:
+       int xoff; //< Offset for the x variables
+       int yoff; //< Offset for the y variables
+     public:
+       /// Construct and register test
+       ChannelFull(Gecode::IntConLevel icl,
+                   unsigned int xoff0 = 0, unsigned int yoff0 = 0)
+         : Test("Channel::Full::"+str(icl)+"::"+
+                str(xoff0)+"::"+str(yoff0),8,0,3,false,icl),
+           xoff(xoff0), yoff(yoff0) {
+         testdomcon = false;
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<4; i++)
+           if (x[4+x[i]] != i)
+             return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         IntVarArgs xa(4); IntVarArgs ya(4);
+         for (int i=4; i--; ) {
+           if (xoff != 0) {
+             IntVar xo(home, xoff, 3+xoff);
+             Gecode::post(home, x[i] == xo-xoff);
+             xa[i] = xo;
+           } else {
+             xa[i] = x[i];             
+           }
+           if (yoff != 0) {
+             IntVar yo(home, yoff, 3+yoff);
+             Gecode::post(home, x[4+i] == yo-yoff);
+             ya[i] = yo;
+           } else {
+             ya[i] = x[4+i];             
+           }
+         }
+         channel(home, xa, xoff, ya, yoff, icl);
+       }
+     };
+     
+     /// Simple test for channel (testing single set of variables)
+     class ChannelHalf : public Test {
+     public:
+       /// Construct and register test
+       ChannelHalf(Gecode::IntConLevel icl)
+         : Test("Channel::Half::"+str(icl),6,0,5,false,icl) {
+         testdomcon = false;
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<6; i++)
+           for (int j=i+1; j<6; j++)
+             if (x[i] == x[j])
+               return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         Gecode::IntVarArgs y(6);
+         for (int i=0; i<6; i++)
+           y[i].init(home,dom);
+         for (int i=0; i<6; i++)
+           for (int j=0; j<6; j++) {
+             Gecode::BoolVar b(home,0,1);
+             rel(home, x[i], Gecode::IRT_EQ, j, b);
+             rel(home, y[j], Gecode::IRT_EQ, i, b);
+           }
+         channel(home, x, y, icl);
+       }
+     };
+     
+     /// Test channel with shared variables
+     class ChannelShared : public Test {
+     public:
+       /// Construct and register test
+       ChannelShared(Gecode::IntConLevel icl)
+         : Test("Channel::Shared::"+str(icl),6,0,5,false,icl) {
+         testdomcon = false;
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<6; i++)
+           if (x[x[i]] != i)
+             return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         channel(home, x, x, icl);
+       }
+     };
+     
+     /// Test channel between integer and Boolean variable
+     class ChannelLinkSingle : public Test {
+     public:
+       /// Construct and register test
+       ChannelLinkSingle(void)
+         : Test("Channel::Bool::Single",2,-1,2) {
+         testdomcon = false;
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return ((x[0]==0) || (x[0]==1)) && (x[0]==x[1]);
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         Gecode::BoolVar b(home,0,1);
+         channel(home, x[0], b);
+         channel(home, x[1], b);
+       }
+     };
+     
+     /// Test channel between integer variable and array of Boolean variables
+     class ChannelLinkMulti : public Test {
+     private:
+       int o;
+     public:
+       /// Construct and register test
+       ChannelLinkMulti(const std::string& s, int min, int max, int o0)
+         : Test("Channel::Bool::Multi::"+s,7,min,max), o(o0) {
+         testdomcon = false;
+       }
+       /// 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] != 1))
+             return false;
+         int k=x[n]-o;
+         if ((k<0) || (k>=n))
+           return false;
+         for (int i=0; i<k; i++)
+           if (x[i] != 0)
+             return false;
+         for (int i=k+1; i<n; i++)
+           if (x[i] != 0)
+             return false;
+         return x[k] == 1;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         int n=x.size()-1;
+         Gecode::BoolVarArgs b(n);
+         for (int i=n; i--; )
+           b[i]=channel(home,x[i]);
+         channel(home, b, x[n], o);
+       }
+     };
+     
+   
+   
+     ChannelFull cfd(Gecode::ICL_DOM);
+     ChannelFull cfv(Gecode::ICL_VAL);
+
+     ChannelFull cfd11(Gecode::ICL_DOM,1,1);
+     ChannelFull cfv11(Gecode::ICL_VAL,1,1);
+
+     ChannelFull cfd35(Gecode::ICL_DOM,3,5);
+     ChannelFull cfv35(Gecode::ICL_VAL,3,5);
+   
+     ChannelHalf chd(Gecode::ICL_DOM);
+     ChannelHalf chv(Gecode::ICL_VAL);
+   
+     ChannelShared csd(Gecode::ICL_DOM);
+     ChannelShared csv(Gecode::ICL_VAL);
+   
+     ChannelLinkSingle cls;
+   
+     ChannelLinkMulti clma("A", 0, 5, 0);
+     ChannelLinkMulti clmb("B", 1, 6, 1);
+     ChannelLinkMulti clmc("C",-1, 4,-1);
+     //@}
+   
+   }
+}}
+
+// STATISTICS: test-int
+