00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
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
00301