Generated on Wed Mar 19 07:29:54 2008 for Gecode by doxygen 1.5.5

branch.cc

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, 2002
00008  *
00009  *  Last modified:
00010  *     $Date: 2008-02-28 14:12:40 +0100 (Thu, 28 Feb 2008) $ by $Author: tack $
00011  *     $Revision: 6344 $
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/int/branch.hh"
00039 
00040 namespace Gecode {
00041 
00042   using namespace Int;
00043 
00044   void
00045   branch(Space* home, const IntVarArgs& x,
00046          IntVarBranch vars, IntValBranch vals) {
00047     ViewArray<IntView> xv(home,x);
00048     switch (vars) {
00049     case INT_VAR_NONE:
00050       if (home->failed()) return;
00051       Branch::create<IntView,Branch::ByNone>(home,xv,vals); break;
00052     case INT_VAR_MIN_MIN:
00053       if (home->failed()) return;
00054       Branch::create<IntView,Branch::ByMinMin>(home,xv,vals); break;
00055     case INT_VAR_MIN_MAX:
00056       if (home->failed()) return;
00057       Branch::create<IntView,Branch::ByMinMax>(home,xv,vals); break;
00058     case INT_VAR_MAX_MIN:
00059       if (home->failed()) return;
00060       Branch::create<IntView,Branch::ByMaxMin>(home,xv,vals); break;
00061     case INT_VAR_MAX_MAX:
00062       if (home->failed()) return;
00063       Branch::create<IntView,Branch::ByMaxMax>(home,xv,vals); break;
00064     case INT_VAR_SIZE_MIN:
00065       if (home->failed()) return;
00066       Branch::create<IntView,Branch::BySizeMin>(home,xv,vals); break;
00067     case INT_VAR_SIZE_MAX:
00068       if (home->failed()) return;
00069       Branch::create<IntView,Branch::BySizeMax>(home,xv,vals); break;
00070     case INT_VAR_DEGREE_MIN:
00071       if (home->failed()) return;
00072       Branch::create<IntView,Branch::ByDegreeMin>(home,xv,vals); break;
00073     case INT_VAR_DEGREE_MAX:
00074       if (home->failed()) return;
00075       Branch::create<IntView,Branch::ByDegreeMax>(home,xv,vals); break;
00076     case INT_VAR_SIZE_DEGREE_MIN:
00077       if (home->failed()) return;
00078       Branch::create<IntView,Branch::BySizeDegreeMin>(home,xv,vals); break;
00079     case INT_VAR_SIZE_DEGREE_MAX:
00080       if (home->failed()) return;
00081       Branch::create<IntView,Branch::BySizeDegreeMax>(home,xv,vals); break;
00082     case INT_VAR_REGRET_MIN_MIN:
00083       if (home->failed()) return;
00084       Branch::create<IntView,Branch::ByRegretMinMin>(home,xv,vals); break;
00085     case INT_VAR_REGRET_MIN_MAX:
00086       if (home->failed()) return;
00087       Branch::create<IntView,Branch::ByRegretMinMax>(home,xv,vals); break;
00088     case INT_VAR_REGRET_MAX_MIN:
00089       if (home->failed()) return;
00090       Branch::create<IntView,Branch::ByRegretMaxMin>(home,xv,vals); break;
00091     case INT_VAR_REGRET_MAX_MAX:
00092       if (home->failed()) return;
00093       Branch::create<IntView,Branch::ByRegretMaxMax>(home,xv,vals); break;
00094     default:
00095       throw UnknownBranching("Int::branch");
00096     }
00097   }
00098 
00099   void
00100   branch(Space* home, const BoolVarArgs& x, 
00101          IntVarBranch vars, IntValBranch vals) {
00102     ViewArray<BoolView> xv(home,x);
00103     switch (vars) {
00104     case INT_VAR_NONE:
00105     case INT_VAR_MIN_MIN:
00106     case INT_VAR_MIN_MAX:
00107     case INT_VAR_MAX_MIN:
00108     case INT_VAR_MAX_MAX:
00109     case INT_VAR_SIZE_MIN:
00110     case INT_VAR_SIZE_MAX:
00111     case INT_VAR_REGRET_MIN_MIN:
00112     case INT_VAR_REGRET_MIN_MAX:
00113     case INT_VAR_REGRET_MAX_MIN:
00114     case INT_VAR_REGRET_MAX_MAX:
00115       switch (vals) {
00116       case INT_VAL_MIN:
00117       case INT_VAL_MED:
00118       case INT_VAL_SPLIT_MIN:
00119         if (home->failed()) return;
00120         (void) new (home) 
00121           ViewValBranching<BoolView,Branch::NoValue,
00122                            Branch::ByNone<BoolView>,
00123                            Branch::ValZeroOne<BoolView> >(home,xv);
00124         break;
00125       case INT_VAL_MAX:
00126       case INT_VAL_SPLIT_MAX:
00127         if (home->failed()) return;
00128         (void) new (home) 
00129           ViewValBranching<BoolView,Branch::NoValue,
00130                            Branch::ByNone<BoolView>,
00131                            Branch::ValOneZero<BoolView> >(home,xv);
00132         break;
00133       default:
00134         throw UnknownBranching("Int::branch");
00135       }
00136       break;
00137     case INT_VAR_DEGREE_MIN:
00138     case INT_VAR_SIZE_DEGREE_MAX:
00139       switch (vals) {
00140       case INT_VAL_MIN:
00141       case INT_VAL_MED:
00142       case INT_VAL_SPLIT_MIN:
00143         if (home->failed()) return;
00144         (void) new (home) 
00145           ViewValBranching<BoolView,Branch::NoValue,
00146                            Branch::ByDegreeMinNoTies<BoolView>,
00147                            Branch::ValZeroOne<BoolView> >(home,xv);
00148         break;
00149       case INT_VAL_MAX:
00150       case INT_VAL_SPLIT_MAX:
00151         if (home->failed()) return;
00152         (void) new (home) 
00153           ViewValBranching<BoolView,Branch::NoValue,
00154                            Branch::ByDegreeMinNoTies<BoolView>,
00155                            Branch::ValOneZero<BoolView> >(home,xv);
00156         break;
00157       default:
00158         throw UnknownBranching("Int::branch");
00159       }
00160       break;
00161     case INT_VAR_DEGREE_MAX:
00162     case INT_VAR_SIZE_DEGREE_MIN:
00163       switch (vals) {
00164       case INT_VAL_MIN:
00165       case INT_VAL_MED:
00166       case INT_VAL_SPLIT_MIN:
00167         if (home->failed()) return;
00168         (void) new (home) 
00169           ViewValBranching<BoolView,Branch::NoValue,
00170                            Branch::ByDegreeMaxNoTies<BoolView>,
00171                            Branch::ValZeroOne<BoolView> >(home,xv);
00172         break;
00173       case INT_VAL_MAX:
00174       case INT_VAL_SPLIT_MAX:
00175         if (home->failed()) return;
00176         (void) new (home) 
00177           ViewValBranching<BoolView,Branch::NoValue,
00178                            Branch::ByDegreeMaxNoTies<BoolView>,
00179                            Branch::ValOneZero<BoolView> >(home,xv);
00180         break;
00181       default:
00182         throw UnknownBranching("Int::branch");
00183       }
00184       break;
00185     default:
00186       throw UnknownBranching("Int::branch");
00187     }
00188   }
00189 
00190   void
00191   assign(Space* home, const IntVarArgs& x, IntAssign vals) {
00192     ViewArray<IntView> xv(home,x);
00193     switch (vals) {
00194     case INT_ASSIGN_MIN:
00195       if (home->failed()) return;
00196       (void) new (home) 
00197         ViewValAssignment<IntView,int,
00198                           Branch::ValMin<IntView> >(home,xv);
00199       break;
00200     case INT_ASSIGN_MED:
00201       if (home->failed()) return;
00202       (void) new (home) 
00203         ViewValAssignment<IntView,int,
00204                           Branch::ValMed<IntView> >(home,xv);
00205       break;
00206     case INT_ASSIGN_MAX:
00207       if (home->failed()) return;
00208       (void) new (home) 
00209         ViewValAssignment<IntView,int,
00210                           Branch::ValMax<IntView> >(home,xv);
00211       break;
00212     default:
00213       throw UnknownBranching("Int::assign");
00214     }
00215   }
00216 
00217   void
00218   assign(Space* home, const BoolVarArgs& x, IntAssign vals) {
00219     ViewArray<BoolView> xv(home,x);
00220     switch (vals) {
00221     case INT_ASSIGN_MIN:
00222     case INT_ASSIGN_MED:
00223       if (home->failed()) return;
00224       (void) new (home) 
00225         ViewValAssignment<BoolView,Branch::NoValue,
00226                           Branch::ValZeroOne<BoolView> >(home,xv);
00227       break;
00228     case INT_ASSIGN_MAX:
00229       if (home->failed()) return;
00230       (void) new (home) 
00231         ViewValAssignment<BoolView,Branch::NoValue,
00232                           Branch::ValOneZero<BoolView> >(home,xv);
00233       break;
00234     default:
00235       throw UnknownBranching("Int::assign");
00236     }
00237   }
00238 
00239   namespace Int { namespace Branch {
00240 
00241     template<class View, class Val, template <class> class SelView>
00243     class Creator {
00244     public:
00245       Reflection::ActorRegistrar<ViewValBranching<View,Val,SelView<View>,
00246         Branch::ValMin<View> > > r1;
00247       Reflection::ActorRegistrar<ViewValBranching<View,Val,SelView<View>,
00248         ValMed<View> > > r2;
00249       Reflection::ActorRegistrar<ViewValBranching<View,Val,SelView<View>,
00250         ValMax<View> > > r3;
00251       Reflection::ActorRegistrar<ViewValBranching<View,Val,SelView<View>,
00252         ValSplitMin<View> > > r4;
00253       Reflection::ActorRegistrar<ViewValBranching<View,Val,SelView<View>,
00254         ValSplitMax<View> > > r5;
00255     };
00256 
00257     Creator<IntView,int,BySizeMin> c1;
00258     Creator<IntView,int,BySizeMax> c2;
00259     Creator<IntView,int,ByMinMin> c3;
00260     Creator<IntView,int,ByMinMax> c4;
00261     Creator<IntView,int,ByMaxMin> c5;
00262     Creator<IntView,int,ByMaxMax> c6;
00263     Creator<IntView,int,ByNone> c7;
00264     Creator<IntView,int,ByRegretMinMin> c8;
00265     Creator<IntView,int,ByRegretMinMax> c9;
00266     Creator<IntView,int,ByRegretMaxMin> c10;
00267     Creator<IntView,int,ByRegretMaxMax> c11;
00268     Creator<IntView,int,ByDegreeMin> c12;
00269     Creator<IntView,int,ByDegreeMax> c13;
00270 
00271     Reflection::ActorRegistrar<ViewValBranching<BoolView,NoValue,
00272       ByDegreeMaxNoTies<BoolView>,ValOneZero<BoolView> > > r1;
00273     Reflection::ActorRegistrar<ViewValBranching<BoolView,NoValue,
00274       ByDegreeMaxNoTies<BoolView>,ValZeroOne<BoolView> > > r2;
00275     Reflection::ActorRegistrar<ViewValBranching<BoolView,NoValue,
00276       ByDegreeMinNoTies<BoolView>,ValOneZero<BoolView> > > r3;
00277     Reflection::ActorRegistrar<ViewValBranching<BoolView,NoValue,
00278       ByDegreeMinNoTies<BoolView>,ValZeroOne<BoolView> > > r4;
00279     Reflection::ActorRegistrar<ViewValBranching<BoolView,NoValue,
00280       ByNone<BoolView>,ValOneZero<BoolView> > > r5;
00281     Reflection::ActorRegistrar<ViewValBranching<BoolView,NoValue,
00282       ByNone<BoolView>,ValZeroOne<BoolView> > > r6;
00283 
00284     Reflection::ActorRegistrar<ViewValAssignment<IntView,int,
00285       ValMax<IntView> > > r7;
00286     Reflection::ActorRegistrar<ViewValAssignment<IntView,int,
00287       ValMed<IntView> > > r8;
00288     Reflection::ActorRegistrar<ViewValAssignment<IntView,int,
00289       ValMin<IntView> > > r9;
00290     Reflection::ActorRegistrar<ViewValAssignment<BoolView,NoValue,
00291       ValOneZero<BoolView> > > r10;
00292     Reflection::ActorRegistrar<ViewValAssignment<BoolView,NoValue,
00293       ValZeroOne<BoolView> > > r11;
00294 
00295   }}
00296 
00297 }
00298 
00299 
00300 // STATISTICS: int-post
00301