Generated on Mon Nov 30 23:53:25 2009 for Gecode by doxygen 1.6.1

element.cpp

Go to the documentation of this file.
00001 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
00002 /*
00003  *  Main authors:
00004  *     Guido Tack <tack@gecode.org>
00005  *     Christian Schulte <schulte@gecode.org>
00006  *
00007  *  Copyright:
00008  *     Guido Tack, 2004
00009  *     Christian Schulte, 2004
00010  *
00011  *  Last modified:
00012  *     $Date: 2009-10-12 17:36:53 +0200 (Mon, 12 Oct 2009) $ by $Author: schulte $
00013  *     $Revision: 9878 $
00014  *
00015  *  This file is part of Gecode, the generic constraint
00016  *  development environment:
00017  *     http://www.gecode.org
00018  *
00019  *  Permission is hereby granted, free of charge, to any person obtaining
00020  *  a copy of this software and associated documentation files (the
00021  *  "Software"), to deal in the Software without restriction, including
00022  *  without limitation the rights to use, copy, modify, merge, publish,
00023  *  distribute, sublicense, and/or sell copies of the Software, and to
00024  *  permit persons to whom the Software is furnished to do so, subject to
00025  *  the following conditions:
00026  *
00027  *  The above copyright notice and this permission notice shall be
00028  *  included in all copies or substantial portions of the Software.
00029  *
00030  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00031  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00032  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00033  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
00034  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
00035  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00036  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00037  *
00038  */
00039 
00040 #include <gecode/set/element.hh>
00041 
00042 namespace Gecode {
00043 
00044   namespace Int { namespace Element {
00045     template<>
00046     class ViewToVarArg<Gecode::Set::ConstantView> {
00047     public:
00048       typedef IntSetArgs argtype;
00049     };
00050   }}
00051 
00052   using namespace Gecode::Set;
00053 
00054   void
00055   element(Home home, SetOpType op, const SetVarArgs& x, SetVar y, SetVar z,
00056     const IntSet& universe) {
00057     if (home.failed()) return;
00058     
00059     switch (op) {
00060     case SOT_DUNION:
00061       {
00062         Set::Element::ElementDisjoint<SetView,SetView>::IdxViewArray
00063           iv(home, x);
00064         GECODE_ES_FAIL(home,(Element::ElementDisjoint<SetView,SetView>::
00065                         post(home,iv,y)));
00066       }
00067       // fall through
00068     case SOT_UNION:
00069       {
00070         Set::Element::ElementUnion<SetView,SetView>::IdxViewArray iv(home, x);
00071         GECODE_ES_FAIL(home,
00072                        (Element::ElementUnion<SetView,SetView>::
00073                         post(home,z,iv,y)));
00074       }
00075       break;
00076     case SOT_INTER:
00077       {
00078         Set::Element::ElementIntersection<SetView,SetView>::IdxViewArray
00079           iv(home, x);
00080         GECODE_ES_FAIL(home,
00081                        (Element::ElementIntersection<SetView,SetView>::
00082                         post(home,z,iv,y,universe)));
00083       }
00084       break;
00085     case SOT_MINUS:
00086       throw IllegalOperation("Set::element");
00087       break;
00088     default:
00089       throw UnknownOperation("Set::element");
00090     }
00091   }
00092 
00093   void
00094   element(Home home, SetOpType op, const IntSetArgs& x, SetVar y, SetVar z,
00095     const IntSet& universe) {
00096     if (home.failed()) return;
00097 
00098     switch (op) {
00099     case SOT_DUNION:
00100       {
00101         Set::Element::ElementDisjoint<ConstantView,SetView>::IdxViewArray
00102           iv(home, x.size());
00103         for (int i=x.size(); i--;) {
00104           iv[i].idx = i; iv[i].view = ConstantView(home, x[i]);
00105         }
00106         GECODE_ES_FAIL(home,(Element::ElementDisjoint<ConstantView,SetView>::
00107                         post(home,iv,y)));
00108       }
00109       // fall through
00110     case SOT_UNION:
00111       {
00112         SharedArray<IntSet> s(x.size());
00113         for (int i=s.size(); i--;)
00114           new (&s[i]) IntSet(x[i]);
00115         GECODE_ES_FAIL(home,
00116                        (Element::ElementUnionConst<SetView,SetView>::
00117                         post(home,z,s,y)));
00118       }
00119       break;
00120     case SOT_INTER:
00121       {
00122         Set::Element::ElementIntersection<ConstantView,SetView>::IdxViewArray
00123           iv(home, x.size());
00124         for (int i=x.size(); i--;) {
00125           iv[i].idx = i; iv[i].view = ConstantView(home, x[i]);
00126         }
00127         GECODE_ES_FAIL(home,
00128                        (Element::ElementIntersection<ConstantView,SetView>::
00129                         post(home,z,iv,y,universe)));
00130       }
00131       break;
00132     case SOT_MINUS:
00133       throw IllegalOperation("Set::element");
00134       break;
00135     default:
00136       throw UnknownOperation("Set::element");
00137     }
00138     
00139   }
00140 
00141   void
00142   element(Home home, const SetVarArgs& x, IntVar y, SetVar z) {
00143     if (x.size() == 0)
00144       throw Set::TooFewArguments("Set::element");
00145     if (home.failed()) return;
00146     Set::Element::ElementUnion<SetView,SingletonView>::IdxViewArray iv(home, x);
00147     SetView zv(z);
00148 
00149     Int::IntView yv(y);
00150     SingletonView single(yv);
00151     GECODE_ES_FAIL(home,(Element::ElementUnion<SetView,
00152                          SingletonView>::post(home, z, iv, single)));
00153   }
00154 
00155   void
00156   element(Home home, const IntSetArgs& s, IntVar y, SetVar z) {
00157     if (s.size() == 0)
00158       throw Set::TooFewArguments("Set::element");
00159     for (int i=s.size(); i--;)
00160       Set::Limits::check(s[i], "Set::element");
00161     if (home.failed()) return;
00162     SetView zv(z);
00163     SharedArray<IntSet> x(s.size());
00164     for (int i=s.size(); i--;)
00165       new (&x[i]) IntSet(s[i]);
00166 
00167     Int::IntView yv(y);
00168     SingletonView single(yv);
00169     GECODE_ES_FAIL(home,(Element::ElementUnionConst<SetView,
00170                          SingletonView>::post(home, z, x, single)));
00171   }
00172 
00173 
00174   namespace {
00175     IntVar
00176     pair(Home home, IntVar x, int w, IntVar y, int h) {
00177       IntVar xy(home,0,w*h-1);
00178       if (Int::Element::Pair::post(home,x,y,xy,w,h) != ES_OK)
00179         home.fail();
00180       return xy;
00181     }
00182   }
00183 
00184   void
00185   element(Home home, const IntSetArgs& a, 
00186           IntVar x, int w, IntVar y, int h, SetVar z) {
00187     if (a.size() == 0)
00188       throw Set::TooFewArguments("Set::element");
00189     if (a.size() != w*h)
00190       throw Set::ArgumentSizeMismatch("Set::element");
00191     if (home.failed()) return;
00192     element(home, a, pair(home,x,w,y,h), z);
00193   }
00194 
00195   void
00196   element(Home home, const SetVarArgs& a, 
00197           IntVar x, int w, IntVar y, int h, SetVar z) {
00198     if (a.size() == 0)
00199       throw Set::TooFewArguments("Set::element");
00200     if (a.size() != w*h)
00201       throw Set::ArgumentSizeMismatch("Set::element");
00202     if (home.failed()) return;
00203     element(home, a, pair(home,x,w,y,h), z);
00204   }
00205 
00206 }
00207 
00208 // STATISTICS: set-post
00209