Generated on Mon May 10 06:46:43 2010 for Gecode by doxygen 1.6.3

lin-expr.cpp

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  *
00006  *  Copyright:
00007  *     Christian Schulte, 2010
00008  *
00009  *  Last modified:
00010  *     $Date: 2010-02-03 11:13:34 +0100 (Wed, 03 Feb 2010) $ by $Author: schulte $
00011  *     $Revision: 10262 $
00012  *
00013  *  This file is part of Gecode, the generic constraint
00014  *  development environment:
00015  *     http://www.gecode.org
00016  *
00017  *  Permission is hereby granted, free of charge, to any person obtaining
00018  *  a copy of this software and associated documentation files (the
00019  *  "Software"), to deal in the Software without restriction, including
00020  *  without limitation the rights to use, copy, modify, merge, publish,
00021  *  distribute, sublicense, and/or sell copies of the Software, and to
00022  *  permit persons to whom the Software is furnished to do so, subject to
00023  *  the following conditions:
00024  *
00025  *  The above copyright notice and this permission notice shall be
00026  *  included in all copies or substantial portions of the Software.
00027  *
00028  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00029  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00030  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00031  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
00032  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
00033  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00034  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00035  *
00036  */
00037 
00038 #include <gecode/minimodel.hh>
00039 
00040 namespace Gecode {
00041 
00042   bool
00043   LinExpr::Node::decrement(void) {
00044     if (--use == 0) {
00045       if ((l != NULL) && l->decrement())
00046         delete l;
00047       if ((r != NULL) && r->decrement())
00048         delete r;
00049       return true;
00050     }
00051     return false;
00052   }
00053 
00054   /*
00055    * Operations for expressions
00056    *
00057    */
00058 
00059   const LinExpr&
00060   LinExpr::operator =(const LinExpr& e) {
00061     if (this != &e) {
00062       if (n->decrement())
00063         delete n;
00064       n = e.n; n->use++;
00065     }
00066     return *this;
00067   }
00068 
00069   LinExpr::~LinExpr(void) {
00070     if (n->decrement())
00071       delete n;
00072   }
00073 
00074 
00075   void
00076   LinExpr::Node::fill(Int::Linear::Term<Int::IntView>*& ti, 
00077                       Int::Linear::Term<Int::BoolView>*& tb,
00078                       double m, double& d) const {
00079     switch (this->t) {
00080     case NT_VAR_INT:
00081       if (a != 0) {
00082         Int::Limits::check(m*a,"MiniModel::LinExpr");
00083         ti->a=m*a; ti->x=x_int; ti++;
00084       }
00085       break;
00086     case NT_VAR_BOOL:
00087       if (a != 0) {
00088         Int::Limits::check(m*a,"MiniModel::LinExpr");
00089         tb->a=m*a; tb->x=x_bool; tb++;
00090       }
00091       break;
00092     case NT_SUM_INT:
00093       for (int i=n_int; i--; ) {
00094         Int::Limits::check(m*sum.ti[i].a,"MiniModel::LinExpr");
00095         ti[i].x = sum.ti[i].x; ti[i].a = m*sum.ti[i].a;
00096       }
00097       ti += n_int;
00098       break;
00099     case NT_SUM_BOOL:
00100       for (int i=n_bool; i--; ) {
00101         Int::Limits::check(m*sum.tb[i].a,"MiniModel::LinExpr");
00102         tb[i].x = sum.tb[i].x; tb[i].a = m*sum.tb[i].a;
00103       }
00104       tb += n_bool;
00105       break;
00106     case NT_ADD:
00107       if (l == NULL) {
00108         Int::Limits::check(m*c,"MiniModel::LinExpr");
00109         d += m*c;
00110       } else {
00111         l->fill(ti,tb,m,d);
00112       }
00113       r->fill(ti,tb,m,d);
00114       break;
00115     case NT_SUB:
00116       if (l == NULL) {
00117         Int::Limits::check(m*c,"MiniModel::LinExpr");
00118         d += m*c;
00119       } else {
00120         l->fill(ti,tb,m,d);
00121       }
00122       r->fill(ti,tb,-m,d);
00123       break;
00124     case NT_MUL:
00125       Int::Limits::check(m*a,"MiniModel::LinExpr");
00126       l->fill(ti,tb,m*a,d);
00127       break;
00128     default:
00129       GECODE_NEVER;
00130     }
00131   }
00132 
00133 
00134   /*
00135    * Operators
00136    *
00137    */
00138   LinExpr
00139   operator +(int c, const IntVar& x) {
00140     return LinExpr(x,LinExpr::NT_ADD,c);
00141   }
00142   LinExpr
00143   operator +(int c, const BoolVar& x) {
00144     return LinExpr(x,LinExpr::NT_ADD,c);
00145   }
00146   LinExpr
00147   operator +(int c, const LinExpr& e) {
00148     return LinExpr(e,LinExpr::NT_ADD,c);
00149   }
00150   LinExpr
00151   operator +(const IntVar& x, int c) {
00152     return LinExpr(x,LinExpr::NT_ADD,c);
00153   }
00154   LinExpr
00155   operator +(const BoolVar& x, int c) {
00156     return LinExpr(x,LinExpr::NT_ADD,c);
00157   }
00158   LinExpr
00159   operator +(const LinExpr& e, int c) {
00160     return LinExpr(e,LinExpr::NT_ADD,c);
00161   }
00162   LinExpr
00163   operator +(const IntVar& x, const IntVar& y) {
00164     return LinExpr(x,LinExpr::NT_ADD,y);
00165   }
00166   LinExpr
00167   operator +(const IntVar& x, const BoolVar& y) {
00168     return LinExpr(x,LinExpr::NT_ADD,y);
00169   }
00170   LinExpr
00171   operator +(const BoolVar& x, const IntVar& y) {
00172     return LinExpr(x,LinExpr::NT_ADD,y);
00173   }
00174   LinExpr
00175   operator +(const BoolVar& x, const BoolVar& y) {
00176     return LinExpr(x,LinExpr::NT_ADD,y);
00177   }
00178   LinExpr
00179   operator +(const IntVar& x, const LinExpr& e) {
00180     return LinExpr(x,LinExpr::NT_ADD,e);
00181   }
00182   LinExpr
00183   operator +(const BoolVar& x, const LinExpr& e) {
00184     return LinExpr(x,LinExpr::NT_ADD,e);
00185   }
00186   LinExpr
00187   operator +(const LinExpr& e, const IntVar& x) {
00188     return LinExpr(e,LinExpr::NT_ADD,x);
00189   }
00190   LinExpr
00191   operator +(const LinExpr& e, const BoolVar& x) {
00192     return LinExpr(e,LinExpr::NT_ADD,x);
00193   }
00194   LinExpr
00195   operator +(const LinExpr& e1, const LinExpr& e2) {
00196     return LinExpr(e1,LinExpr::NT_ADD,e2);
00197   }
00198 
00199   LinExpr
00200   operator -(int c, const IntVar& x) {
00201     return LinExpr(x,LinExpr::NT_SUB,c);
00202   }
00203   LinExpr
00204   operator -(int c, const BoolVar& x) {
00205     return LinExpr(x,LinExpr::NT_SUB,c);
00206   }
00207   LinExpr
00208   operator -(int c, const LinExpr& e) {
00209     return LinExpr(e,LinExpr::NT_SUB,c);
00210   }
00211   LinExpr
00212   operator -(const IntVar& x, int c) {
00213     return LinExpr(x,LinExpr::NT_ADD,-c);
00214   }
00215   LinExpr
00216   operator -(const BoolVar& x, int c) {
00217     return LinExpr(x,LinExpr::NT_ADD,-c);
00218   }
00219   LinExpr
00220   operator -(const LinExpr& e, int c) {
00221     return LinExpr(e,LinExpr::NT_ADD,-c);
00222   }
00223   LinExpr
00224   operator -(const IntVar& x, const IntVar& y) {
00225     return LinExpr(x,LinExpr::NT_SUB,y);
00226   }
00227   LinExpr
00228   operator -(const IntVar& x, const BoolVar& y) {
00229     return LinExpr(x,LinExpr::NT_SUB,y);
00230   }
00231   LinExpr
00232   operator -(const BoolVar& x, const IntVar& y) {
00233     return LinExpr(x,LinExpr::NT_SUB,y);
00234   }
00235   LinExpr
00236   operator -(const BoolVar& x, const BoolVar& y) {
00237     return LinExpr(x,LinExpr::NT_SUB,y);
00238   }
00239   LinExpr
00240   operator -(const IntVar& x, const LinExpr& e) {
00241     return LinExpr(x,LinExpr::NT_SUB,e);
00242   }
00243   LinExpr
00244   operator -(const BoolVar& x, const LinExpr& e) {
00245     return LinExpr(x,LinExpr::NT_SUB,e);
00246   }
00247   LinExpr
00248   operator -(const LinExpr& e, const IntVar& x) {
00249     return LinExpr(e,LinExpr::NT_SUB,x);
00250   }
00251   LinExpr
00252   operator -(const LinExpr& e, const BoolVar& x) {
00253     return LinExpr(e,LinExpr::NT_SUB,x);
00254   }
00255   LinExpr
00256   operator -(const LinExpr& e1, const LinExpr& e2) {
00257     return LinExpr(e1,LinExpr::NT_SUB,e2);
00258   }
00259 
00260   LinExpr
00261   operator -(const IntVar& x) {
00262     return LinExpr(x,LinExpr::NT_SUB,0);
00263   }
00264   LinExpr
00265   operator -(const BoolVar& x) {
00266     return LinExpr(x,LinExpr::NT_SUB,0);
00267   }
00268   LinExpr
00269   operator -(const LinExpr& e) {
00270     return LinExpr(e,LinExpr::NT_SUB,0);
00271   }
00272 
00273   LinExpr
00274   operator *(int a, const IntVar& x) {
00275     return LinExpr(x,a);
00276   }
00277   LinExpr
00278   operator *(int a, const BoolVar& x) {
00279     return LinExpr(x,a);
00280   }
00281   LinExpr
00282   operator *(const IntVar& x, int a) {
00283     return LinExpr(x,a);
00284   }
00285   LinExpr
00286   operator *(const BoolVar& x, int a) {
00287     return LinExpr(x,a);
00288   }
00289   LinExpr
00290   operator *(const LinExpr& e, int a) {
00291     return LinExpr(a,e);
00292   }
00293   LinExpr
00294   operator *(int a, const LinExpr& e) {
00295     return LinExpr(a,e);
00296   }
00297 
00298   LinExpr
00299   sum(const IntVarArgs& x) {
00300     return LinExpr(x);
00301   }
00302   LinExpr
00303   sum(const IntArgs& a, const IntVarArgs& x) {
00304     return LinExpr(a,x);
00305   }
00306   LinExpr
00307   sum(const BoolVarArgs& x) {
00308     return LinExpr(x);
00309   }
00310   LinExpr
00311   sum(const IntArgs& a, const BoolVarArgs& x) {
00312     return LinExpr(a,x);
00313   }
00314 
00315 
00316   IntVar
00317   post(Home home, const LinExpr& e, IntConLevel icl) {
00318     if (!home.failed())
00319       return e.post(home,icl);
00320     IntVar x(home,Int::Limits::min,Int::Limits::max);
00321     return x;
00322   }
00323 
00324 }
00325 
00326 // STATISTICS: minimodel-any