Generated on Thu Apr 5 2018 19:44:19 for Gecode by doxygen 1.8.13
branch.cpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Mikael Lagerkvist <lagerkvist@gecode.org>
5  * Christian Schulte <schulte@gecode.org>
6  *
7  * Contributing authors:
8  * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
9  *
10  * Copyright:
11  * Mikael Lagerkvist, 2005
12  * Christian Schulte, 2009
13  * Vincent Barichard, 2012
14  *
15  * Last modified:
16  * $Date$ by $Author$
17  * $Revision$
18  *
19  * This file is part of Gecode, the generic constraint
20  * development environment:
21  * http://www.gecode.org
22  *
23  * Permission is hereby granted, free of charge, to any person obtaining
24  * a copy of this software and associated documentation files (the
25  * "Software"), to deal in the Software without restriction, including
26  * without limitation the rights to use, copy, modify, merge, publish,
27  * distribute, sublicense, and/or sell copies of the Software, and to
28  * permit persons to whom the Software is furnished to do so, subject to
29  * the following conditions:
30  *
31  * The above copyright notice and this permission notice shall be
32  * included in all copies or substantial portions of the Software.
33  *
34  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
35  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
36  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
37  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
38  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
39  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
40  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
41  *
42  */
43 
44 #include "test/branch.hh"
45 
46 #include <algorithm>
47 #include <map>
48 #include <vector>
49 #include <iostream>
50 
51 #include <gecode/kernel.hh>
52 #include <gecode/int.hh>
53 #ifdef GECODE_HAS_SET_VARS
54 #include <gecode/set.hh>
55 #endif
56 #ifdef GECODE_HAS_FLOAT_VARS
57 #include <gecode/float.hh>
58 #endif
59 
60 #include <gecode/search.hh>
61 
62 namespace Test { namespace Branch {
63 
65  double tbl(const Gecode::Space&, double w, double b) {
66  return (w + (b-w)/2.0);
67  }
68 
70  class IntTestSpace : public Gecode::Space {
71  public:
80  : x(*this, n, d),
81  vara(Gecode::INT_VAR_NONE()), varb(Gecode::INT_VAR_NONE()),
82  val(Gecode::INT_VAL_MIN()) {}
85  : Gecode::Space(s), vara(s.vara), varb(s.varb), val(s.val) {
86  x.update(*this, s.x);
87  }
89  virtual Gecode::Space* copy(void) {
90  return new IntTestSpace(*this);
91  }
92  };
93 
95  class BoolTestSpace : public Gecode::Space {
96  public:
101  : x(*this, n, 0, 1) {}
104  : Gecode::Space(s) {
105  x.update(*this, s.x);
106  }
108  virtual Gecode::Space* copy(void) {
109  return new BoolTestSpace(*this);
110  }
111  };
112 
113 #ifdef GECODE_HAS_SET_VARS
114  class SetTestSpace : public Gecode::Space {
116  public:
121  : x(*this, n, Gecode::IntSet::empty, d) {}
124  : Gecode::Space(s) {
125  x.update(*this, s.x);
126  }
128  virtual Gecode::Space* copy(void) {
129  return new SetTestSpace(*this);
130  }
131  };
132 #endif
133 
134 #ifdef GECODE_HAS_FLOAT_VARS
135  class FloatTestSpace : public Gecode::Space {
137  public:
142  : x(*this, n, d.min(), d.max()) {}
145  : Gecode::Space(s) {
146  x.update(*this, s.x);
147  }
149  virtual Gecode::Space* copy(void) {
150  return new FloatTestSpace(*this);
151  }
152  };
153 #endif
154 
160  const char* int_var_branch_name[] = {
162  "SINGLE VARIABLE",
163  "INT_VAR_NONE",
164  "INT_VAR_RND",
165  "INT_VAR_MERIT_MIN",
166  "INT_VAR_MERIT_MAX",
167  "INT_VAR_DEGREE_MIN",
168  "INT_VAR_DEGREE_MAX",
169  "INT_VAR_AFC_MIN",
170  "INT_VAR_AFC_MAX",
171  "INT_VAR_ACTION_MIN",
172  "INT_VAR_ACTION_MAX",
173  "INT_VAR_CHB_MIN",
174  "INT_VAR_CHB_MAX",
175  "INT_VAR_MIN_MIN",
176  "INT_VAR_MIN_MAX",
177  "INT_VAR_MAX_MIN",
178  "INT_VAR_MAX_MAX",
179  "INT_VAR_SIZE_MIN",
180  "INT_VAR_SIZE_MAX",
181  "INT_VAR_DEGREE_SIZE_MIN",
182  "INT_VAR_DEGREE_SIZE_MAX",
183  "INT_VAR_AFC_SIZE_MIN",
184  "INT_VAR_AFC_SIZE_MAX",
185  "INT_VAR_ACTION_SIZE_MIN",
186  "INT_VAR_ACTION_SIZE_MAX",
187  "INT_VAR_CHB_SIZE_MIN",
188  "INT_VAR_CHB_SIZE_MAX",
189  "INT_VAR_REGRET_MIN_MIN",
190  "INT_VAR_REGRET_MIN_MAX",
191  "INT_VAR_REGRET_MAX_MIN",
192  "INT_VAR_REGRET_MAX_MAX"
193  };
195  const int n_int_var_branch =
196  sizeof(int_var_branch_name)/sizeof(const char*);
198  const char* bool_var_branch_name[] = {
199  "SINGLE VARIABLE",
200  "BOOL_VAR_NONE",
201  "BOOL_VAR_RND",
202  "BOOL_VAR_MERIT_MIN",
203  "BOOL_VAR_MERIT_MAX",
204  "BOOL_VAR_DEGREE_MIN",
205  "BOOL_VAR_DEGREE_MAX",
206  "BOOL_VAR_AFC_MIN",
207  "BOOL_VAR_AFC_MAX",
208  "BOOL_VAR_ACTION_MIN",
209  "BOOL_VAR_ACTION_MAX",
210  "BOOL_VAR_CHB_MIN",
211  "BOOL_VAR_CHB_MAX"
212  };
214  const int n_bool_var_branch =
215  sizeof(bool_var_branch_name)/sizeof(const char*);
217  double int_merit(const Gecode::Space&, Gecode::IntVar x, int) {
218  return x.min();
219  }
221  double bool_merit(const Gecode::Space&, Gecode::BoolVar x, int) {
222  return x.min();
223  }
225  const char* int_val_branch_name[] = {
226  "INT_VAL_MIN",
227  "INT_VAL_MED",
228  "INT_VAL_MAX",
229  "INT_VAL_RND",
230  "INT_VAL_SPLIT_MIN",
231  "INT_VAL_SPLIT_MAX",
232  "INT_VAL_RANGE_MIN",
233  "INT_VAL_RANGE_MAX",
234  "INT_VAL",
235  "INT_VALUES_MIN",
236  "INT_VALUES_MAX"
237  };
239  const int n_int_val_branch =
240  sizeof(int_val_branch_name)/sizeof(const char*);
242  const char* bool_val_branch_name[] = {
243  "BOOL_VAL_MIN",
244  "BOOL_VAL_MAX",
245  "BOOL_VAL_RND",
246  "BOOL_VAL"
247  };
249  const int n_bool_val_branch =
250  sizeof(bool_val_branch_name)/sizeof(const char*);
252  int int_val(const Gecode::Space&, Gecode::IntVar x, int) {
253  return x.min();
254  }
257  return x.min();
258  }
260 
261 #ifdef GECODE_HAS_SET_VARS
262 
267  const char* set_var_branch_name[] = {
269  "SINGLE VARIABLE",
270  "SET_VAR_NONE",
271  "SET_VAR_RND",
272  "SET_VAR_MERIT_MIN",
273  "SET_VAR_MERIT_MAX",
274  "SET_VAR_DEGREE_MIN",
275  "SET_VAR_DEGREE_MAX",
276  "SET_VAR_AFC_MIN",
277  "SET_VAR_AFC_MAX",
278  "SET_VAR_ACTION_MIN",
279  "SET_VAR_ACTION_MAX",
280  "SET_VAR_CHB_MIN",
281  "SET_VAR_CHB_MAX",
282  "SET_VAR_MIN_MIN",
283  "SET_VAR_MIN_MAX",
284  "SET_VAR_MAX_MIN",
285  "SET_VAR_MAX_MAX",
286  "SET_VAR_SIZE_MIN",
287  "SET_VAR_SIZE_MAX",
288  "SET_VAR_DEGREE_SIZE_MIN",
289  "SET_VAR_DEGREE_SIZE_MAX",
290  "SET_VAR_AFC_SIZE_MIN",
291  "SET_VAR_AFC_SIZE_MAX",
292  "SET_VAR_ACTION_SIZE_MIN",
293  "SET_VAR_ACTION_SIZE_MAX",
294  "SET_VAR_CHB_SIZE_MIN",
295  "SET_VAR_CHB_SIZE_MAX"
296  };
298  const int n_set_var_branch =
299  sizeof(set_var_branch_name)/sizeof(const char*);
301  double set_merit(const Gecode::Space&, Gecode::SetVar, int) {
302  return 2.0;
303  }
305  const char* set_val_branch_name[] = {
306  "SET_VAL_MIN_INC",
307  "SET_VAL_MIN_EXC",
308  "SET_VAL_MED_INC",
309  "SET_VAL_MED_EXC",
310  "SET_VAL_MAX_INC",
311  "SET_VAL_MAX_EXC",
312  "SET_VAL_RND_INC",
313  "SET_VAL_RND_EXC",
314  "SET_VAL"
315  };
317  const int n_set_val_branch =
318  sizeof(set_val_branch_name)/sizeof(const char*);
320  int set_val(const Gecode::Space&, Gecode::SetVar x, int) {
322  return r.min();
323  }
325 #endif
326 
327 #ifdef GECODE_HAS_FLOAT_VARS
328 
333  const char* float_var_branch_name[] = {
335  "SINGLE VARIABLE",
336  "FLOAT_VAR_NONE",
337  "FLOAT_VAR_RND",
338  "FLOAT_VAR_MERIT_MIN",
339  "FLOAT_VAR_MERIT_MAX",
340  "FLOAT_VAR_DEGREE_MIN",
341  "FLOAT_VAR_DEGREE_MAX",
342  "FLOAT_VAR_AFC_MIN",
343  "FLOAT_VAR_AFC_MAX",
344  "FLOAT_VAR_ACTION_MIN",
345  "FLOAT_VAR_ACTION_MAX",
346  "FLOAT_VAR_CHB_MIN",
347  "FLOAT_VAR_CHB_MAX",
348  "FLOAT_VAR_MIN_MIN",
349  "FLOAT_VAR_MIN_MAX",
350  "FLOAT_VAR_MAX_MIN",
351  "FLOAT_VAR_MAX_MAX",
352  "FLOAT_VAR_SIZE_MIN",
353  "FLOAT_VAR_SIZE_MAX",
354  "FLOAT_VAR_DEGREE_SIZE_MIN",
355  "FLOAT_VAR_DEGREE_SIZE_MAX",
356  "FLOAT_VAR_AFC_SIZE_MIN",
357  "FLOAT_VAR_AFC_SIZE_MAX",
358  "FLOAT_VAR_ACTION_SIZE_MIN",
359  "FLOAT_VAR_ACTION_SIZE_MAX",
360  "FLOAT_VAR_CHB_SIZE_MIN",
361  "FLOAT_VAR_CHB_SIZE_MAX"
362  };
364  const int n_float_var_branch =
365  sizeof(float_var_branch_name)/sizeof(const char*);
368  return static_cast<double>(x.degree());
369  }
371  const char* float_val_branch_name[] = {
372  "FLOAT_VAL_SPLIT_MIN",
373  "FLOAT_VAL_SPLIT_MAX",
374  "FLOAT_VAL_SPLIT_RND",
375  "FLOAT_VAL"
376  };
378  const int n_float_val_branch =
379  sizeof(float_val_branch_name)/sizeof(const char*);
382  Gecode::FloatVar x, int) {
383  Gecode::FloatNumBranch nl; nl.n=x.med(); nl.l=true;
384  return nl;
385  }
387 #endif
388 
390  class RunInfo {
391  public:
392  std::string var, val;
393  unsigned int a_d, c_d;
394  RunInfo(const std::string& vara, const std::string& varb,
395  const std::string& valname,
396  const Gecode::Search::Options& o)
397  : var(vara + "::" + varb), val(valname), a_d(o.a_d), c_d(o.c_d) {}
398  void print(std::ostream& o) const {
399  o << "(" << var << ", " << val << ", " << a_d << ", " << c_d << ")";
400  }
401  };
402 
403 }}
404 
405 std::ostream&
406 operator<<(std::ostream& os, const Test::Branch::RunInfo& ri) {
407  ri.print(os);
408  return os;
409 }
410 
411 
412 namespace Test { namespace Branch {
413 
415  template<class TestSpace>
416  int solutions(TestSpace* c, Gecode::Search::Options& o, int maxNbSol = -1) {
417  o.a_d = Base::rand(10);
418  o.c_d = Base::rand(10);
419  Gecode::DFS<TestSpace> e_s(c, o);
420  delete c;
421 
422  // Find number of solutions
423  int s = 0;
424  do {
425  Gecode::Space* ex = e_s.next();
426  if (ex == NULL) break;
427  delete ex;
428  ++s;
429  if ((maxNbSol >= 0) && (maxNbSol == s)) break;
430  } while (true);
431  return s;
432  }
433 
434  IntTest::IntTest(const std::string& s, int a, const Gecode::IntSet& d)
435  : Base("Int::Branch::"+s), arity(a), dom(d) {
436  }
437 
438  bool
439  IntTest::run(void) {
440  using std::map;
441  using std::vector;
442  using std::string;
443  using std::ostream;
444  using namespace Gecode;
445 
446  // Results of tests run
447  map<int, vector<RunInfo> > results;
448  // Set up root space
449  IntTestSpace* root = new IntTestSpace(arity,dom);
450  post(*root, root->x);
451  results.clear();
452 
453  IntArgs d(arity);
454  for (int i=arity; i--; )
455  d[i]=i;
456 
457  for (int vara = 0; vara<n_int_var_branch; vara++) {
458  for (int varb = 1; varb<n_int_var_branch; varb++) {
459  for (int val = 0; val<n_int_val_branch; val++) {
460  Rnd r(1);
461 
462  IntValBranch ivb;
463  switch (val) {
464  case 0: ivb = INT_VAL_MIN(); break;
465  case 1: ivb = INT_VAL_MED(); break;
466  case 2: ivb = INT_VAL_MAX(); break;
467  case 3: ivb = INT_VAL_RND(r); break;
468  case 4: ivb = INT_VAL_SPLIT_MIN(); break;
469  case 5: ivb = INT_VAL_SPLIT_MAX(); break;
470  case 6: ivb = INT_VAL_RANGE_MIN(); break;
471  case 7: ivb = INT_VAL_RANGE_MAX(); break;
472  case 8: ivb = INT_VAL(&int_val); break;
473  case 9: ivb = INT_VALUES_MIN(); break;
474  case 10: ivb = INT_VALUES_MAX(); break;
475  }
476 
477  IntTestSpace* c = static_cast<IntTestSpace*>(root->clone());
478 
479  if ((vara == 0) && (val < 11)) {
480  for (int i=0; i<c->x.size(); i++)
481  branch(*c, c->x[i], ivb);
482  } else {
483  Rnd ra(1);
484  IntVarBranch ivba;
485  IntAction iaa(*c, c->x, 0.9);
486  IntCHB ica(*c, c->x);
487  switch (vara) {
488  case 0: ivba = INT_VAR_NONE(); break;
489  case 1: ivba = INT_VAR_NONE(); break;
490  case 2: ivba = INT_VAR_RND(ra); break;
491  case 3: ivba = INT_VAR_MERIT_MIN(&int_merit); break;
492  case 4: ivba = INT_VAR_MERIT_MAX(&int_merit); break;
493  case 5: ivba = INT_VAR_DEGREE_MIN(); break;
494  case 6: ivba = INT_VAR_DEGREE_MAX(); break;
495  case 7: ivba = INT_VAR_AFC_MIN(0.5); break;
496  case 8: ivba = INT_VAR_AFC_MAX(0.5); break;
497  case 9: ivba = INT_VAR_ACTION_MIN(iaa); break;
498  case 10: ivba = INT_VAR_ACTION_MAX(iaa); break;
499  case 11: ivba = INT_VAR_CHB_MIN(ica); break;
500  case 12: ivba = INT_VAR_CHB_MAX(ica); break;
501  case 13: ivba = INT_VAR_MIN_MIN(); break;
502  case 14: ivba = INT_VAR_MIN_MAX(); break;
503  case 15: ivba = INT_VAR_MAX_MIN(); break;
504  case 16: ivba = INT_VAR_MAX_MAX(); break;
505  case 17: ivba = INT_VAR_SIZE_MIN(); break;
506  case 18: ivba = INT_VAR_SIZE_MAX(); break;
507  case 19: ivba = INT_VAR_DEGREE_SIZE_MIN(); break;
508  case 20: ivba = INT_VAR_DEGREE_SIZE_MAX(); break;
509  case 21: ivba = INT_VAR_AFC_SIZE_MIN(); break;
510  case 22: ivba = INT_VAR_AFC_SIZE_MAX(); break;
511  case 23: ivba = INT_VAR_ACTION_SIZE_MIN(iaa); break;
512  case 24: ivba = INT_VAR_ACTION_SIZE_MAX(iaa); break;
513  case 25: ivba = INT_VAR_CHB_SIZE_MIN(ica); break;
514  case 26: ivba = INT_VAR_CHB_SIZE_MAX(ica); break;
515  case 27: ivba = INT_VAR_REGRET_MIN_MIN(); break;
516  case 28: ivba = INT_VAR_REGRET_MIN_MAX(); break;
517  case 29: ivba = INT_VAR_REGRET_MAX_MIN(); break;
518  case 30: ivba = INT_VAR_REGRET_MAX_MAX(); break;
519  }
520 
521  Rnd rb(2);
522  IntVarBranch ivbb;
523  IntAction iab(*c, c->x, 0.9, &int_merit);
524  IntCHB icb(*c, c->x, &int_merit);
525  switch (varb) {
526  case 0: ivbb = INT_VAR_NONE(); break;
527  case 1: ivbb = INT_VAR_NONE(); break;
528  case 2: ivbb = INT_VAR_RND(rb); break;
529  case 3: ivbb = INT_VAR_MERIT_MIN(&int_merit,&tbl); break;
530  case 4: ivbb = INT_VAR_MERIT_MAX(&int_merit,&tbl); break;
531  case 5: ivbb = INT_VAR_DEGREE_MIN(&tbl); break;
532  case 6: ivbb = INT_VAR_DEGREE_MAX(&tbl); break;
533  case 7: ivbb = INT_VAR_AFC_MIN(0.5,&tbl); break;
534  case 8: ivbb = INT_VAR_AFC_MAX(0.5,&tbl); break;
535  case 9: ivbb = INT_VAR_ACTION_MIN(iab,&tbl); break;
536  case 10: ivbb = INT_VAR_ACTION_MAX(iab,&tbl); break;
537  case 11: ivbb = INT_VAR_CHB_MIN(icb,&tbl); break;
538  case 12: ivbb = INT_VAR_CHB_MAX(icb,&tbl); break;
539  case 13: ivbb = INT_VAR_MIN_MIN(&tbl); break;
540  case 14: ivbb = INT_VAR_MIN_MAX(&tbl); break;
541  case 15: ivbb = INT_VAR_MAX_MIN(&tbl); break;
542  case 16: ivbb = INT_VAR_MAX_MAX(&tbl); break;
543  case 17: ivbb = INT_VAR_SIZE_MIN(&tbl); break;
544  case 18: ivbb = INT_VAR_SIZE_MAX(&tbl); break;
545  case 19: ivbb = INT_VAR_DEGREE_SIZE_MIN(&tbl); break;
546  case 20: ivbb = INT_VAR_DEGREE_SIZE_MAX(&tbl); break;
547  case 21: ivbb = INT_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
548  case 22: ivbb = INT_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
549  case 23: ivbb = INT_VAR_ACTION_SIZE_MIN(iab,&tbl); break;
550  case 24: ivbb = INT_VAR_ACTION_SIZE_MAX(iab,&tbl); break;
551  case 25: ivbb = INT_VAR_CHB_SIZE_MIN(icb,&tbl); break;
552  case 26: ivbb = INT_VAR_CHB_SIZE_MAX(icb,&tbl); break;
553  case 27: ivbb = INT_VAR_REGRET_MIN_MIN(&tbl); break;
554  case 28: ivbb = INT_VAR_REGRET_MIN_MAX(&tbl); break;
555  case 29: ivbb = INT_VAR_REGRET_MAX_MIN(&tbl); break;
556  case 30: ivbb = INT_VAR_REGRET_MAX_MAX(&tbl); break;
557  }
558 
559  switch (Base::rand(9U)) {
560  case 0U:
561  branch(*c, c->x, ivba, ivb); break;
562  case 1U:
563  branch(*c, c->x, ivbb, ivb); break;
564  case 2U:
565  branch(*c, c->x, tiebreak(ivba,ivbb), ivb); break;
566  case 3U:
567  branch(*c, c->x, tiebreak(ivbb,ivba), ivb); break;
568  case 4U:
569  branch(*c, c->x, tiebreak(ivba,ivba,ivbb), ivb); break;
570  case 5U:
571  branch(*c, c->x, tiebreak(ivba,ivbb,ivbb), ivb); break;
572  case 6U:
573  branch(*c, c->x, tiebreak(ivbb,ivba,ivba), ivb); break;
574  case 7U:
575  branch(*c, c->x, tiebreak(ivba,ivba,ivbb,ivba), ivb); break;
576  case 8U:
577  branch(*c, c->x, tiebreak(ivbb,ivba,ivbb,ivba), ivb); break;
578  }
579 
580  }
582  results[solutions(c,o)].push_back
583  (RunInfo(int_var_branch_name[vara],
584  int_var_branch_name[varb],
585  int_val_branch_name[val],
586  o));
587  }
588  }
589  }
590  if (results.size() > 1)
591  goto failed;
592  delete root;
593  return true;
594  failed:
595  std::cout << "FAILURE" << std::endl;
596  for (map<int, vector<RunInfo> >::iterator it = results.begin();
597  it != results.end(); ++it) {
598  std::cout << "Number of solutions: " << it->first << std::endl;
599  for (unsigned int i = 0; i < it->second.size(); ++i)
600  std::cout << it->second[i] << " ";
601  std::cout << std::endl;
602  }
603 
604  delete root;
605  return results.size() == 1;
606  }
607 
608  BoolTest::BoolTest(const std::string& s, int a)
609  : Base("Bool::Branch::"+s), arity(a) {
610  }
611 
612  bool
614  using std::map;
615  using std::vector;
616  using std::string;
617  using std::ostream;
618  using namespace Gecode;
619 
620  // Results of tests run
621  map<int, vector<RunInfo> > results;
622  // Set up root space
623  BoolTestSpace* root = new BoolTestSpace(arity);
624  post(*root, root->x);
625  results.clear();
626 
627  for (int vara = 0; vara<n_bool_var_branch; vara++) {
628  for (int varb = 1; varb<n_bool_var_branch; varb++) {
629  for (int val = 0; val<n_bool_val_branch; val++) {
630 
631  Rnd r(1);
632 
633  BoolValBranch bvb;
634  switch (val) {
635  case 0: bvb = BOOL_VAL_MIN(); break;
636  case 1: bvb = BOOL_VAL_MAX(); break;
637  case 2: bvb = BOOL_VAL_RND(r); break;
638  case 3: bvb = BOOL_VAL(&bool_val); break;
639  }
640 
641  BoolTestSpace* c = static_cast<BoolTestSpace*>(root->clone());
642 
643  if (vara == 0) {
644  for (int i=0; i<c->x.size(); i++)
645  branch(*c, c->x[i], bvb);
646  } else {
647 
648 
649  Rnd ra(1);
650  BoolVarBranch bvba;
651  BoolAction baa(*c, c->x, 0.9);
652  BoolCHB bca(*c, c->x);
653  switch (vara) {
654  case 0: bvba = BOOL_VAR_NONE(); break;
655  case 1: bvba = BOOL_VAR_NONE(); break;
656  case 2: bvba = BOOL_VAR_RND(ra); break;
657  case 3: bvba = BOOL_VAR_MERIT_MIN(&bool_merit); break;
658  case 4: bvba = BOOL_VAR_MERIT_MAX(&bool_merit); break;
659  case 5: bvba = BOOL_VAR_DEGREE_MIN(); break;
660  case 6: bvba = BOOL_VAR_DEGREE_MAX(); break;
661  case 7: bvba = BOOL_VAR_AFC_MIN(0.5); break;
662  case 8: bvba = BOOL_VAR_AFC_MAX(0.5); break;
663  case 9: bvba = BOOL_VAR_ACTION_MIN(baa); break;
664  case 10: bvba = BOOL_VAR_ACTION_MAX(baa); break;
665  case 11: bvba = BOOL_VAR_CHB_MIN(bca); break;
666  case 12: bvba = BOOL_VAR_CHB_MAX(bca); break;
667  }
668 
669  Rnd rb(2);
670  BoolVarBranch bvbb;
671  BoolAction bab(*c, c->x, 0.9, &bool_merit);
672  BoolCHB bcb(*c, c->x, &bool_merit);
673  switch (varb) {
674  case 0: bvbb = BOOL_VAR_NONE(); break;
675  case 1: bvbb = BOOL_VAR_NONE(); break;
676  case 2: bvbb = BOOL_VAR_RND(rb); break;
677  case 3: bvbb = BOOL_VAR_MERIT_MIN(&bool_merit,&tbl); break;
678  case 4: bvbb = BOOL_VAR_MERIT_MAX(&bool_merit,&tbl); break;
679  case 5: bvbb = BOOL_VAR_DEGREE_MIN(&tbl); break;
680  case 6: bvbb = BOOL_VAR_DEGREE_MAX(&tbl); break;
681  case 7: bvbb = BOOL_VAR_AFC_MIN(0.5,&tbl); break;
682  case 8: bvbb = BOOL_VAR_AFC_MAX(0.5,&tbl); break;
683  case 9: bvbb = BOOL_VAR_ACTION_MIN(bab,&tbl); break;
684  case 10: bvbb = BOOL_VAR_ACTION_MAX(bab,&tbl); break;
685  case 11: bvbb = BOOL_VAR_CHB_MIN(bcb,&tbl); break;
686  case 12: bvbb = BOOL_VAR_CHB_MAX(bcb,&tbl); break;
687  }
688 
689  switch (Base::rand(9U)) {
690  case 0U:
691  branch(*c, c->x, bvba, bvb); break;
692  case 1U:
693  branch(*c, c->x, bvbb, bvb); break;
694  case 2U:
695  branch(*c, c->x, tiebreak(bvba,bvbb), bvb); break;
696  case 3U:
697  branch(*c, c->x, tiebreak(bvbb,bvba), bvb); break;
698  case 4U:
699  branch(*c, c->x, tiebreak(bvba,bvba,bvbb), bvb); break;
700  case 5U:
701  branch(*c, c->x, tiebreak(bvba,bvbb,bvbb), bvb); break;
702  case 6U:
703  branch(*c, c->x, tiebreak(bvbb,bvba,bvba), bvb); break;
704  case 7U:
705  branch(*c, c->x, tiebreak(bvba,bvba,bvbb,bvba), bvb); break;
706  case 8U:
707  branch(*c, c->x, tiebreak(bvbb,bvba,bvbb,bvba), bvb); break;
708  }
709 
710  }
712  results[solutions(c,o)].push_back
713  (RunInfo(int_var_branch_name[vara],
714  int_var_branch_name[varb],
715  int_val_branch_name[val],
716  o));
717  }
718  }
719  }
720  if (results.size() > 1)
721  goto failed;
722  delete root;
723  return true;
724  failed:
725  std::cout << "FAILURE" << std::endl;
726  for (map<int, vector<RunInfo> >::iterator it = results.begin();
727  it != results.end(); ++it) {
728  std::cout << "Number of solutions: " << it->first << std::endl;
729  for (unsigned int i = 0; i < it->second.size(); ++i)
730  std::cout << it->second[i] << " ";
731  std::cout << std::endl;
732  }
733 
734  delete root;
735  return results.size() == 1;
736  }
737 
738 #ifdef GECODE_HAS_SET_VARS
739  SetTest::SetTest(const std::string& s, int a, const Gecode::IntSet& d)
740  : Base("Set::Branch::"+s), arity(a), dom(d) {
741  }
742 
743  bool
744  SetTest::run(void) {
745  using std::map;
746  using std::vector;
747  using std::string;
748  using std::ostream;
749  using namespace Gecode;
750 
751  // Results of tests run
752  map<int, vector<RunInfo> > results;
753  // Set up root space
754  SetTestSpace* root = new SetTestSpace(arity,dom);
755  post(*root, root->x);
756  root->status();
757  results.clear();
758 
759  for (int vara = 0; vara<n_set_var_branch; vara++) {
760  for (int varb = 1; varb<n_set_var_branch; varb++) {
761  for (int val = 0; val<n_set_val_branch; val++) {
762  Rnd r(1);
763 
764  SetValBranch svb;
765  switch (val) {
766  case 0: svb = SET_VAL_MIN_INC(); break;
767  case 1: svb = SET_VAL_MIN_EXC(); break;
768  case 2: svb = SET_VAL_MED_INC(); break;
769  case 3: svb = SET_VAL_MED_EXC(); break;
770  case 4: svb = SET_VAL_MAX_INC(); break;
771  case 5: svb = SET_VAL_MAX_EXC(); break;
772  case 6: svb = SET_VAL_RND_INC(r); break;
773  case 7: svb = SET_VAL_RND_EXC(r); break;
774  case 8: svb = SET_VAL(&set_val); break;
775  }
776 
777  SetTestSpace* c = static_cast<SetTestSpace*>(root->clone());
778 
779  if (vara == 0) {
780  for (int i=0; i<c->x.size(); i++)
781  branch(*c, c->x[i], svb);
782  } else {
783  Rnd ra(1);
784  SetVarBranch svba;
785  SetAction saa(*c, c->x, 0.9);
786  SetCHB sca(*c, c->x);
787  switch (vara) {
788  case 0: break;
789  case 1: svba = SET_VAR_NONE(); break;
790  case 2: svba = SET_VAR_RND(ra); break;
791  case 3: svba = SET_VAR_MERIT_MIN(&set_merit); break;
792  case 4: svba = SET_VAR_MERIT_MAX(&set_merit); break;
793  case 5: svba = SET_VAR_DEGREE_MIN(); break;
794  case 6: svba = SET_VAR_DEGREE_MAX(); break;
795  case 7: svba = SET_VAR_AFC_MIN(0.5); break;
796  case 8: svba = SET_VAR_AFC_MAX(0.5); break;
797  case 9: svba = SET_VAR_ACTION_MIN(saa); break;
798  case 10: svba = SET_VAR_ACTION_MAX(saa); break;
799  case 11: svba = SET_VAR_CHB_MIN(sca); break;
800  case 12: svba = SET_VAR_CHB_MAX(sca); break;
801  case 13: svba = SET_VAR_MIN_MIN(); break;
802  case 14: svba = SET_VAR_MIN_MAX(); break;
803  case 15: svba = SET_VAR_MAX_MIN(); break;
804  case 16: svba = SET_VAR_MAX_MAX(); break;
805  case 17: svba = SET_VAR_SIZE_MIN(); break;
806  case 18: svba = SET_VAR_SIZE_MAX(); break;
807  case 19: svba = SET_VAR_DEGREE_SIZE_MIN(); break;
808  case 20: svba = SET_VAR_DEGREE_SIZE_MAX(); break;
809  case 21: svba = SET_VAR_AFC_SIZE_MIN(); break;
810  case 22: svba = SET_VAR_AFC_SIZE_MAX(); break;
811  case 23: svba = SET_VAR_ACTION_SIZE_MIN(saa); break;
812  case 24: svba = SET_VAR_ACTION_SIZE_MAX(saa); break;
813  case 25: svba = SET_VAR_CHB_SIZE_MIN(sca); break;
814  case 26: svba = SET_VAR_CHB_SIZE_MAX(sca); break;
815  }
816 
817  Rnd rb(2);
818  SetVarBranch svbb;
819  SetAction sab(*c, c->x, 0.9, &set_merit);
820  SetCHB scb(*c, c->x, &set_merit);
821  switch (varb) {
822  case 0: break;
823  case 1: svbb = SET_VAR_NONE(); break;
824  case 2: svbb = SET_VAR_RND(rb); break;
825  case 3: svbb = SET_VAR_MERIT_MIN(&set_merit,&tbl); break;
826  case 4: svbb = SET_VAR_MERIT_MAX(&set_merit,&tbl); break;
827  case 5: svbb = SET_VAR_DEGREE_MIN(&tbl); break;
828  case 6: svbb = SET_VAR_DEGREE_MAX(&tbl); break;
829  case 7: svbb = SET_VAR_AFC_MIN(0.5,&tbl); break;
830  case 8: svbb = SET_VAR_AFC_MAX(0.5,&tbl); break;
831  case 9: svbb = SET_VAR_ACTION_MIN(sab,&tbl); break;
832  case 10: svbb = SET_VAR_ACTION_MAX(sab,&tbl); break;
833  case 11: svbb = SET_VAR_CHB_MIN(scb,&tbl); break;
834  case 12: svbb = SET_VAR_CHB_MAX(scb,&tbl); break;
835  case 13: svbb = SET_VAR_MIN_MIN(&tbl); break;
836  case 14: svbb = SET_VAR_MIN_MAX(&tbl); break;
837  case 15: svbb = SET_VAR_MAX_MIN(&tbl); break;
838  case 16: svbb = SET_VAR_MAX_MAX(&tbl); break;
839  case 17: svbb = SET_VAR_SIZE_MIN(&tbl); break;
840  case 18: svbb = SET_VAR_SIZE_MAX(&tbl); break;
841  case 19: svbb = SET_VAR_DEGREE_SIZE_MIN(&tbl); break;
842  case 20: svbb = SET_VAR_DEGREE_SIZE_MAX(&tbl); break;
843  case 21: svbb = SET_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
844  case 22: svbb = SET_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
845  case 23: svbb = SET_VAR_ACTION_SIZE_MIN(sab,&tbl); break;
846  case 24: svbb = SET_VAR_ACTION_SIZE_MAX(sab,&tbl); break;
847  case 25: svbb = SET_VAR_CHB_SIZE_MIN(scb,&tbl); break;
848  case 26: svbb = SET_VAR_CHB_SIZE_MAX(scb,&tbl); break;
849  }
850 
851  switch (Base::rand(9U)) {
852  case 0U:
853  branch(*c, c->x, svba, svb); break;
854  case 1U:
855  branch(*c, c->x, svbb, svb); break;
856  case 2U:
857  branch(*c, c->x, tiebreak(svba,svbb), svb); break;
858  case 3U:
859  branch(*c, c->x, tiebreak(svbb,svba), svb); break;
860  case 4U:
861  branch(*c, c->x, tiebreak(svba,svba,svbb), svb); break;
862  case 5U:
863  branch(*c, c->x, tiebreak(svba,svbb,svbb), svb); break;
864  case 6U:
865  branch(*c, c->x, tiebreak(svbb,svba,svba), svb); break;
866  case 7U:
867  branch(*c, c->x, tiebreak(svba,svba,svbb,svba), svb); break;
868  case 8U:
869  branch(*c, c->x, tiebreak(svbb,svba,svbb,svba), svb); break;
870  }
871 
872  }
874  results[solutions(c,o)].push_back
875  (RunInfo(set_var_branch_name[vara],
876  set_var_branch_name[varb],
877  set_val_branch_name[val],
878  o));
879  }
880  }
881  }
882  if (results.size() > 1)
883  goto failed;
884  delete root;
885  return true;
886  failed:
887  std::cout << "FAILURE" << std::endl;
888  for (map<int, vector<RunInfo> >::iterator it = results.begin();
889  it != results.end(); ++it) {
890  std::cout << "Number of solutions: " << it->first << std::endl;
891  for (unsigned int i = 0; i < it->second.size(); ++i)
892  std::cout << it->second[i] << " ";
893  std::cout << std::endl;
894  }
895 
896  delete root;
897  return results.size() == 1;
898  }
899 #endif
900 
901 #ifdef GECODE_HAS_FLOAT_VARS
902  FloatTest::FloatTest(const std::string& s, int a, const Gecode::FloatVal& d, int nbs)
903  : Base("Float::Branch::"+s), arity(a), dom(d), nbSols(nbs) {
904  }
905 
906  bool
908  using std::map;
909  using std::vector;
910  using std::string;
911  using std::ostream;
912  using namespace Gecode;
913 
914  // Results of tests run
915  map<int, vector<RunInfo> > results;
916  // Set up root space
917  FloatTestSpace* root = new FloatTestSpace(arity,dom);
918  post(*root, root->x);
919  root->status();
920  results.clear();
921 
922  for (int vara = 0; vara<n_float_var_branch; vara++) {
923  for (int varb = 1; varb<n_float_var_branch; varb++) {
924  for (int val = 0; val<n_float_val_branch; val++) {
925  Rnd r(1);
926 
927  FloatValBranch fvb;
928  switch (val) {
929  case 0: fvb = FLOAT_VAL_SPLIT_MIN(); break;
930  case 1: fvb = FLOAT_VAL_SPLIT_MAX(); break;
931  case 2: fvb = FLOAT_VAL_SPLIT_RND(r); break;
932  case 3: fvb = FLOAT_VAL(&float_val); break;
933  }
934 
935  FloatTestSpace* c = static_cast<FloatTestSpace*>(root->clone());
936  if (vara == 0) {
937  for (int i=0; i<c->x.size(); i++)
938  branch(*c, c->x[i], fvb);
939  } else {
940  Rnd ra(1);
941  FloatVarBranch fvba;
942  FloatAction faa(*c, c->x, 0.9);
943  FloatCHB fca(*c, c->x);
944  switch (vara) {
945  case 0: break;
946  case 1: fvba = FLOAT_VAR_NONE(); break;
947  case 2: fvba = FLOAT_VAR_RND(ra); break;
948  case 3: fvba = FLOAT_VAR_MERIT_MIN(&float_merit); break;
949  case 4: fvba = FLOAT_VAR_MERIT_MAX(&float_merit); break;
950  case 5: fvba = FLOAT_VAR_DEGREE_MIN(); break;
951  case 6: fvba = FLOAT_VAR_DEGREE_MAX(); break;
952  case 7: fvba = FLOAT_VAR_AFC_MIN(0.5); break;
953  case 8: fvba = FLOAT_VAR_AFC_MAX(0.5); break;
954  case 9: fvba = FLOAT_VAR_ACTION_MIN(faa); break;
955  case 10: fvba = FLOAT_VAR_ACTION_MAX(faa); break;
956  case 11: fvba = FLOAT_VAR_CHB_MIN(fca); break;
957  case 12: fvba = FLOAT_VAR_CHB_MAX(fca); break;
958  case 13: fvba = FLOAT_VAR_MIN_MIN(); break;
959  case 14: fvba = FLOAT_VAR_MIN_MAX(); break;
960  case 15: fvba = FLOAT_VAR_MAX_MIN(); break;
961  case 16: fvba = FLOAT_VAR_MAX_MAX(); break;
962  case 17: fvba = FLOAT_VAR_SIZE_MIN(); break;
963  case 18: fvba = FLOAT_VAR_SIZE_MAX(); break;
964  case 19: fvba = FLOAT_VAR_DEGREE_SIZE_MIN(); break;
965  case 20: fvba = FLOAT_VAR_DEGREE_SIZE_MAX(); break;
966  case 21: fvba = FLOAT_VAR_AFC_SIZE_MIN(); break;
967  case 22: fvba = FLOAT_VAR_AFC_SIZE_MAX(); break;
968  case 23: fvba = FLOAT_VAR_ACTION_SIZE_MIN(faa); break;
969  case 24: fvba = FLOAT_VAR_ACTION_SIZE_MAX(faa); break;
970  case 25: fvba = FLOAT_VAR_CHB_SIZE_MIN(fca); break;
971  case 26: fvba = FLOAT_VAR_CHB_SIZE_MAX(fca); break;
972  }
973 
974  Rnd rb(2);
975  FloatVarBranch fvbb;
976  FloatAction fab(*c, c->x, 0.9, &float_merit);
977  FloatCHB fcb(*c, c->x, &float_merit);
978  switch (varb) {
979  case 0: break;
980  case 1: fvbb = FLOAT_VAR_NONE(); break;
981  case 2: fvbb = FLOAT_VAR_RND(rb); break;
982  case 3: fvbb = FLOAT_VAR_MERIT_MIN(&float_merit,&tbl); break;
983  case 4: fvbb = FLOAT_VAR_MERIT_MAX(&float_merit,&tbl); break;
984  case 5: fvbb = FLOAT_VAR_DEGREE_MIN(&tbl); break;
985  case 6: fvbb = FLOAT_VAR_DEGREE_MAX(&tbl); break;
986  case 7: fvbb = FLOAT_VAR_AFC_MIN(0.5,&tbl); break;
987  case 8: fvbb = FLOAT_VAR_AFC_MAX(0.5,&tbl); break;
988  case 9: fvbb = FLOAT_VAR_ACTION_MIN(fab,&tbl); break;
989  case 10: fvbb = FLOAT_VAR_ACTION_MAX(fab,&tbl); break;
990  case 11: fvbb = FLOAT_VAR_CHB_MIN(fcb,&tbl); break;
991  case 12: fvbb = FLOAT_VAR_CHB_MAX(fcb,&tbl); break;
992  case 13: fvbb = FLOAT_VAR_MIN_MIN(&tbl); break;
993  case 14: fvbb = FLOAT_VAR_MIN_MAX(&tbl); break;
994  case 15: fvbb = FLOAT_VAR_MAX_MIN(&tbl); break;
995  case 16: fvbb = FLOAT_VAR_MAX_MAX(&tbl); break;
996  case 17: fvbb = FLOAT_VAR_SIZE_MIN(&tbl); break;
997  case 18: fvbb = FLOAT_VAR_SIZE_MAX(&tbl); break;
998  case 19: fvbb = FLOAT_VAR_DEGREE_SIZE_MIN(&tbl); break;
999  case 20: fvbb = FLOAT_VAR_DEGREE_SIZE_MAX(&tbl); break;
1000  case 21: fvbb = FLOAT_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
1001  case 22: fvbb = FLOAT_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
1002  case 23: fvbb = FLOAT_VAR_ACTION_SIZE_MIN(fab,&tbl); break;
1003  case 24: fvbb = FLOAT_VAR_ACTION_SIZE_MAX(fab,&tbl); break;
1004  case 25: fvbb = FLOAT_VAR_CHB_SIZE_MIN(fcb,&tbl); break;
1005  case 26: fvbb = FLOAT_VAR_CHB_SIZE_MAX(fcb,&tbl); break;
1006  }
1007 
1008  switch (Base::rand(9U)) {
1009  case 0U:
1010  branch(*c, c->x, fvba, fvb); break;
1011  case 1U:
1012  branch(*c, c->x, fvbb, fvb); break;
1013  case 2U:
1014  branch(*c, c->x, tiebreak(fvba,fvbb), fvb); break;
1015  case 3U:
1016  branch(*c, c->x, tiebreak(fvbb,fvba), fvb); break;
1017  case 4U:
1018  branch(*c, c->x, tiebreak(fvba,fvba,fvbb), fvb); break;
1019  case 5U:
1020  branch(*c, c->x, tiebreak(fvba,fvbb,fvbb), fvb); break;
1021  case 6U:
1022  branch(*c, c->x, tiebreak(fvbb,fvba,fvba), fvb); break;
1023  case 7U:
1024  branch(*c, c->x, tiebreak(fvba,fvba,fvbb,fvba), fvb); break;
1025  case 8U:
1026  branch(*c, c->x, tiebreak(fvbb,fvba,fvbb,fvba), fvb); break;
1027  }
1028 
1029  }
1031  results[solutions(c,o,nbSols)].push_back
1032  (RunInfo(float_var_branch_name[vara],
1033  float_var_branch_name[varb],
1034  float_val_branch_name[val],
1035  o));
1036  }
1037  }
1038  }
1039  if (results.size() > 1)
1040  goto failed;
1041  delete root;
1042  return true;
1043  failed:
1044  std::cout << "FAILURE" << std::endl;
1045  for (map<int, vector<RunInfo> >::iterator it = results.begin();
1046  it != results.end(); ++it) {
1047  std::cout << "Number of solutions: " << it->first << std::endl;
1048  for (unsigned int i = 0; i < it->second.size(); ++i)
1049  std::cout << it->second[i] << " ";
1050  std::cout << std::endl;
1051  }
1052 
1053  delete root;
1054  return results.size() == 1;
1055  }
1056 #endif
1057 
1058 }}
1059 
1060 // STATISTICS: test-branch
unsigned int a_d
Create a clone during recomputation if distance is greater than a_d (adaptive distance) ...
Definition: search.hh:757
BoolValBranch BOOL_VAL_RND(Rnd r)
Select random value.
Definition: val.hpp:144
Which values to select for branching first.
Definition: set.hh:1449
int min(void) const
Return minimum of domain.
Definition: bool.hpp:67
IntVarBranch INT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl)
Select variable with largest degree divided by domain size.
Definition: var.hpp:225
IntValBranch INT_VAL_RANGE_MIN(void)
Select the smallest range of the variable domain if it has several ranges, otherwise select values no...
Definition: val.hpp:89
IntTestSpace(IntTestSpace &s)
Constructor for cloning s.
Definition: branch.cpp:84
virtual bool run(void)
Perform test.
Definition: branch.cpp:439
FloatVarBranch FLOAT_VAR_CHB_SIZE_MIN(BranchTbl tbl)
Select variable with smallest CHB Q-score divided by domain size.
Definition: var.hpp:271
Gecode::IntVarArray x
Variables to be tested.
Definition: branch.cpp:73
Recording actions for set variables.
Definition: set.hh:1185
SetVarBranch SET_VAR_CHB_SIZE_MIN(BranchTbl tbl)
Definition: var.hpp:270
SetVarBranch SET_VAR_SIZE_MIN(BranchTbl tbl)
Definition: var.hpp:210
Space for executing Boolean tests.
Definition: branch.cpp:95
IntVarBranch INT_VAR_CHB_SIZE_MAX(IntCHB c, BranchTbl tbl)
Select variable with largest CHB Q-score divided by domain size.
Definition: var.hpp:280
IntVarBranch INT_VAR_NONE(void)
Select first unassigned variable.
Definition: var.hpp:100
Which values to select for branching first.
Definition: float.hh:1821
Gecode::FloatVal dom
Domain of variables.
Definition: branch.hh:133
int arity
Number of variables.
Definition: branch.hh:92
BoolVarBranch BOOL_VAR_NONE(void)
Select first unassigned variable.
Definition: var.hpp:368
FloatValBranch FLOAT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
Definition: val.hpp:64
SetTest(const std::string &s, int a, const Gecode::IntSet &d)
Construct and register test.
Definition: branch.cpp:739
BoolVarBranch BOOL_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
Definition: var.hpp:398
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1657
SetTestSpace(SetTestSpace &s)
Constructor for cloning s.
Definition: branch.cpp:123
virtual void post(Gecode::Space &home, Gecode::SetVarArray &x)=0
Post propagators on variables x.
const char * bool_var_branch_name[]
Names for Boolean variable selections.
Definition: branch.cpp:198
SetTestSpace(int n, Gecode::IntSet &d)
Initialize test space.
Definition: branch.cpp:120
BoolTest(const std::string &s, int a)
Construct and register test.
Definition: branch.cpp:608
Gecode::BoolVarArray x
Variables to be tested.
Definition: branch.cpp:98
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition: branch.cpp:128
Which values to select for branching first.
Definition: int.hh:4686
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:973
const FloatNum max
Largest allowed float value.
Definition: float.hh:848
std::ostream & operator<<(std::ostream &os, const Test::Branch::RunInfo &ri)
Definition: branch.cpp:406
FloatVarBranch FLOAT_VAR_CHB_SIZE_MAX(BranchTbl tbl)
Select variable with largest CHB Q-score divided by domain size.
Definition: var.hpp:281
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition: branch.cpp:89
Recording actions for float variables.
Definition: float.hh:1556
void update(Space &home, VarArray< Var > &a)
Update array to be a clone of array a.
Definition: array.hpp:1060
int nbSols
Maximum number of solutions searched during solving.
Definition: branch.hh:135
static Gecode::Support::RandomGenerator rand
Random number generator.
Definition: test.hh:138
unsigned int c_d
Create a clone after every c_d commits (commit distance)
Definition: search.hh:755
FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
Definition: var.hpp:126
SetVarBranch SET_VAR_MERIT_MAX(SetBranchMerit bm, BranchTbl tbl)
Definition: var.hpp:115
Which values to select for branching first.
Definition: int.hh:4651
Search engine options
Definition: search.hh:748
IntVarBranch INT_VAR_SIZE_MAX(BranchTbl tbl)
Select variable with largest domain size.
Definition: var.hpp:215
Gecode::IntSet dom
Domain of variables.
Definition: branch.hh:75
Which integer variable to select for branching.
Definition: int.hh:4367
double set_merit(const Gecode::Space &, Gecode::SetVar, int)
Test function for branch merit function.
Definition: branch.cpp:301
unsigned int c_d
Definition: branch.cpp:393
virtual bool run(void)
Perform test.
Definition: branch.cpp:744
FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(double d, BranchTbl tbl)
Select variable with smalllest accumulated failure count divided by domain size with decay factor d...
Definition: var.hpp:231
int set_val(const Gecode::Space &, Gecode::SetVar x, int)
Test function for branch value function.
Definition: branch.cpp:320
IntVarBranch INT_VAR_REGRET_MIN_MIN(BranchTbl tbl)
Select variable with smallest min-regret.
Definition: var.hpp:290
IntVarBranch INT_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
Definition: var.hpp:125
BoolVarBranch BOOL_VAR_ACTION_MIN(double d, BranchTbl tbl)
Select variable with lowest action with decay factor d.
Definition: var.hpp:418
virtual T * next(void)
Return next solution (NULL, if none exists or search has been stopped)
Definition: base.hpp:50
IntVarBranch INT_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
Definition: var.hpp:130
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:44
SetVarBranch SET_VAR_DEGREE_SIZE_MAX(BranchTbl tbl)
Definition: var.hpp:225
IntValBranch INT_VAL_RANGE_MAX(void)
Select the largest range of the variable domain if it has several ranges, otherwise select values gre...
Definition: val.hpp:94
IntVarBranch INT_VAR_CHB_SIZE_MIN(IntCHB c, BranchTbl tbl)
Select variable with smallest CHB Q-score divided by domain size.
Definition: var.hpp:270
std::string var
Definition: branch.cpp:392
Integer variable array.
Definition: int.hh:742
IntVarBranch INT_VAR_MERIT_MAX(IntBranchMerit bm, BranchTbl tbl)
Select variable with highest merit according to branch merit function bm.
Definition: var.hpp:115
Which variable to select for branching.
Definition: float.hh:1669
BoolVarBranch BOOL_VAR_MERIT_MIN(BoolBranchMerit bm, BranchTbl tbl)
Select variable with least merit according to branch merit function bm.
Definition: var.hpp:378
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition: branch.cpp:149
const int n_bool_val_branch
Number of Boolean value selections.
Definition: branch.cpp:249
virtual void post(Gecode::Space &home, Gecode::BoolVarArray &x)=0
Post propagators on variables x.
SetValBranch SET_VAL_MED_INC(void)
Definition: val.hpp:69
IntVarBranch INT_VAR_REGRET_MIN_MAX(BranchTbl tbl)
Select variable with largest min-regret.
Definition: var.hpp:295
SetVarBranch SET_VAR_MAX_MAX(BranchTbl tbl)
Definition: var.hpp:205
void print(std::ostream &o) const
Definition: branch.cpp:398
SetValBranch SET_VAL_RND_INC(Rnd r)
Definition: val.hpp:89
virtual bool run(void)
Perform test.
Definition: branch.cpp:613
int arity
Number of variables.
Definition: branch.hh:110
int min(void) const
Return smallest value of range.
Definition: set.hpp:178
double int_merit(const Gecode::Space &, Gecode::IntVar x, int)
Test function for branch merit function.
Definition: branch.cpp:217
SetVarBranch SET_VAR_NONE(void)
Definition: var.hpp:100
FloatValBranch FLOAT_VAL(FloatBranchVal v, FloatBranchCommit c)
Definition: val.hpp:74
BoolTestSpace(BoolTestSpace &s)
Constructor for cloning s.
Definition: branch.cpp:103
FloatVarBranch FLOAT_VAR_ACTION_SIZE_MIN(double d, BranchTbl tbl)
Select variable with smallest action divided by domain size with decay factor d.
Definition: var.hpp:251
double float_merit(const Gecode::Space &, Gecode::FloatVar x, int)
Test function for branch merit function.
Definition: branch.cpp:367
Float variable array.
Definition: float.hh:1031
SetVarBranch SET_VAR_DEGREE_SIZE_MIN(BranchTbl tbl)
Definition: var.hpp:220
void branch(Home home, SetVar x, SetValBranch vals, SetVarValPrint vvp)
Branch over x with value selection vals.
Definition: branch.cpp:105
Computation spaces.
Definition: core.hpp:1668
FloatVarBranch FLOAT_VAR_NONE(void)
Select first unassigned variable.
Definition: var.hpp:101
FloatVarBranch FLOAT_VAR_DEGREE_MIN(BranchTbl tbl)
Select variable with smallest degree.
Definition: var.hpp:121
FloatVarBranch FLOAT_VAR_MERIT_MIN(FloatBranchMerit bm, BranchTbl tbl)
Select variable with least merit according to branch merit function bm.
Definition: var.hpp:106
IntValBranch INT_VAL_RND(Rnd r)
Select random value.
Definition: val.hpp:74
FloatValBranch FLOAT_VAL_SPLIT_RND(Rnd r)
Select values randomly which are not greater or not smaller than mean of largest and smallest value...
Definition: val.hpp:69
Iterator for the unknown ranges of a set variable.
Definition: set.hh:338
Gecode::IntSet d(v, 7)
IntVarBranch INT_VAR_MAX_MAX(BranchTbl tbl)
Select variable with largest max.
Definition: var.hpp:205
const int n_bool_var_branch
Number of integer variable selections.
Definition: branch.cpp:214
Gecode::FloatVal c(-8, 8)
FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl)
Select variable with largest domain size.
Definition: var.hpp:216
SetVarBranch SET_VAR_AFC_MAX(double d, BranchTbl tbl)
Definition: var.hpp:140
const char * int_val_branch_name[]
Names for integer value selections.
Definition: branch.cpp:225
IntVarBranch INT_VAR_ACTION_MAX(double d, BranchTbl tbl)
Select variable with highest action with decay factor d.
Definition: var.hpp:160
const FloatNum min
Smallest allowed float value.
Definition: float.hh:850
BoolValBranch BOOL_VAL_MIN(void)
Select smallest value.
Definition: val.hpp:134
IntVarBranch INT_VAR_AFC_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count divided by domain size with decay factor d...
Definition: var.hpp:240
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl)
Select variable with smallest degree divided by domain size.
Definition: var.hpp:221
Gecode::IntArgs i(4, 1, 2, 3, 4)
FloatNum n
The middle value for branching.
Definition: float.hh:1466
double bool_merit(const Gecode::Space &, Gecode::BoolVar x, int)
Test function for branch merit function.
Definition: branch.cpp:221
BoolValBranch BOOL_VAL_MAX(void)
Select largest value.
Definition: val.hpp:139
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:238
SetVarBranch SET_VAR_CHB_SIZE_MAX(BranchTbl tbl)
Definition: var.hpp:280
SetVarBranch SET_VAR_DEGREE_MIN(BranchTbl tbl)
Definition: var.hpp:120
Value description class for branching.
Definition: float.hh:1463
SetVarBranch SET_VAR_DEGREE_MAX(BranchTbl tbl)
Definition: var.hpp:125
IntVarBranch INT_VAR_MIN_MIN(BranchTbl tbl)
Select variable with smallest min.
Definition: var.hpp:190
IntTest(const std::string &s, int a, const Gecode::IntSet &d)
Construct and register test.
Definition: branch.cpp:434
BoolVarBranch BOOL_VAR_DEGREE_MIN(BranchTbl tbl)
Select variable with smallest degree.
Definition: var.hpp:388
Space * clone(CloneStatistics &stat=unused_clone) const
Clone space.
Definition: core.hpp:3144
SetVarBranch SET_VAR_CHB_MAX(BranchTbl tbl)
Definition: var.hpp:180
const unsigned int a_d
Create a clone during recomputation if distance is greater than a_d (adaptive distance) ...
Definition: search.hh:117
IntVarBranch INT_VAR_MERIT_MIN(IntBranchMerit bm, BranchTbl tbl)
Select variable with least merit according to branch merit function bm.
Definition: var.hpp:110
Gecode::IntVarBranch varb
Definition: branch.cpp:75
BoolVarBranch BOOL_VAR_CHB_MAX(BoolCHB c, BranchTbl tbl)
Select variable with largest CHB Q-score.
Definition: var.hpp:448
IntValBranch INT_VAL_MIN(void)
Select smallest value.
Definition: val.hpp:59
FloatTestSpace(int n, Gecode::FloatVal &d)
Initialize test space.
Definition: branch.cpp:141
const char * int_var_branch_name[]
Names for integer variable selections.
Definition: branch.cpp:161
unsigned int degree(void) const
Return degree (number of subscribed propagators and advisors)
Definition: var.hpp:113
IntValBranch INT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
Definition: val.hpp:84
bool l
Whether to try the lower or upper half first.
Definition: float.hh:1468
Base class for all tests to be run
Definition: test.hh:107
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition: branch.cpp:108
IntVarBranch INT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
Definition: var.hpp:105
struct Gecode::Space::@58::@60 c
Data available only during copying.
Recording actions for Boolean variables.
Definition: int.hh:4204
Recording CHB for set variables.
Definition: set.hh:1237
IntValBranch INT_VAL(IntBranchVal v, IntBranchCommit c)
Select value as defined by the value function v and commit function c Uses a commit function as defau...
Definition: val.hpp:99
LDSB< TieBreak > tiebreak("TieBreak")
Gecode::IntSet dom
Domain of variables.
Definition: branch.hh:112
Which Boolean variable to select for branching.
Definition: int.hh:4453
FloatValBranch FLOAT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
Definition: val.hpp:59
Integer sets.
Definition: int.hh:174
Space for executing Set tests.
Definition: branch.cpp:115
SetVarBranch SET_VAR_AFC_MIN(double d, BranchTbl tbl)
Definition: var.hpp:130
IntVarBranch INT_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
Definition: var.hpp:140
FloatVarBranch FLOAT_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
Definition: var.hpp:131
SetVarBranch SET_VAR_RND(Rnd r)
Definition: var.hpp:105
FloatNum med(void) const
Return median of domain.
Definition: float.hpp:67
Recording CHB for integer variables.
Definition: int.hh:4255
Gecode::IntValBranch val
Varlue selection criterion.
Definition: branch.cpp:77
SetVarBranch SET_VAR_MERIT_MIN(SetBranchMerit bm, BranchTbl tbl)
Definition: var.hpp:110
FloatVarBranch FLOAT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
Definition: var.hpp:116
SetVarBranch SET_VAR_MIN_MAX(BranchTbl tbl)
Definition: var.hpp:195
SetValBranch SET_VAL_MIN_EXC(void)
Definition: val.hpp:64
Passing integer arguments.
Definition: int.hh:608
SetValBranch SET_VAL_MIN_INC(void)
Definition: val.hpp:59
Recording CHB for float variables.
Definition: float.hh:1608
Space for executing Float tests.
Definition: branch.cpp:136
FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl)
Select variable with smallest domain size.
Definition: var.hpp:211
Boolean variable array.
Definition: int.hh:787
Boolean integer variables.
Definition: int.hh:492
FloatVarBranch FLOAT_VAR_MIN_MAX(BranchTbl tbl)
Select variable with largest min.
Definition: var.hpp:196
SetValBranch SET_VAL_MAX_EXC(void)
Definition: val.hpp:84
virtual bool run(void)
Perform test.
Definition: branch.cpp:907
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)=0
Post propagators on variables x.
IntVarBranch INT_VAR_DEGREE_MIN(BranchTbl tbl)
Select variable with smallest degree.
Definition: var.hpp:120
IntValBranch INT_VAL_MAX(void)
Select largest value.
Definition: val.hpp:69
IntVarBranch INT_VAR_CHB_MIN(IntCHB c, BranchTbl tbl)
Select variable with lowest CHB Q-score.
Definition: var.hpp:170
SetValBranch SET_VAL_MAX_INC(void)
Definition: val.hpp:79
General test support.
Definition: afc.cpp:43
struct Gecode::@585::NNF::@62::@63 b
For binary nodes (and, or, eqv)
SetVarBranch SET_VAR_MAX_MIN(BranchTbl tbl)
Definition: var.hpp:200
IntVarBranch INT_VAR_SIZE_MIN(BranchTbl tbl)
Select variable with smallest domain size.
Definition: var.hpp:210
SetVarBranch SET_VAR_SIZE_MAX(BranchTbl tbl)
Definition: var.hpp:215
Space for executing integer tests.
Definition: branch.cpp:70
BoolVarBranch BOOL_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
Definition: var.hpp:408
Float value type.
Definition: float.hh:338
IntValBranch INT_VALUES_MIN(void)
Try all values starting from smallest.
Definition: val.hpp:104
SetValBranch SET_VAL_MED_EXC(void)
Definition: val.hpp:74
RunInfo(const std::string &vara, const std::string &varb, const std::string &valname, const Gecode::Search::Options &o)
Definition: branch.cpp:394
BoolVarBranch BOOL_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
Definition: var.hpp:393
Set variables
Definition: set.hh:131
SetValBranch SET_VAL_RND_EXC(Rnd r)
Definition: val.hpp:94
Space(void)
Default constructor.
Definition: core.cpp:115
struct Gecode::@585::NNF::@62::@64 a
For atomic nodes.
Information about one test-run.
Definition: branch.cpp:390
int min(void) const
Return minimum of domain.
Definition: int.hpp:66
IntVarBranch INT_VAR_MIN_MAX(BranchTbl tbl)
Select variable with largest min.
Definition: var.hpp:195
IntValBranch INT_VALUES_MAX(void)
Try all values starting from largest.
Definition: val.hpp:109
Gecode::IntVarBranch vara
Variable selection criteria.
Definition: branch.cpp:75
Region r
Definition: region.cpp:69
SetVarBranch SET_VAR_AFC_SIZE_MIN(double d, BranchTbl tbl)
Definition: var.hpp:230
FloatVarBranch FLOAT_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
Definition: var.hpp:141
Integer variables.
Definition: int.hh:351
Gecode::SetVarArray x
Variables to be tested.
Definition: branch.cpp:118
IntVarBranch INT_VAR_ACTION_MIN(double d, BranchTbl tbl)
Select variable with lowest action with decay factor d.
Definition: var.hpp:150
BoolVarBranch BOOL_VAR_ACTION_MAX(double d, BranchTbl tbl)
Select variable with highest action with decay factor d.
Definition: var.hpp:428
IntVarBranch INT_VAR_AFC_SIZE_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count divided by domain size with decay factor d...
Definition: var.hpp:230
IntVarBranch INT_VAR_REGRET_MAX_MIN(BranchTbl tbl)
Select variable with smallest max-regret.
Definition: var.hpp:300
FloatVarBranch FLOAT_VAR_ACTION_MIN(double d, BranchTbl tbl)
Select variable with lowest action with decay factor d.
Definition: var.hpp:151
int bab(Space *root, const Gist::Options &opt)
Create a new stand-alone Gist for branch-and-bound search of root.
Definition: gist.hpp:212
IntValBranch INT_VAL_MED(void)
Select greatest value not greater than the median.
Definition: val.hpp:64
IntVarBranch INT_VAR_ACTION_SIZE_MIN(double d, BranchTbl tbl)
Select variable with smallest action divided by domain size with decay factor d.
Definition: var.hpp:250
IntVarBranch INT_VAR_MAX_MIN(BranchTbl tbl)
Select variable with smallest max.
Definition: var.hpp:200
FloatVarBranch FLOAT_VAR_CHB_MIN(BranchTbl tbl)
Select variable with lowest CHB Q-score.
Definition: var.hpp:171
IntVarBranch INT_VAR_REGRET_MAX_MAX(BranchTbl tbl)
Select variable with largest max-regret.
Definition: var.hpp:305
FloatTestSpace(FloatTestSpace &s)
Constructor for cloning s.
Definition: branch.cpp:144
SpaceStatus status(StatusStatistics &stat=unused_status)
Query space status.
Definition: core.cpp:229
int arity
Number of variables.
Definition: branch.hh:73
int bool_val(const Gecode::Space &, Gecode::BoolVar x, int)
Test function for branch value function.
Definition: branch.cpp:256
BoolVarBranch BOOL_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
Definition: var.hpp:373
IntVarBranch INT_VAR_CHB_MAX(IntCHB c, BranchTbl tbl)
Select variable with largest CHB Q-score.
Definition: var.hpp:180
Recording CHB for Boolean variables.
Definition: int.hh:4299
BoolTestSpace(int n)
Initialize test space.
Definition: branch.cpp:100
Float variables.
Definition: float.hh:874
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)=0
Post propagators on variables x.
SetValBranch SET_VAL(SetBranchVal v, SetBranchCommit c)
Select value as defined by the value function v and commit function c.
Definition: val.hpp:99
FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl)
Select variable with smallest min.
Definition: var.hpp:191
Set variable array
Definition: set.hh:572
IntValBranch INT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
Definition: val.hpp:79
BoolValBranch BOOL_VAL(BoolBranchVal v, BoolBranchCommit c)
Select value as defined by the value function v and commit function c Uses a commit function as defau...
Definition: val.hpp:149
Gecode toplevel namespace
const int n_int_val_branch
Number of integer value selections.
Definition: branch.cpp:239
IntTestSpace(int n, Gecode::IntSet &d)
Initialize test space.
Definition: branch.cpp:79
BoolVarBranch BOOL_VAR_CHB_MIN(BoolCHB c, BranchTbl tbl)
Select variable with lowest CHB Q-score.
Definition: var.hpp:438
SetVarBranch SET_VAR_ACTION_MAX(double d, BranchTbl tbl)
Definition: var.hpp:160
SetVarBranch SET_VAR_MIN_MIN(BranchTbl tbl)
Definition: var.hpp:190
SetVarBranch SET_VAR_CHB_MIN(BranchTbl tbl)
Definition: var.hpp:170
BoolVarBranch BOOL_VAR_MERIT_MAX(BoolBranchMerit bm, BranchTbl tbl)
Select variable with highest merit according to branch merit function bm.
Definition: var.hpp:383
FloatVarBranch FLOAT_VAR_ACTION_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest action divided by domain size with decay factor d.
Definition: var.hpp:261
Which variable to select for branching.
Definition: set.hh:1298
Random number generator.
Definition: rnd.hpp:46
IntVarBranch INT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl)
Select variable with smallest degree divided by domain size.
Definition: var.hpp:220
Gecode::FloatNumBranch float_val(const Gecode::Space &, Gecode::FloatVar x, int)
Test function for branch value function.
Definition: branch.cpp:381
FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count divided by domain size with decay factor d...
Definition: var.hpp:241
SetVarBranch SET_VAR_AFC_SIZE_MAX(double d, BranchTbl tbl)
Definition: var.hpp:240
FloatTest(const std::string &s, int a, const Gecode::FloatVal &d, int nbs)
Construct and register test.
Definition: branch.cpp:902
FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl)
Select variable with largest max.
Definition: var.hpp:206
const char * bool_val_branch_name[]
Names for Boolean value selections.
Definition: branch.cpp:242
Gecode::FloatVarArray x
Variables to be tested.
Definition: branch.cpp:139
FloatVarBranch FLOAT_VAR_MERIT_MAX(FloatBranchMerit bm, BranchTbl tbl)
Select variable with highest merit according to branch merit function bm.
Definition: var.hpp:111
double tbl(const Gecode::Space &, double w, double b)
Test function for tie-break limit function.
Definition: branch.cpp:65
FloatVarBranch FLOAT_VAR_ACTION_MAX(double d, BranchTbl tbl)
Select variable with highest action with decay factor d.
Definition: var.hpp:161
SetVarBranch SET_VAR_ACTION_SIZE_MAX(double d, BranchTbl tbl)
Definition: var.hpp:260
FloatVarBranch FLOAT_VAR_MAX_MIN(BranchTbl tbl)
Select variable with smallest max.
Definition: var.hpp:201
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl)
Select variable with largest degree divided by domain size.
Definition: var.hpp:226
Depth-first search engine.
Definition: search.hh:1039
SetVarBranch SET_VAR_ACTION_SIZE_MIN(double d, BranchTbl tbl)
Definition: var.hpp:250
Recording actions for integer variables.
Definition: int.hh:4159
int arity
Number of variables.
Definition: branch.hh:131
int solutions(TestSpace *c, Gecode::Search::Options &o, int maxNbSol=-1)
Find number of solutions.
Definition: branch.cpp:416
IntVarBranch INT_VAR_ACTION_SIZE_MAX(double d, BranchTbl tbl)
Select variable with largest action divided by domain size with decay factor d.
Definition: var.hpp:260
int int_val(const Gecode::Space &, Gecode::IntVar x, int)
Test function for branch value function.
Definition: branch.cpp:252
FloatVarBranch FLOAT_VAR_CHB_MAX(BranchTbl tbl)
Select variable with highest CHB Q-score.
Definition: var.hpp:181
const int n_int_var_branch
Number of integer variable selections.
Definition: branch.cpp:195
SetVarBranch SET_VAR_ACTION_MIN(double d, BranchTbl tbl)
Definition: var.hpp:150