Generated on Wed Mar 19 07:30:01 2008 for Gecode by doxygen 1.5.5

minimodel.hh

Go to the documentation of this file.
00001 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
00002 /*
00003  *  Main authors:
00004  *     Christian Schulte <schulte@gecode.org>
00005  *     Guido Tack <tack@gecode.org>
00006  *     Mikael Lagerkvist <lagerkvist@gecode.org>
00007  *
00008  *  Copyright:
00009  *     Christian Schulte, 2004
00010  *     Guido Tack, 2004
00011  *     Mikael Lagerkvist, 2005
00012  *
00013  *  Last modified:
00014  *     $Date: 2008-02-29 01:09:17 +0100 (Fri, 29 Feb 2008) $ by $Author: schulte $
00015  *     $Revision: 6355 $
00016  *
00017  *  This file is part of Gecode, the generic constraint
00018  *  development environment:
00019  *     http://www.gecode.org
00020  *
00021  *  Permission is hereby granted, free of charge, to any person obtaining
00022  *  a copy of this software and associated documentation files (the
00023  *  "Software"), to deal in the Software without restriction, including
00024  *  without limitation the rights to use, copy, modify, merge, publish,
00025  *  distribute, sublicense, and/or sell copies of the Software, and to
00026  *  permit persons to whom the Software is furnished to do so, subject to
00027  *  the following conditions:
00028  *
00029  *  The above copyright notice and this permission notice shall be
00030  *  included in all copies or substantial portions of the Software.
00031  *
00032  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00033  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00034  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00035  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
00036  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
00037  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00038  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00039  *
00040  */
00041 
00042 #ifndef __GECODE_MINIMODEL_HH__
00043 #define __GECODE_MINIMODEL_HH__
00044 
00045 #include "gecode/kernel.hh"
00046 #include "gecode/int.hh"
00047 #include "gecode/int/linear.hh"
00048 
00049 #include "gecode/minimodel/exception.icc"
00050 
00051 #include <iostream>
00052 
00053 /*
00054  * Support for DLLs under Windows
00055  *
00056  */
00057 
00058 #if !defined(GECODE_STATIC_LIBS) && \
00059     (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
00060 
00061 #ifdef GECODE_BUILD_MINIMODEL
00062 #define GECODE_MINIMODEL_EXPORT __declspec( dllexport )
00063 #else
00064 #define GECODE_MINIMODEL_EXPORT __declspec( dllimport )
00065 #endif
00066 
00067 #else
00068 
00069 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
00070 
00071 #define GECODE_MINIMODEL_EXPORT __attribute__ ((visibility("default")))
00072 
00073 #else
00074 
00075 #define GECODE_MINIMODEL_EXPORT
00076 
00077 #endif
00078 #endif
00079 
00080 namespace Gecode {
00081 
00083   namespace MiniModel {
00084 
00086     template <class Var>
00087     class LinExpr {
00088     public:
00090       enum NodeType {
00091         NT_VAR, 
00092         NT_ADD, 
00093         NT_SUB, 
00094         NT_MUL  
00095       };
00096     private:
00097       typedef typename VarViewTraits<Var>::View View;
00099       class Node {
00100       public:
00102         unsigned int use;
00104         unsigned int n;
00106         NodeType t;
00108         Node *l, *r;
00110         int a, c;
00112         Var x;
00114         Node(void);
00116         int fill(Int::Linear::Term<View> t[], int i, int m, 
00117                  int c_i, int& c_o) const;
00119         bool decrement(void);
00121         static void* operator new(size_t size);
00123         static void  operator delete(void* p,size_t size);
00124       };
00125       Node* n;       
00126     public:
00128       LinExpr(void);
00130       LinExpr(const Var& x, int a=1);
00132       LinExpr(const LinExpr& e);
00134       LinExpr(const LinExpr& e0, NodeType t, const LinExpr& e1);
00136       LinExpr(const LinExpr& e0, NodeType t, int c);
00138       LinExpr(int a, const LinExpr& e);
00140       const LinExpr& operator=(const LinExpr& e);
00142       void post(Space* home, IntRelType irt, 
00143                 IntConLevel icl, PropKind pk) const;
00145       void post(Space* home, IntRelType irt, const BoolVar& b,
00146                 IntConLevel icl, PropKind pk) const;
00148       IntVar post(Space* home, 
00149                   IntConLevel icl, PropKind pk) const;
00151       ~LinExpr(void);
00152     };
00153 
00155     template<class Var>
00156     class LinRel {
00157     private:
00159       LinExpr<Var> e;
00161       IntRelType   irt;
00163       static IntRelType neg(IntRelType irt);
00164     public:
00166       LinRel(void);
00168       LinRel(const LinExpr<Var>& l, IntRelType irt, const LinExpr<Var>& r);
00170       LinRel(const LinExpr<Var>& l, IntRelType irt, int r);
00172       LinRel(int l, IntRelType irt, const LinExpr<Var>& r);
00174       void post(Space* home, bool t, 
00175                 IntConLevel icl, PropKind pk) const;
00177       void post(Space* home, const BoolVar& b,
00178                 IntConLevel icl, PropKind pk) const;
00179     };
00180 
00181   }
00182 
00183 }
00184 
00202 
00204 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00205 operator+(int,
00206           const Gecode::MiniModel::LinExpr<Gecode::IntVar>&);
00208 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00209 operator+(const Gecode::MiniModel::LinExpr<Gecode::IntVar>&,
00210           int);
00212 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00213 operator+(const Gecode::MiniModel::LinExpr<Gecode::IntVar>&,
00214           const Gecode::MiniModel::LinExpr<Gecode::IntVar>&);
00216 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00217 operator-(int,
00218           const Gecode::MiniModel::LinExpr<Gecode::IntVar>&);
00220 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00221 operator-(const Gecode::MiniModel::LinExpr<Gecode::IntVar>&,
00222           int);
00224 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00225 operator-(const Gecode::MiniModel::LinExpr<Gecode::IntVar>&,
00226           const Gecode::MiniModel::LinExpr<Gecode::IntVar>&);
00228 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00229 operator-(const Gecode::MiniModel::LinExpr<Gecode::IntVar>&);
00230 
00232 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00233 operator*(int, const Gecode::IntVar&);
00235 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00236 operator*(const Gecode::IntVar&, int);
00238 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00239 operator*(const Gecode::MiniModel::LinExpr<Gecode::IntVar>&, int);
00241 Gecode::MiniModel::LinExpr<Gecode::IntVar>
00242 operator*(int, const Gecode::MiniModel::LinExpr<Gecode::IntVar>&);
00243 
00244 
00246 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00247 operator+(int,
00248           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&);
00250 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00251 operator+(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&,
00252           int);
00254 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00255 operator+(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&,
00256           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&);
00258 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00259 operator-(int,
00260           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&);
00262 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00263 operator-(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&,
00264           int);
00266 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00267 operator-(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&,
00268           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&);
00270 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00271 operator-(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&);
00272 
00274 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00275 operator*(int, const Gecode::BoolVar&);
00277 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00278 operator*(const Gecode::BoolVar&, int);
00280 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00281 operator*(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&, int);
00283 Gecode::MiniModel::LinExpr<Gecode::BoolVar>
00284 operator*(int, const Gecode::MiniModel::LinExpr<Gecode::BoolVar>&);
00285 
00286 
00288 Gecode::MiniModel::LinRel<Gecode::IntVar>
00289 operator==(int l,
00290            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00292 Gecode::MiniModel::LinRel<Gecode::IntVar>
00293 operator==(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00294            int r);
00296 Gecode::MiniModel::LinRel<Gecode::IntVar>
00297 operator==(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00298            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00299 
00301 Gecode::MiniModel::LinRel<Gecode::IntVar>
00302 operator!=(int l,
00303            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00305 Gecode::MiniModel::LinRel<Gecode::IntVar>
00306 operator!=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00307            int r);
00309 Gecode::MiniModel::LinRel<Gecode::IntVar>
00310 operator!=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00311            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00312 
00314 Gecode::MiniModel::LinRel<Gecode::IntVar>
00315 operator<(int l,
00316           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00318 Gecode::MiniModel::LinRel<Gecode::IntVar>
00319 operator<(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00320           int r);
00322 Gecode::MiniModel::LinRel<Gecode::IntVar>
00323 operator<(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00324           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00325 
00327 Gecode::MiniModel::LinRel<Gecode::IntVar>
00328 operator<=(int l,
00329            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00331 Gecode::MiniModel::LinRel<Gecode::IntVar>
00332 operator<=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00333            int r);
00335 Gecode::MiniModel::LinRel<Gecode::IntVar>
00336 operator<=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00337            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00338 
00340 Gecode::MiniModel::LinRel<Gecode::IntVar>
00341 operator>(int l,
00342           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00344 Gecode::MiniModel::LinRel<Gecode::IntVar>
00345 operator>(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00346           int r);
00348 Gecode::MiniModel::LinRel<Gecode::IntVar>
00349 operator>(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00350           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00351 
00353 Gecode::MiniModel::LinRel<Gecode::IntVar>
00354 operator>=(int l,
00355            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00357 Gecode::MiniModel::LinRel<Gecode::IntVar>
00358 operator>=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00359            int r);
00361 Gecode::MiniModel::LinRel<Gecode::IntVar>
00362 operator>=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
00363            const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r);
00364 
00365 
00367 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00368 operator==(int l,
00369            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00371 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00372 operator==(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00373            int r);
00375 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00376 operator==(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00377            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00378 
00380 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00381 operator!=(int l,
00382            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00384 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00385 operator!=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00386            int r);
00388 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00389 operator!=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00390            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00391 
00393 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00394 operator<(int l,
00395           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00397 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00398 operator<(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00399           int r);
00401 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00402 operator<(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00403           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00404 
00406 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00407 operator<=(int l,
00408            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00410 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00411 operator<=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00412            int r);
00414 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00415 operator<=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00416            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00417 
00419 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00420 operator>(int l,
00421           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00423 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00424 operator>(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00425           int r);
00427 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00428 operator>(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00429           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00430 
00432 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00433 operator>=(int l,
00434            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00436 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00437 operator>=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00438            int r);
00440 Gecode::MiniModel::LinRel<Gecode::BoolVar>
00441 operator>=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
00442            const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r);
00443 
00445 
00446 namespace Gecode {
00447 
00448   namespace MiniModel {
00449 
00451     class BoolExpr {
00452     public:
00454       enum NodeType {
00455         NT_VAR,       
00456         NT_NOT,       
00457         NT_AND,       
00458         NT_OR,        
00459         NT_IMP,       
00460         NT_XOR,       
00461         NT_EQV,       
00462         NT_RLIN_INT,  
00463         NT_RLIN_BOOL  
00464       };
00466       class Node {
00467       public:
00469         unsigned int use;
00471         unsigned int same;
00473         NodeType t;
00475         Node *l, *r;
00477         BoolVar x;
00479         LinRel<IntVar> rl_int;
00481         LinRel<BoolVar> rl_bool;
00482 
00484         Node(void);
00486         GECODE_MINIMODEL_EXPORT 
00487         bool decrement(void);
00489         GECODE_MINIMODEL_EXPORT         
00490         int post(Space* home, NodeType t, BoolVarArgs& b, int i,
00491                  IntConLevel icl, PropKind pk) const;
00493         GECODE_MINIMODEL_EXPORT
00494         void post(Space* home, BoolVar b,
00495                   IntConLevel icl, PropKind pk) const;
00497         GECODE_MINIMODEL_EXPORT
00498         BoolVar post(Space* home,
00499                      IntConLevel icl, PropKind pk) const;
00501         GECODE_MINIMODEL_EXPORT
00502         void post(Space* home, bool t,
00503                   IntConLevel icl, PropKind pk) const;
00504         
00506         static void* operator new(size_t size);
00508         static void  operator delete(void* p,size_t size);
00509       };
00510     private:
00512       Node* n;
00513     public:
00515       BoolExpr(const BoolExpr& e);
00517       GECODE_MINIMODEL_EXPORT 
00518       BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r);
00520       GECODE_MINIMODEL_EXPORT 
00521       BoolExpr(const BoolVar& x);
00523       GECODE_MINIMODEL_EXPORT 
00524       BoolExpr(const BoolExpr& e, NodeType t);
00526       GECODE_MINIMODEL_EXPORT 
00527       BoolExpr(const LinRel<IntVar>& rl);
00529       GECODE_MINIMODEL_EXPORT 
00530       BoolExpr(const LinRel<BoolVar>& rl);
00532       BoolVar post(Space* home, IntConLevel icl, PropKind pk) const;
00534       void post(Space* home, bool t, IntConLevel icl, PropKind pk) const;
00535 
00537       GECODE_MINIMODEL_EXPORT 
00538       const BoolExpr& operator=(const BoolExpr& e);
00540       GECODE_MINIMODEL_EXPORT 
00541       ~BoolExpr(void);
00542     };
00543 
00545     class BoolRel {
00546     private:
00548       BoolExpr e;
00550       bool t;
00551     public:
00553       BoolRel(const BoolExpr& e, bool t);
00555       void post(Space* home, IntConLevel icl, PropKind pk) const;
00556     };
00557   }
00558 
00559 }
00560 
00575 
00577 Gecode::MiniModel::BoolExpr
00578 operator!(const Gecode::MiniModel::BoolExpr&);
00579 
00581 Gecode::MiniModel::BoolExpr
00582 operator&&(const Gecode::MiniModel::BoolExpr&,
00583            const Gecode::MiniModel::BoolExpr&);
00584 
00586 Gecode::MiniModel::BoolExpr
00587 operator||(const Gecode::MiniModel::BoolExpr&,
00588            const Gecode::MiniModel::BoolExpr&);
00589 
00591 Gecode::MiniModel::BoolExpr
00592 operator^(const Gecode::MiniModel::BoolExpr&,
00593           const Gecode::MiniModel::BoolExpr&);
00594 
00596 template <class Var>
00597 Gecode::MiniModel::BoolExpr
00598 operator~(const Gecode::MiniModel::LinRel<Var>&);
00599 
00600 namespace Gecode {
00601 
00603   MiniModel::BoolExpr
00604   eqv(const MiniModel::BoolExpr&,
00605       const MiniModel::BoolExpr&);
00607   MiniModel::BoolExpr
00608   imp(const MiniModel::BoolExpr&,
00609       const MiniModel::BoolExpr&);
00610 
00612   MiniModel::BoolRel
00613   tt(const MiniModel::BoolExpr&);
00614 
00616   MiniModel::BoolRel
00617   ff(const MiniModel::BoolExpr&);
00618 
00619 }
00620 
00622 
00623 namespace Gecode {
00624 
00631 
00632   template <class Var>
00633   IntVar post(Space* home, const MiniModel::LinExpr<Var>& e,
00634               IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00636   IntVar post(Space* home, const IntVar& x,
00637               IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00639   IntVar post(Space* home, int n,
00640               IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00641 
00643   template <class Var>
00644   void post(Space* home, const MiniModel::LinRel<Var>& r,
00645             IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00647   void post(Space* home, bool r,
00648             IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00649 
00651   BoolVar post(Space* home, const MiniModel::BoolExpr& e,
00652                IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00654   BoolVar post(Space* home, const BoolVar& b,
00655                IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00657   void post(Space* home, const MiniModel::BoolRel& r,
00658             IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00660 
00661 }
00662 
00663 #include "gecode/minimodel/lin-expr.icc"
00664 #include "gecode/minimodel/lin-rel.icc"
00665 #include "gecode/minimodel/bool-expr.icc"
00666 #include "gecode/minimodel/bool-rel.icc"
00667 
00668 namespace Gecode {
00669 
00675   class GECODE_MINIMODEL_EXPORT REG {
00676   private:
00678     class Exp;
00680     Exp* e;
00682     REG(Exp* e);
00683   public:
00685     REG(void);
00687     REG(int s);
00694     REG(const IntArgs& x);
00695 
00697     REG(const REG& r);
00699     const REG& operator=(const REG& r);
00700 
00702     REG operator+(const REG& r);
00704     REG& operator+=(const REG& r);
00706     REG operator|(const REG& r);
00708     REG& operator|=(const REG& r);
00710     REG operator*(void);
00712     REG operator+(void);
00714     REG operator()(unsigned int n, unsigned int m);
00716     REG operator()(unsigned int n);
00718     std::ostream& print(std::ostream&) const;
00720     operator DFA(void);
00722     ~REG(void);
00723   };
00724 
00725 }
00726 
00730 GECODE_MINIMODEL_EXPORT std::ostream&
00731 operator<<(std::ostream&, const Gecode::REG& r);
00732 
00733 
00734 namespace Gecode {
00735 
00742 
00743   GECODE_MINIMODEL_EXPORT IntVar
00744   abs(Space* home, IntVar x, 
00745       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00747   GECODE_MINIMODEL_EXPORT IntVar
00748   min(Space* home, IntVar x, IntVar y, 
00749       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00751   GECODE_MINIMODEL_EXPORT IntVar
00752   min(Space* home, const IntVarArgs& x, 
00753       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00755   GECODE_MINIMODEL_EXPORT IntVar
00756   max(Space* home, IntVar x, IntVar y, 
00757       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00759   GECODE_MINIMODEL_EXPORT IntVar
00760   max(Space* home, const IntVarArgs& x, 
00761       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00763   GECODE_MINIMODEL_EXPORT IntVar
00764   mult(Space* home, IntVar x, IntVar y, 
00765        IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00767   GECODE_MINIMODEL_EXPORT IntVar
00768   sqr(Space* home, IntVar x, 
00769       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00771   GECODE_MINIMODEL_EXPORT IntVar
00772   sqrt(Space* home, IntVar x, 
00773        IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00775   GECODE_MINIMODEL_EXPORT IntVar
00776   plus(Space* home, IntVar x, IntVar y, 
00777        IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00779   GECODE_MINIMODEL_EXPORT IntVar
00780   minus(Space* home, IntVar x, IntVar y, 
00781         IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF);
00783 
00784 }
00785 
00786 namespace Gecode {
00787 
00794 
00795   inline BoolVar
00796   channel(Space* home, IntVar x, 
00797           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00798     (void) icl; (void) pk;
00799     BoolVar b(home,0,1); channel(home,b,x);
00800     return b;
00801   }
00803   inline IntVar
00804   channel(Space* home, BoolVar b, 
00805           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00806     (void) icl; (void) pk;
00807     IntVar x(home,0,1); channel(home,b,x);
00808     return x;
00809   }
00811 
00812 }
00813 
00814 namespace Gecode {
00815 
00830   inline void
00831   atmost(Space* home, const IntVarArgs& x, int n, int m,
00832          IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00833     count(home,x,n,IRT_LQ,m,icl,pk);
00834   }
00839   inline void
00840   atmost(Space* home, const IntVarArgs& x, IntVar y, int m,
00841          IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00842     count(home,x,y,IRT_LQ,m,icl,pk);
00843   }
00851   inline void
00852   atmost(Space* home, const IntVarArgs& x, const IntArgs& y, int m,
00853          IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00854     count(home,x,y,IRT_LQ,m,icl,pk);
00855   }
00860   inline void
00861   atmost(Space* home, const IntVarArgs& x, int n, IntVar z,
00862          IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00863     count(home,x,n,IRT_LQ,z,icl,pk);
00864   }
00869   inline void
00870   atmost(Space* home, const IntVarArgs& x, IntVar y, IntVar z,
00871          IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00872     count(home,x,y,IRT_LQ,z,icl,pk);
00873   }
00881   inline void
00882   atmost(Space* home, const IntVarArgs& x, const IntArgs& y, IntVar z,
00883          IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00884     count(home,x,y,IRT_LQ,z,icl,pk);
00885   }
00886 
00891   inline void
00892   atleast(Space* home, const IntVarArgs& x, int n, int m,
00893           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00894     count(home,x,n,IRT_GQ,m,icl,pk);
00895   }
00900   inline void
00901   atleast(Space* home, const IntVarArgs& x, IntVar y, int m,
00902           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00903     count(home,x,y,IRT_GQ,m,icl,pk);
00904   }
00912   inline void
00913   atleast(Space* home, const IntVarArgs& x, const IntArgs& y, int m,
00914           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00915     count(home,x,y,IRT_GQ,m,icl,pk);
00916   }
00921   inline void
00922   atleast(Space* home, const IntVarArgs& x, int n, IntVar z,
00923           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00924     count(home,x,n,IRT_GQ,z,icl,pk);
00925   }
00930   inline void
00931   atleast(Space* home, const IntVarArgs& x, IntVar y, IntVar z,
00932           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00933     count(home,x,y,IRT_GQ,z,icl,pk);
00934   }
00942   inline void
00943   atleast(Space* home, const IntVarArgs& x, const IntArgs& y, IntVar z,
00944           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00945     count(home,x,y,IRT_GQ,z,icl,pk);
00946   }
00947 
00952   inline void
00953   exactly(Space* home, const IntVarArgs& x, int n, int m,
00954           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00955     count(home,x,n,IRT_EQ,m,icl,pk);
00956   }
00961   inline void
00962   exactly(Space* home, const IntVarArgs& x, IntVar y, int m,
00963           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00964     count(home,x,y,IRT_EQ,m,icl,pk);
00965   }
00973   inline void
00974   exactly(Space* home, const IntVarArgs& x, const IntArgs& y, int m,
00975           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00976     count(home,x,y,IRT_EQ,m,icl,pk);
00977   }
00982   inline void
00983   exactly(Space* home, const IntVarArgs& x, int n, IntVar z,
00984           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00985     count(home,x,n,IRT_EQ,z,icl,pk);
00986   }
00991   inline void
00992   exactly(Space* home, const IntVarArgs& x, IntVar y, IntVar z,
00993           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
00994     count(home,x,y,IRT_EQ,z,icl,pk);
00995   }
01003   inline void
01004   exactly(Space* home, const IntVarArgs& x, const IntArgs& y, IntVar z,
01005           IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
01006     count(home,x,y,IRT_EQ,z,icl,pk);
01007   }
01013   inline void
01014   lex(Space* home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
01015       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
01016     rel(home,x,r,y,icl,pk);
01017   }
01023   inline void
01024   lex(Space* home, const BoolVarArgs& x, IntRelType r, const BoolVarArgs& y,
01025       IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) {
01026     rel(home,x,r,y,icl,pk);
01027   }
01028 
01030 
01031 }
01032 
01041 namespace Gecode { namespace MiniModel {
01042 
01053   template <class A>
01054   class Matrix {
01055   public:
01057     typedef typename ArrayTraits<A>::value_type value_type;
01059     typedef typename ArrayTraits<A>::args_type  args_type;
01060 
01068     class Slice {
01069       args_type _r;     
01070       unsigned int _fc, 
01071         _tc,            
01072         _fr,            
01073         _tr;            
01074     public:
01075       Slice(Matrix<A>& a,
01076             unsigned int fc, unsigned int tc,
01077             unsigned int fr, unsigned int tr);
01078 
01082       Slice& reverse(void);
01083 
01084       operator args_type(void);
01085       operator Matrix<args_type>(void);
01086     };
01087 
01088   private:
01090     typedef typename ArrayTraits<A>::storage_type storage_type;
01091     storage_type _a; 
01092     unsigned int _w, 
01093       _h;            
01094 
01095   public:
01108     Matrix(A a, unsigned int w, unsigned int h);
01109 
01122     Matrix(A a, unsigned int n);
01123 
01125     unsigned int width(void) const;
01127     unsigned int height(void) const;
01129     args_type const get_array(void);
01130 
01136     value_type& operator()(unsigned int c, unsigned int r);
01137 
01147     Slice slice(unsigned int fc, unsigned int tc,
01148                 unsigned int fr, unsigned int tr);
01149 
01151     Slice row(int r);
01152 
01154     Slice col(int c);
01155   };
01156 }}
01157 
01158 #include "gecode/minimodel/matrix.icc"
01160 
01161 #endif
01162 
01163 // IFDEF: GECODE_HAS_INT_VARS
01164 // STATISTICS: minimodel-any
01165