bool.cc

Go to the documentation of this file.

/* -*- 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 {

   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;
     }


     class BinXYZ : public Test {
     protected:
       Gecode::BoolOpType op;
     public:
       BinXYZ(Gecode::BoolOpType op0) 
         : Test("Bool::Bin::XYZ::"+str(op0),3,0,1), op(op0) {}
       virtual bool solution(const Assignment& x) const {
         return check(x[0],op,x[1]) == x[2];
       }
       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]));
       }
     };
     
     class BinXXY : public Test {
     protected:
       Gecode::BoolOpType op;
     public:
       BinXXY(Gecode::BoolOpType op0) 
         : Test("Bool::Bin::XXY::"+str(op0),2,0,1), op(op0) {}
       virtual bool solution(const Assignment& x) const {
         return check(x[0],op,x[0]) == x[1];
       }
       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]));
       }
     };
     
     class BinXYX : public Test {
     protected:
       Gecode::BoolOpType op;
     public:
       BinXYX(Gecode::BoolOpType op0) 
         : Test("Bool::Bin::XYX::"+str(op0),2,0,1), op(op0) {}
       virtual bool solution(const Assignment& x) const {
         return check(x[0],op,x[1]) == x[0];
       }
       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);
       }
     };
     
     class BinXYY : public Test {
     protected:
       Gecode::BoolOpType op;
     public:
       BinXYY(Gecode::BoolOpType op0) 
         : Test("Bool::Bin::XYY::"+str(op0),2,0,1), op(op0) {}
       virtual bool solution(const Assignment& x) const {
         return check(x[0],op,x[1]) == x[1];
       }
       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);
       }
     };
     
     class BinXXX : public Test {
     protected:
       Gecode::BoolOpType op;
     public:
       BinXXX(Gecode::BoolOpType op0) 
         : Test("Bool::Bin::XXX::"+str(op0),1,0,1), op(op0) {}
       virtual bool solution(const Assignment& x) const {
         return check(x[0],op,x[0]) == x[0];
       }
       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
         using namespace Gecode;
         BoolVar b = channel(home,x[0]);
         rel(home, b, op, b, b);
       }
     };
     
     class BinConstXY : public Test {
     protected:
       Gecode::BoolOpType op;
       int c;
     public:
       BinConstXY(Gecode::BoolOpType op0, int c0) 
         : Test("Bool::Bin::XY::"+str(op0)+"::"+str(c0),2,0,1), 
           op(op0), c(c0) {}
       virtual bool solution(const Assignment& x) const {
         return check(x[0],op,x[1]) == c;
       }
       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
         using namespace Gecode;
         rel(home, channel(home,x[0]), op, channel(home,x[1]), c);
       }
     };
     
     class BinConstXX : public Test {
     protected:
       Gecode::BoolOpType op;
       int c;
     public:
       BinConstXX(Gecode::BoolOpType op0, int c0) 
         : Test("Bool::Bin::XX::"+str(op0)+"::"+str(c0),1,0,1), 
           op(op0), c(c0) {}
       virtual bool solution(const Assignment& x) const {
         return check(x[0],op,x[0]) == c;
       }
       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
         using namespace Gecode;
         BoolVar b = channel(home,x[0]);
         rel(home, b, op, b, c);
       }
     };
     
     class Nary : public Test {
     protected:
       Gecode::BoolOpType op;
     public:
       Nary(Gecode::BoolOpType op0, int n) 
         : Test("Bool::Nary::"+str(op0)+"::"+str(n),n+1,0,1), op(op0) {}
       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];
       }
       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]));
       }
     };
     
     class NaryShared : public Test {
     protected:
       Gecode::BoolOpType op;
     public:
       NaryShared(Gecode::BoolOpType op0, int n) 
         : Test("Bool::Nary::Shared::"+str(op0)+"::"+str(n),n,0,1), 
           op(op0) {}
       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];
       }
       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]);
       }
     };
     
     class NaryConst : public Test {
     protected:
       Gecode::BoolOpType op;
       int c;
     public:
       NaryConst(Gecode::BoolOpType op0, int n, int c0) 
         : Test("Bool::Nary::"+str(op0)+"::"+str(n)+"::"+str(c0),n,0,1), 
           op(op0), c(c0) {}
       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;
       }
       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);
       }
     };
     
     class Create {
     public:
       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