Generated on Sat Jun 2 2018 07:17:44 for Gecode by doxygen 1.8.13
flatzinc.cpp
Go to the documentation of this file.
1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /*
3  * Main authors:
4  * Guido Tack <tack@gecode.org>
5  *
6  * Contributing authors:
7  * Gabriel Hjort Blindell <gabriel.hjort.blindell@gmail.com>
8  *
9  * Copyright:
10  * Guido Tack, 2007-2012
11  * Gabriel Hjort Blindell, 2012
12  *
13  * This file is part of Gecode, the generic constraint
14  * development environment:
15  * http://www.gecode.org
16  *
17  * Permission is hereby granted, free of charge, to any person obtaining
18  * a copy of this software and associated documentation files (the
19  * "Software"), to deal in the Software without restriction, including
20  * without limitation the rights to use, copy, modify, merge, publish,
21  * distribute, sublicense, and/or sell copies of the Software, and to
22  * permit persons to whom the Software is furnished to do so, subject to
23  * the following conditions:
24  *
25  * The above copyright notice and this permission notice shall be
26  * included in all copies or substantial portions of the Software.
27  *
28  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
32  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
33  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
34  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35  *
36  */
37 
38 #include <gecode/flatzinc.hh>
42 
43 #include <gecode/search.hh>
44 
45 #include <vector>
46 #include <string>
47 #include <sstream>
48 #include <limits>
49 #include <unordered_set>
50 
51 
52 namespace std {
53 
55  template<> struct hash<Gecode::TupleSet> {
57  forceinline size_t
58  operator()(const Gecode::TupleSet& x) const {
59  return x.hash();
60  }
61  };
62 
64  template<> struct hash<Gecode::SharedArray<int> > {
66  forceinline size_t
68  size_t seed = static_cast<size_t>(x.size());
69  for (int i=x.size(); i--; )
70  Gecode::cmb_hash(seed, x[i]);
71  return seed;
72  }
73  };
74 
76  template<> struct hash<Gecode::DFA> {
78  forceinline size_t operator()(const Gecode::DFA& d) const {
79  return d.hash();
80  }
81  };
82 
83 }
84 
85 namespace Gecode { namespace FlatZinc {
86 
87  // Default random number generator
88  Rnd defrnd(0);
89 
102  class AuxVarBrancher : public Brancher {
103  protected:
105  bool done;
108  IntValBranch int_valsel0,
109  TieBreak<BoolVarBranch> bool_varsel0,
110  BoolValBranch bool_valsel0
111 #ifdef GECODE_HAS_SET_VARS
112  ,
113  SetVarBranch set_varsel0,
114  SetValBranch set_valsel0
115 #endif
117  ,
118  TieBreak<FloatVarBranch> float_varsel0,
119  FloatValBranch float_valsel0
120 #endif
121  )
122  : Brancher(home), done(false),
123  int_varsel(int_varsel0), int_valsel(int_valsel0),
124  bool_varsel(bool_varsel0), bool_valsel(bool_valsel0)
125 #ifdef GECODE_HAS_SET_VARS
126  , set_varsel(set_varsel0), set_valsel(set_valsel0)
127 #endif
128 #ifdef GECODE_HAS_FLOAT_VARS
129  , float_varsel(float_varsel0), float_valsel(float_valsel0)
130 #endif
131  {}
134  : Brancher(home, b), done(b.done) {}
135 
137  class Choice : public Gecode::Choice {
138  public:
140  bool fail;
142  Choice(const Brancher& b, bool fail0)
143  : Gecode::Choice(b,1), fail(fail0) {}
145  virtual size_t size(void) const {
146  return sizeof(Choice);
147  }
149  virtual void archive(Archive& e) const {
151  e.put(fail);
152  }
153  };
154 
159 #ifdef GECODE_HAS_SET_VARS
162 #endif
163 #ifdef GECODE_HAS_FLOAT_VARS
166 #endif
167 
168  public:
170  virtual bool status(const Space& _home) const {
171  if (done) return false;
172  const FlatZincSpace& home = static_cast<const FlatZincSpace&>(_home);
173  for (int i=0; i<home.iv_aux.size(); i++)
174  if (!home.iv_aux[i].assigned()) return true;
175  for (int i=0; i<home.bv_aux.size(); i++)
176  if (!home.bv_aux[i].assigned()) return true;
177 #ifdef GECODE_HAS_SET_VARS
178  for (int i=0; i<home.sv_aux.size(); i++)
179  if (!home.sv_aux[i].assigned()) return true;
180 #endif
181 #ifdef GECODE_HAS_FLOAT_VARS
182  for (int i=0; i<home.fv_aux.size(); i++)
183  if (!home.fv_aux[i].assigned()) return true;
184 #endif
185  // No non-assigned variables left
186  return false;
187  }
189  virtual Choice* choice(Space& home) {
190  done = true;
191  FlatZincSpace& fzs = static_cast<FlatZincSpace&>(*home.clone());
192  fzs.needAuxVars = false;
193  branch(fzs,fzs.iv_aux,int_varsel,int_valsel);
194  branch(fzs,fzs.bv_aux,bool_varsel,bool_valsel);
195 #ifdef GECODE_HAS_SET_VARS
196  branch(fzs,fzs.sv_aux,set_varsel,set_valsel);
197 #endif
198 #ifdef GECODE_HAS_FLOAT_VARS
199  branch(fzs,fzs.fv_aux,float_varsel,float_valsel);
200 #endif
201  Search::Options opt; opt.clone = false;
202  FlatZincSpace* sol = dfs(&fzs, opt);
203  if (sol) {
204  delete sol;
205  return new Choice(*this,false);
206  } else {
207  return new Choice(*this,true);
208  }
209  }
211  virtual Choice* choice(const Space&, Archive& e) {
212  bool fail; e >> fail;
213  return new Choice(*this, fail);
214  }
216  virtual ExecStatus commit(Space&, const Gecode::Choice& c, unsigned int) {
217  return static_cast<const Choice&>(c).fail ? ES_FAILED : ES_OK;
218  }
220  virtual void print(const Space&, const Gecode::Choice& c,
221  unsigned int,
222  std::ostream& o) const {
223  o << "FlatZinc("
224  << (static_cast<const Choice&>(c).fail ? "fail" : "ok")
225  << ")";
226  }
228  virtual Actor* copy(Space& home) {
229  return new (home) AuxVarBrancher(home, *this);
230  }
232  static void post(Home home,
233  TieBreak<IntVarBranch> int_varsel,
234  IntValBranch int_valsel,
235  TieBreak<BoolVarBranch> bool_varsel,
236  BoolValBranch bool_valsel
237 #ifdef GECODE_HAS_SET_VARS
238  ,
239  SetVarBranch set_varsel,
240  SetValBranch set_valsel
241 #endif
243  ,
244  TieBreak<FloatVarBranch> float_varsel,
245  FloatValBranch float_valsel
246 #endif
247  ) {
248  (void) new (home) AuxVarBrancher(home, int_varsel, int_valsel,
249  bool_varsel, bool_valsel
250 #ifdef GECODE_HAS_SET_VARS
251  , set_varsel, set_valsel
252 #endif
253 #ifdef GECODE_HAS_FLOAT_VARS
254  , float_varsel, float_valsel
255 #endif
256  );
257  }
259  virtual size_t dispose(Space&) {
260  return sizeof(*this);
261  }
262  };
263 
265  private:
266  struct BI {
267  std::string r0;
268  std::string r1;
269  std::vector<std::string> n;
270  BI(void) : r0(""), r1(""), n(0) {}
271  BI(const std::string& r00, const std::string& r10,
272  const std::vector<std::string>& n0)
273  : r0(r00), r1(r10), n(n0) {}
274  };
275  std::vector<BI> v;
276  BranchInformationO(std::vector<BI> v0) : v(v0) {}
277  public:
279  virtual ~BranchInformationO(void) {}
280  virtual SharedHandle::Object* copy(void) const {
281  return new BranchInformationO(v);
282  }
285  const std::string& rel0,
286  const std::string& rel1,
287  const std::vector<std::string>& n) {
288  v.resize(std::max(static_cast<unsigned int>(v.size()),bg.id()+1));
289  v[bg.id()] = BI(rel0,rel1,n);
290  }
292  void print(const Brancher& b,
293  unsigned int a, int i, int n, std::ostream& o) const {
294  const BI& bi = v[b.group().id()];
295  o << bi.n[i] << " " << (a==0 ? bi.r0 : bi.r1) << " " << n;
296  }
297 #ifdef GECODE_HAS_FLOAT_VARS
298  void print(const Brancher& b,
299  unsigned int a, int i, const FloatNumBranch& nl,
300  std::ostream& o) const {
301  const BI& bi = v[b.group().id()];
302  o << bi.n[i] << " "
303  << (((a == 0) == nl.l) ? "<=" : ">=") << nl.n;
304  }
305 #endif
306  };
307 
308  BranchInformation::BranchInformation(void)
309  : SharedHandle(NULL) {}
310 
312  : SharedHandle(bi) {}
313 
314  void
316  assert(object() == NULL);
317  object(new BranchInformationO());
318  }
319 
320  void
322  const std::string& rel0,
323  const std::string& rel1,
324  const std::vector<std::string>& n) {
325  static_cast<BranchInformationO*>(object())->add(bg,rel0,rel1,n);
326  }
327  void
328  BranchInformation::print(const Brancher& b, unsigned int a, int i,
329  int n, std::ostream& o) const {
330  static_cast<const BranchInformationO*>(object())->print(b,a,i,n,o);
331  }
332 #ifdef GECODE_HAS_FLOAT_VARS
333  void
334  BranchInformation::print(const Brancher& b, unsigned int a, int i,
335  const FloatNumBranch& nl, std::ostream& o) const {
336  static_cast<const BranchInformationO*>(object())->print(b,a,i,nl,o);
337  }
338 #endif
339  template<class Var>
340  void varValPrint(const Space &home, const Brancher& b,
341  unsigned int a,
342  Var, int i, const int& n,
343  std::ostream& o) {
344  static_cast<const FlatZincSpace&>(home).branchInfo.print(b,a,i,n,o);
345  }
346 
347 #ifdef GECODE_HAS_FLOAT_VARS
348  void varValPrintF(const Space &home, const Brancher& b,
349  unsigned int a,
350  FloatVar, int i, const FloatNumBranch& nl,
351  std::ostream& o) {
352  static_cast<const FlatZincSpace&>(home).branchInfo.print(b,a,i,nl,o);
353  }
354 #endif
355 
357  if (vs->assigned) {
358  return IntSet(vs->i,vs->i);
359  }
360  if (vs->domain()) {
361  AST::SetLit* sl = vs->domain.some();
362  if (sl->interval) {
363  return IntSet(sl->min, sl->max);
364  } else {
365  int* newdom = heap.alloc<int>(static_cast<unsigned long int>(sl->s.size()));
366  for (int i=sl->s.size(); i--;)
367  newdom[i] = sl->s[i];
368  IntSet ret(newdom, sl->s.size());
369  heap.free(newdom, static_cast<unsigned long int>(sl->s.size()));
370  return ret;
371  }
372  }
374  }
375 
376  int vs2bsl(BoolVarSpec* bs) {
377  if (bs->assigned) {
378  return bs->i;
379  }
380  if (bs->domain()) {
381  AST::SetLit* sl = bs->domain.some();
382  assert(sl->interval);
383  return std::min(1, std::max(0, sl->min));
384  }
385  return 0;
386  }
387 
388  int vs2bsh(BoolVarSpec* bs) {
389  if (bs->assigned) {
390  return bs->i;
391  }
392  if (bs->domain()) {
393  AST::SetLit* sl = bs->domain.some();
394  assert(sl->interval);
395  return std::max(0, std::min(1, sl->max));
396  }
397  return 1;
398  }
399 
400  TieBreak<IntVarBranch> ann2ivarsel(AST::Node* ann, Rnd rnd, double decay) {
401  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
402  if (s->id == "input_order")
404  if (s->id == "first_fail")
406  if (s->id == "anti_first_fail")
408  if (s->id == "smallest")
410  if (s->id == "largest")
412  if (s->id == "occurrence")
414  if (s->id == "max_regret")
416  if (s->id == "most_constrained")
419  if (s->id == "random") {
420  return TieBreak<IntVarBranch>(INT_VAR_RND(rnd));
421  }
422  if (s->id == "dom_w_deg") {
424  }
425  if (s->id == "afc_min")
427  if (s->id == "afc_max")
429  if (s->id == "afc_size_min")
431  if (s->id == "afc_size_max") {
433  }
434  if (s->id == "action_min")
436  if (s->id == "action_max")
438  if (s->id == "action_size_min")
440  if (s->id == "action_size_max")
442  }
443  std::cerr << "Warning, ignored search annotation: ";
444  ann->print(std::cerr);
445  std::cerr << std::endl;
447  }
448 
449  IntValBranch ann2ivalsel(AST::Node* ann, std::string& r0, std::string& r1,
450  Rnd rnd) {
451  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
452  if (s->id == "indomain_min") {
453  r0 = "="; r1 = "!=";
454  return INT_VAL_MIN();
455  }
456  if (s->id == "indomain_max") {
457  r0 = "="; r1 = "!=";
458  return INT_VAL_MAX();
459  }
460  if (s->id == "indomain_median") {
461  r0 = "="; r1 = "!=";
462  return INT_VAL_MED();
463  }
464  if (s->id == "indomain_split") {
465  r0 = "<="; r1 = ">";
466  return INT_VAL_SPLIT_MIN();
467  }
468  if (s->id == "indomain_reverse_split") {
469  r0 = ">"; r1 = "<=";
470  return INT_VAL_SPLIT_MAX();
471  }
472  if (s->id == "indomain_random") {
473  r0 = "="; r1 = "!=";
474  return INT_VAL_RND(rnd);
475  }
476  if (s->id == "indomain") {
477  r0 = "="; r1 = "=";
478  return INT_VALUES_MIN();
479  }
480  if (s->id == "indomain_middle") {
481  std::cerr << "Warning, replacing unsupported annotation "
482  << "indomain_middle with indomain_median" << std::endl;
483  r0 = "="; r1 = "!=";
484  return INT_VAL_MED();
485  }
486  if (s->id == "indomain_interval") {
487  std::cerr << "Warning, replacing unsupported annotation "
488  << "indomain_interval with indomain_split" << std::endl;
489  r0 = "<="; r1 = ">";
490  return INT_VAL_SPLIT_MIN();
491  }
492  }
493  std::cerr << "Warning, ignored search annotation: ";
494  ann->print(std::cerr);
495  std::cerr << std::endl;
496  r0 = "="; r1 = "!=";
497  return INT_VAL_MIN();
498  }
499 
501  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
502  if (s->id == "indomain_min")
503  return INT_ASSIGN_MIN();
504  if (s->id == "indomain_max")
505  return INT_ASSIGN_MAX();
506  if (s->id == "indomain_median")
507  return INT_ASSIGN_MED();
508  if (s->id == "indomain_random") {
509  return INT_ASSIGN_RND(rnd);
510  }
511  }
512  std::cerr << "Warning, ignored search annotation: ";
513  ann->print(std::cerr);
514  std::cerr << std::endl;
515  return INT_ASSIGN_MIN();
516  }
517 
519  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
520  if ((s->id == "input_order") ||
521  (s->id == "first_fail") ||
522  (s->id == "anti_first_fail") ||
523  (s->id == "smallest") ||
524  (s->id == "largest") ||
525  (s->id == "max_regret"))
527  if ((s->id == "occurrence") ||
528  (s->id == "most_constrained"))
530  if (s->id == "random")
532  if ((s->id == "afc_min") ||
533  (s->id == "afc_size_min"))
535  if ((s->id == "afc_max") ||
536  (s->id == "afc_size_max") ||
537  (s->id == "dom_w_deg"))
539  if ((s->id == "action_min") &&
540  (s->id == "action_size_min"))
542  if ((s->id == "action_max") ||
543  (s->id == "action_size_max"))
545  }
546  std::cerr << "Warning, ignored search annotation: ";
547  ann->print(std::cerr);
548  std::cerr << std::endl;
550  }
551 
552  BoolValBranch ann2bvalsel(AST::Node* ann, std::string& r0, std::string& r1,
553  Rnd rnd) {
554  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
555  if (s->id == "indomain_min") {
556  r0 = "="; r1 = "!=";
557  return BOOL_VAL_MIN();
558  }
559  if (s->id == "indomain_max") {
560  r0 = "="; r1 = "!=";
561  return BOOL_VAL_MAX();
562  }
563  if (s->id == "indomain_median") {
564  r0 = "="; r1 = "!=";
565  return BOOL_VAL_MIN();
566  }
567  if (s->id == "indomain_split") {
568  r0 = "<="; r1 = ">";
569  return BOOL_VAL_MIN();
570  }
571  if (s->id == "indomain_reverse_split") {
572  r0 = ">"; r1 = "<=";
573  return BOOL_VAL_MAX();
574  }
575  if (s->id == "indomain_random") {
576  r0 = "="; r1 = "!=";
577  return BOOL_VAL_RND(rnd);
578  }
579  if (s->id == "indomain") {
580  r0 = "="; r1 = "=";
581  return BOOL_VAL_MIN();
582  }
583  if (s->id == "indomain_middle") {
584  std::cerr << "Warning, replacing unsupported annotation "
585  << "indomain_middle with indomain_median" << std::endl;
586  r0 = "="; r1 = "!=";
587  return BOOL_VAL_MIN();
588  }
589  if (s->id == "indomain_interval") {
590  std::cerr << "Warning, replacing unsupported annotation "
591  << "indomain_interval with indomain_split" << std::endl;
592  r0 = "<="; r1 = ">";
593  return BOOL_VAL_MIN();
594  }
595  }
596  std::cerr << "Warning, ignored search annotation: ";
597  ann->print(std::cerr);
598  std::cerr << std::endl;
599  r0 = "="; r1 = "!=";
600  return BOOL_VAL_MIN();
601  }
602 
604  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
605  if ((s->id == "indomain_min") ||
606  (s->id == "indomain_median"))
607  return BOOL_ASSIGN_MIN();
608  if (s->id == "indomain_max")
609  return BOOL_ASSIGN_MAX();
610  if (s->id == "indomain_random") {
611  return BOOL_ASSIGN_RND(rnd);
612  }
613  }
614  std::cerr << "Warning, ignored search annotation: ";
615  ann->print(std::cerr);
616  std::cerr << std::endl;
617  return BOOL_ASSIGN_MIN();
618  }
619 
620 #ifdef GECODE_HAS_SET_VARS
621  SetVarBranch ann2svarsel(AST::Node* ann, Rnd rnd, double decay) {
622  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
623  if (s->id == "input_order")
624  return SET_VAR_NONE();
625  if (s->id == "first_fail")
626  return SET_VAR_SIZE_MIN();
627  if (s->id == "anti_first_fail")
628  return SET_VAR_SIZE_MAX();
629  if (s->id == "smallest")
630  return SET_VAR_MIN_MIN();
631  if (s->id == "largest")
632  return SET_VAR_MAX_MAX();
633  if (s->id == "afc_min")
634  return SET_VAR_AFC_MIN(decay);
635  if (s->id == "afc_max")
636  return SET_VAR_AFC_MAX(decay);
637  if (s->id == "afc_size_min")
638  return SET_VAR_AFC_SIZE_MIN(decay);
639  if (s->id == "afc_size_max")
640  return SET_VAR_AFC_SIZE_MAX(decay);
641  if (s->id == "action_min")
642  return SET_VAR_ACTION_MIN(decay);
643  if (s->id == "action_max")
644  return SET_VAR_ACTION_MAX(decay);
645  if (s->id == "action_size_min")
646  return SET_VAR_ACTION_SIZE_MIN(decay);
647  if (s->id == "action_size_max")
648  return SET_VAR_ACTION_SIZE_MAX(decay);
649  if (s->id == "random") {
650  return SET_VAR_RND(rnd);
651  }
652  }
653  std::cerr << "Warning, ignored search annotation: ";
654  ann->print(std::cerr);
655  std::cerr << std::endl;
656  return SET_VAR_NONE();
657  }
658 
659  SetValBranch ann2svalsel(AST::Node* ann, std::string r0, std::string r1,
660  Rnd rnd) {
661  (void) rnd;
662  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
663  if (s->id == "indomain_min") {
664  r0 = "in"; r1 = "not in";
665  return SET_VAL_MIN_INC();
666  }
667  if (s->id == "indomain_max") {
668  r0 = "in"; r1 = "not in";
669  return SET_VAL_MAX_INC();
670  }
671  if (s->id == "outdomain_min") {
672  r1 = "in"; r0 = "not in";
673  return SET_VAL_MIN_EXC();
674  }
675  if (s->id == "outdomain_max") {
676  r1 = "in"; r0 = "not in";
677  return SET_VAL_MAX_EXC();
678  }
679  }
680  std::cerr << "Warning, ignored search annotation: ";
681  ann->print(std::cerr);
682  std::cerr << std::endl;
683  r0 = "in"; r1 = "not in";
684  return SET_VAL_MIN_INC();
685  }
686 #endif
687 
688 #ifdef GECODE_HAS_FLOAT_VARS
690  double decay) {
691  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
692  if (s->id == "input_order")
694  if (s->id == "first_fail")
696  if (s->id == "anti_first_fail")
698  if (s->id == "smallest")
700  if (s->id == "largest")
702  if (s->id == "occurrence")
704  if (s->id == "most_constrained")
707  if (s->id == "random") {
709  }
710  if (s->id == "afc_min")
712  if (s->id == "afc_max")
714  if (s->id == "afc_size_min")
716  if (s->id == "afc_size_max")
718  if (s->id == "action_min")
720  if (s->id == "action_max")
722  if (s->id == "action_size_min")
724  if (s->id == "action_size_max")
726  }
727  std::cerr << "Warning, ignored search annotation: ";
728  ann->print(std::cerr);
729  std::cerr << std::endl;
731  }
732 
733  FloatValBranch ann2fvalsel(AST::Node* ann, std::string r0, std::string r1) {
734  if (AST::Atom* s = dynamic_cast<AST::Atom*>(ann)) {
735  if (s->id == "indomain_split") {
736  r0 = "<="; r1 = ">";
737  return FLOAT_VAL_SPLIT_MIN();
738  }
739  if (s->id == "indomain_reverse_split") {
740  r1 = "<="; r0 = ">";
741  return FLOAT_VAL_SPLIT_MAX();
742  }
743  }
744  std::cerr << "Warning, ignored search annotation: ";
745  ann->print(std::cerr);
746  std::cerr << std::endl;
747  r0 = "<="; r1 = ">";
748  return FLOAT_VAL_SPLIT_MIN();
749  }
750 
751 #endif
752 
754  public:
756  typedef std::unordered_set<TupleSet> TupleSetSet;
758  TupleSetSet tupleSetSet;
759 
761  typedef std::unordered_set<SharedArray<int> > IntSharedArraySet;
763  IntSharedArraySet intSharedArraySet;
764 
766  typedef std::unordered_set<DFA> DFASet;
768  DFASet dfaSet;
769 
772  };
773 
775  : Space(f),
776  _initData(NULL), _random(f._random),
777  _solveAnnotations(NULL), iv_boolalias(NULL),
779  step(f.step),
780 #endif
781  needAuxVars(f.needAuxVars) {
782  _optVar = f._optVar;
784  _method = f._method;
785  _lns = f._lns;
788  iv.update(*this, f.iv);
789  iv_lns.update(*this, f.iv_lns);
791 
792  if (needAuxVars) {
793  IntVarArgs iva;
794  for (int i=0; i<f.iv_aux.size(); i++) {
795  if (!f.iv_aux[i].assigned()) {
796  iva << IntVar();
797  iva[iva.size()-1].update(*this, f.iv_aux[i]);
798  }
799  }
800  iv_aux = IntVarArray(*this, iva);
801  }
802 
803  bv.update(*this, f.bv);
805  if (needAuxVars) {
806  BoolVarArgs bva;
807  for (int i=0; i<f.bv_aux.size(); i++) {
808  if (!f.bv_aux[i].assigned()) {
809  bva << BoolVar();
810  bva[bva.size()-1].update(*this, f.bv_aux[i]);
811  }
812  }
813  bv_aux = BoolVarArray(*this, bva);
814  }
815 
816 #ifdef GECODE_HAS_SET_VARS
817  sv.update(*this, f.sv);
819  if (needAuxVars) {
820  SetVarArgs sva;
821  for (int i=0; i<f.sv_aux.size(); i++) {
822  if (!f.sv_aux[i].assigned()) {
823  sva << SetVar();
824  sva[sva.size()-1].update(*this, f.sv_aux[i]);
825  }
826  }
827  sv_aux = SetVarArray(*this, sva);
828  }
829 #endif
830 #ifdef GECODE_HAS_FLOAT_VARS
831  fv.update(*this, f.fv);
833  if (needAuxVars) {
834  FloatVarArgs fva;
835  for (int i=0; i<f.fv_aux.size(); i++) {
836  if (!f.fv_aux[i].assigned()) {
837  fva << FloatVar();
838  fva[fva.size()-1].update(*this, f.fv_aux[i]);
839  }
840  }
841  fv_aux = FloatVarArray(*this, fva);
842  }
843 #endif
844  }
845 
849  _optVar(-1), _optVarIsInt(true), _lns(0), _lnsInitialSolution(0),
850  _random(random),
851  _solveAnnotations(NULL), needAuxVars(true) {
852  branchInfo.init();
853  }
854 
855  void
856  FlatZincSpace::init(int intVars, int boolVars,
857  int setVars, int floatVars) {
858  (void) setVars;
859  (void) floatVars;
860 
861  intVarCount = 0;
862  iv = IntVarArray(*this, intVars);
863  iv_introduced = std::vector<bool>(2*intVars);
864  iv_boolalias = alloc<int>(intVars+(intVars==0?1:0));
865  boolVarCount = 0;
866  bv = BoolVarArray(*this, boolVars);
867  bv_introduced = std::vector<bool>(2*boolVars);
868 #ifdef GECODE_HAS_SET_VARS
869  setVarCount = 0;
870  sv = SetVarArray(*this, setVars);
871  sv_introduced = std::vector<bool>(2*setVars);
872 #endif
873 #ifdef GECODE_HAS_FLOAT_VARS
874  floatVarCount = 0;
875  fv = FloatVarArray(*this, floatVars);
876  fv_introduced = std::vector<bool>(2*floatVars);
877 #endif
878  }
879 
880  void
882  if (vs->alias) {
883  iv[intVarCount++] = iv[vs->i];
884  } else {
885  IntSet dom(vs2is(vs));
886  if (dom.size()==0) {
887  fail();
888  return;
889  } else {
890  iv[intVarCount++] = IntVar(*this, dom);
891  }
892  }
893  iv_introduced[2*(intVarCount-1)] = vs->introduced;
894  iv_introduced[2*(intVarCount-1)+1] = vs->funcDep;
895  iv_boolalias[intVarCount-1] = -1;
896  }
897 
898  void
900  iv_boolalias[iv] = bv;
901  }
902  int
904  return iv_boolalias[iv];
905  }
906 
907  void
909  if (vs->alias) {
910  bv[boolVarCount++] = bv[vs->i];
911  } else {
912  bv[boolVarCount++] = BoolVar(*this, vs2bsl(vs), vs2bsh(vs));
913  }
915  bv_introduced[2*(boolVarCount-1)+1] = vs->funcDep;
916  }
917 
918 #ifdef GECODE_HAS_SET_VARS
919  void
921  if (vs->alias) {
922  sv[setVarCount++] = sv[vs->i];
923  } else if (vs->assigned) {
924  assert(vs->upperBound());
925  AST::SetLit* vsv = vs->upperBound.some();
926  if (vsv->interval) {
927  IntSet d(vsv->min, vsv->max);
928  sv[setVarCount++] = SetVar(*this, d, d);
929  } else {
930  int* is = heap.alloc<int>(static_cast<unsigned long int>(vsv->s.size()));
931  for (int i=vsv->s.size(); i--; )
932  is[i] = vsv->s[i];
933  IntSet d(is, vsv->s.size());
934  heap.free(is,static_cast<unsigned long int>(vsv->s.size()));
935  sv[setVarCount++] = SetVar(*this, d, d);
936  }
937  } else if (vs->upperBound()) {
938  AST::SetLit* vsv = vs->upperBound.some();
939  if (vsv->interval) {
940  IntSet d(vsv->min, vsv->max);
941  sv[setVarCount++] = SetVar(*this, IntSet::empty, d);
942  } else {
943  int* is = heap.alloc<int>(static_cast<unsigned long int>(vsv->s.size()));
944  for (int i=vsv->s.size(); i--; )
945  is[i] = vsv->s[i];
946  IntSet d(is, vsv->s.size());
947  heap.free(is,static_cast<unsigned long int>(vsv->s.size()));
948  sv[setVarCount++] = SetVar(*this, IntSet::empty, d);
949  }
950  } else {
951  sv[setVarCount++] = SetVar(*this, IntSet::empty,
954  }
955  sv_introduced[2*(setVarCount-1)] = vs->introduced;
956  sv_introduced[2*(setVarCount-1)+1] = vs->funcDep;
957  }
958 #else
959  void
961  throw FlatZinc::Error("Gecode", "set variables not supported");
962  }
963 #endif
964 
965 #ifdef GECODE_HAS_FLOAT_VARS
966  void
968  if (vs->alias) {
969  fv[floatVarCount++] = fv[vs->i];
970  } else {
971  double dmin, dmax;
972  if (vs->domain()) {
973  dmin = vs->domain.some().first;
974  dmax = vs->domain.some().second;
975  if (dmin > dmax) {
976  fail();
977  return;
978  }
979  } else {
980  dmin = Float::Limits::min;
981  dmax = Float::Limits::max;
982  }
983  fv[floatVarCount++] = FloatVar(*this, dmin, dmax);
984  }
986  fv_introduced[2*(floatVarCount-1)+1] = vs->funcDep;
987  }
988 #else
989  void
991  throw FlatZinc::Error("Gecode", "float variables not supported");
992  }
993 #endif
994 
995  namespace {
996  struct ConExprOrder {
997  bool operator() (ConExpr* ce0, ConExpr* ce1) {
998  return ce0->args->a.size() < ce1->args->a.size();
999  }
1000  };
1001  }
1002 
1003  void
1004  FlatZincSpace::postConstraints(std::vector<ConExpr*>& ces) {
1005  ConExprOrder ceo;
1006  std::sort(ces.begin(), ces.end(), ceo);
1007 
1008  for (unsigned int i=0; i<ces.size(); i++) {
1009  const ConExpr& ce = *ces[i];
1010  try {
1011  registry().post(*this, ce);
1012  } catch (Gecode::Exception& e) {
1013  throw FlatZinc::Error("Gecode", e.what());
1014  } catch (AST::TypeError& e) {
1015  throw FlatZinc::Error("Type error", e.what());
1016  }
1017  delete ces[i];
1018  ces[i] = NULL;
1019  }
1020  }
1021 
1022  void flattenAnnotations(AST::Array* ann, std::vector<AST::Node*>& out) {
1023  for (unsigned int i=0; i<ann->a.size(); i++) {
1024  if (ann->a[i]->isCall("seq_search")) {
1025  AST::Call* c = ann->a[i]->getCall();
1026  if (c->args->isArray())
1027  flattenAnnotations(c->args->getArray(), out);
1028  else
1029  out.push_back(c->args);
1030  } else {
1031  out.push_back(ann->a[i]);
1032  }
1033  }
1034  }
1035 
1036  void
1038  bool ignoreUnknown,
1039  std::ostream& err) {
1040  int seed = opt.seed();
1041  double decay = opt.decay();
1042  Rnd rnd(static_cast<unsigned int>(seed));
1043  TieBreak<IntVarBranch> def_int_varsel = INT_VAR_AFC_SIZE_MAX(0.99);
1044  IntBoolVarBranch def_intbool_varsel = INTBOOL_VAR_AFC_SIZE_MAX(0.99);
1045  IntValBranch def_int_valsel = INT_VAL_MIN();
1046  std::string def_int_rel_left = "=";
1047  std::string def_int_rel_right = "!=";
1048  TieBreak<BoolVarBranch> def_bool_varsel = BOOL_VAR_AFC_MAX(0.99);
1049  BoolValBranch def_bool_valsel = BOOL_VAL_MIN();
1050  std::string def_bool_rel_left = "=";
1051  std::string def_bool_rel_right = "!=";
1052 #ifdef GECODE_HAS_SET_VARS
1053  SetVarBranch def_set_varsel = SET_VAR_AFC_SIZE_MAX(0.99);
1054  SetValBranch def_set_valsel = SET_VAL_MIN_INC();
1055  std::string def_set_rel_left = "in";
1056  std::string def_set_rel_right = "not in";
1057 #endif
1058 #ifdef GECODE_HAS_FLOAT_VARS
1059  TieBreak<FloatVarBranch> def_float_varsel = FLOAT_VAR_SIZE_MIN();
1060  FloatValBranch def_float_valsel = FLOAT_VAL_SPLIT_MIN();
1061  std::string def_float_rel_left = "<=";
1062  std::string def_float_rel_right = ">";
1063 #endif
1064 
1065  std::vector<bool> iv_searched(iv.size());
1066  for (unsigned int i=iv.size(); i--;)
1067  iv_searched[i] = false;
1068  std::vector<bool> bv_searched(bv.size());
1069  for (unsigned int i=bv.size(); i--;)
1070  bv_searched[i] = false;
1071 #ifdef GECODE_HAS_SET_VARS
1072  std::vector<bool> sv_searched(sv.size());
1073  for (unsigned int i=sv.size(); i--;)
1074  sv_searched[i] = false;
1075 #endif
1076 #ifdef GECODE_HAS_FLOAT_VARS
1077  std::vector<bool> fv_searched(fv.size());
1078  for (unsigned int i=fv.size(); i--;)
1079  fv_searched[i] = false;
1080 #endif
1081 
1082  _lns = 0;
1083  if (ann) {
1084  std::vector<AST::Node*> flatAnn;
1085  if (ann->isArray()) {
1086  flattenAnnotations(ann->getArray() , flatAnn);
1087  } else {
1088  flatAnn.push_back(ann);
1089  }
1090 
1091  for (unsigned int i=0; i<flatAnn.size(); i++) {
1092  if (flatAnn[i]->isCall("restart_geometric")) {
1093  AST::Call* call = flatAnn[i]->getCall("restart_geometric");
1094  opt.restart(RM_GEOMETRIC);
1095  AST::Array* args = call->getArgs(2);
1096  opt.restart_base(args->a[0]->getFloat());
1097  opt.restart_scale(args->a[1]->getInt());
1098  } else if (flatAnn[i]->isCall("restart_luby")) {
1099  AST::Call* call = flatAnn[i]->getCall("restart_luby");
1100  opt.restart(RM_LUBY);
1101  opt.restart_scale(call->args->getInt());
1102  } else if (flatAnn[i]->isCall("restart_linear")) {
1103  AST::Call* call = flatAnn[i]->getCall("restart_linear");
1104  opt.restart(RM_LINEAR);
1105  opt.restart_scale(call->args->getInt());
1106  } else if (flatAnn[i]->isCall("restart_constant")) {
1107  AST::Call* call = flatAnn[i]->getCall("restart_constant");
1108  opt.restart(RM_CONSTANT);
1109  opt.restart_scale(call->args->getInt());
1110  } else if (flatAnn[i]->isCall("restart_none")) {
1111  opt.restart(RM_NONE);
1112  } else if (flatAnn[i]->isCall("relax_and_reconstruct")) {
1113  if (_lns != 0)
1114  throw FlatZinc::Error("FlatZinc",
1115  "Only one relax_and_reconstruct annotation allowed");
1116  AST::Call *call = flatAnn[i]->getCall("relax_and_reconstruct");
1117  AST::Array* args;
1118  if (call->args->getArray()->a.size()==2) {
1119  args = call->getArgs(2);
1120  } else {
1121  args = call->getArgs(3);
1122  }
1123  _lns = args->a[1]->getInt();
1124  AST::Array *vars = args->a[0]->getArray();
1125  int k=vars->a.size();
1126  for (int i=vars->a.size(); i--;)
1127  if (vars->a[i]->isInt())
1128  k--;
1129  iv_lns = IntVarArray(*this, k);
1130  k = 0;
1131  for (unsigned int i=0; i<vars->a.size(); i++) {
1132  if (vars->a[i]->isInt())
1133  continue;
1134  iv_lns[k++] = iv[vars->a[i]->getIntVar()];
1135  }
1136  if (args->a.size()==3) {
1137  AST::Array *initial = args->a[2]->getArray();
1138  _lnsInitialSolution = IntSharedArray(initial->a.size());
1139  for (unsigned int i=initial->a.size(); i--;)
1140  _lnsInitialSolution[i] = initial->a[i]->getInt();
1141  }
1142  } else if (flatAnn[i]->isCall("gecode_search")) {
1143  AST::Call* c = flatAnn[i]->getCall();
1144  branchWithPlugin(c->args);
1145  } else if (flatAnn[i]->isCall("int_search")) {
1146  AST::Call *call = flatAnn[i]->getCall("int_search");
1147  AST::Array *args = call->getArgs(4);
1148  AST::Array *vars = args->a[0]->getArray();
1149  int k=vars->a.size();
1150  for (int i=vars->a.size(); i--;)
1151  if (vars->a[i]->isInt())
1152  k--;
1153  IntVarArgs va(k);
1154  std::vector<std::string> names;
1155  k=0;
1156  for (unsigned int i=0; i<vars->a.size(); i++) {
1157  if (vars->a[i]->isInt())
1158  continue;
1159  va[k++] = iv[vars->a[i]->getIntVar()];
1160  iv_searched[vars->a[i]->getIntVar()] = true;
1161  names.push_back(vars->a[i]->getVarName());
1162  }
1163  std::string r0, r1;
1164  {
1165  BrancherGroup bg;
1166  branch(bg(*this), va,
1167  ann2ivarsel(args->a[1],rnd,decay),
1168  ann2ivalsel(args->a[2],r0,r1,rnd),
1169  nullptr,
1170  &varValPrint<IntVar>);
1171  branchInfo.add(bg,r0,r1,names);
1172  }
1173  } else if (flatAnn[i]->isCall("int_assign")) {
1174  AST::Call *call = flatAnn[i]->getCall("int_assign");
1175  AST::Array *args = call->getArgs(2);
1176  AST::Array *vars = args->a[0]->getArray();
1177  int k=vars->a.size();
1178  for (int i=vars->a.size(); i--;)
1179  if (vars->a[i]->isInt())
1180  k--;
1181  IntVarArgs va(k);
1182  k=0;
1183  for (unsigned int i=0; i<vars->a.size(); i++) {
1184  if (vars->a[i]->isInt())
1185  continue;
1186  va[k++] = iv[vars->a[i]->getIntVar()];
1187  iv_searched[vars->a[i]->getIntVar()] = true;
1188  }
1189  assign(*this, va, ann2asnivalsel(args->a[1],rnd), nullptr,
1190  &varValPrint<IntVar>);
1191  } else if (flatAnn[i]->isCall("bool_search")) {
1192  AST::Call *call = flatAnn[i]->getCall("bool_search");
1193  AST::Array *args = call->getArgs(4);
1194  AST::Array *vars = args->a[0]->getArray();
1195  int k=vars->a.size();
1196  for (int i=vars->a.size(); i--;)
1197  if (vars->a[i]->isBool())
1198  k--;
1199  BoolVarArgs va(k);
1200  k=0;
1201  std::vector<std::string> names;
1202  for (unsigned int i=0; i<vars->a.size(); i++) {
1203  if (vars->a[i]->isBool())
1204  continue;
1205  va[k++] = bv[vars->a[i]->getBoolVar()];
1206  bv_searched[vars->a[i]->getBoolVar()] = true;
1207  names.push_back(vars->a[i]->getVarName());
1208  }
1209 
1210  std::string r0, r1;
1211  {
1212  BrancherGroup bg;
1213  branch(bg(*this), va,
1214  ann2bvarsel(args->a[1],rnd,decay),
1215  ann2bvalsel(args->a[2],r0,r1,rnd),
1216  nullptr,
1217  &varValPrint<BoolVar>);
1218  branchInfo.add(bg,r0,r1,names);
1219  }
1220  } else if (flatAnn[i]->isCall("int_default_search")) {
1221  AST::Call *call = flatAnn[i]->getCall("int_default_search");
1222  AST::Array *args = call->getArgs(2);
1223  def_int_varsel = ann2ivarsel(args->a[0],rnd,decay);
1224  def_int_valsel = ann2ivalsel(args->a[1],
1225  def_int_rel_left,def_int_rel_right,rnd);
1226  } else if (flatAnn[i]->isCall("bool_default_search")) {
1227  AST::Call *call = flatAnn[i]->getCall("bool_default_search");
1228  AST::Array *args = call->getArgs(2);
1229  def_bool_varsel = ann2bvarsel(args->a[0],rnd,decay);
1230  def_bool_valsel = ann2bvalsel(args->a[1],
1231  def_bool_rel_left,def_bool_rel_right,
1232  rnd);
1233  } else if (flatAnn[i]->isCall("set_search")) {
1234 #ifdef GECODE_HAS_SET_VARS
1235  AST::Call *call = flatAnn[i]->getCall("set_search");
1236  AST::Array *args = call->getArgs(4);
1237  AST::Array *vars = args->a[0]->getArray();
1238  int k=vars->a.size();
1239  for (int i=vars->a.size(); i--;)
1240  if (vars->a[i]->isSet())
1241  k--;
1242  SetVarArgs va(k);
1243  k=0;
1244  std::vector<std::string> names;
1245  for (unsigned int i=0; i<vars->a.size(); i++) {
1246  if (vars->a[i]->isSet())
1247  continue;
1248  va[k++] = sv[vars->a[i]->getSetVar()];
1249  sv_searched[vars->a[i]->getSetVar()] = true;
1250  names.push_back(vars->a[i]->getVarName());
1251  }
1252  std::string r0, r1;
1253  {
1254  BrancherGroup bg;
1255  branch(bg(*this), va,
1256  ann2svarsel(args->a[1],rnd,decay),
1257  ann2svalsel(args->a[2],r0,r1,rnd),
1258  nullptr,
1259  &varValPrint<SetVar>);
1260  branchInfo.add(bg,r0,r1,names);
1261  }
1262 #else
1263  if (!ignoreUnknown) {
1264  err << "Warning, ignored search annotation: ";
1265  flatAnn[i]->print(err);
1266  err << std::endl;
1267  }
1268 #endif
1269  } else if (flatAnn[i]->isCall("set_default_search")) {
1270 #ifdef GECODE_HAS_SET_VARS
1271  AST::Call *call = flatAnn[i]->getCall("set_default_search");
1272  AST::Array *args = call->getArgs(2);
1273  def_set_varsel = ann2svarsel(args->a[0],rnd,decay);
1274  def_set_valsel = ann2svalsel(args->a[1],
1275  def_set_rel_left,def_set_rel_right,rnd);
1276 #else
1277  if (!ignoreUnknown) {
1278  err << "Warning, ignored search annotation: ";
1279  flatAnn[i]->print(err);
1280  err << std::endl;
1281  }
1282 #endif
1283  } else if (flatAnn[i]->isCall("float_default_search")) {
1284 #ifdef GECODE_HAS_FLOAT_VARS
1285  AST::Call *call = flatAnn[i]->getCall("float_default_search");
1286  AST::Array *args = call->getArgs(2);
1287  def_float_varsel = ann2fvarsel(args->a[0],rnd,decay);
1288  def_float_valsel = ann2fvalsel(args->a[1],
1289  def_float_rel_left,def_float_rel_right);
1290 #else
1291  if (!ignoreUnknown) {
1292  err << "Warning, ignored search annotation: ";
1293  flatAnn[i]->print(err);
1294  err << std::endl;
1295  }
1296 #endif
1297  } else if (flatAnn[i]->isCall("float_search")) {
1298 #ifdef GECODE_HAS_FLOAT_VARS
1299  AST::Call *call = flatAnn[i]->getCall("float_search");
1300  AST::Array *args = call->getArgs(5);
1301  AST::Array *vars = args->a[0]->getArray();
1302  int k=vars->a.size();
1303  for (int i=vars->a.size(); i--;)
1304  if (vars->a[i]->isFloat())
1305  k--;
1306  FloatVarArgs va(k);
1307  k=0;
1308  std::vector<std::string> names;
1309  for (unsigned int i=0; i<vars->a.size(); i++) {
1310  if (vars->a[i]->isFloat())
1311  continue;
1312  va[k++] = fv[vars->a[i]->getFloatVar()];
1313  fv_searched[vars->a[i]->getFloatVar()] = true;
1314  names.push_back(vars->a[i]->getVarName());
1315  }
1316  std::string r0, r1;
1317  {
1318  BrancherGroup bg;
1319  branch(bg(*this), va,
1320  ann2fvarsel(args->a[2],rnd,decay),
1321  ann2fvalsel(args->a[3],r0,r1),
1322  nullptr,
1323  &varValPrintF);
1324  branchInfo.add(bg,r0,r1,names);
1325  }
1326 #else
1327  if (!ignoreUnknown) {
1328  err << "Warning, ignored search annotation: ";
1329  flatAnn[i]->print(err);
1330  err << std::endl;
1331  }
1332 #endif
1333  } else {
1334  if (!ignoreUnknown) {
1335  err << "Warning, ignored search annotation: ";
1336  flatAnn[i]->print(err);
1337  err << std::endl;
1338  }
1339  }
1340  }
1341  }
1342  int introduced = 0;
1343  int funcdep = 0;
1344  int searched = 0;
1345  for (int i=iv.size(); i--;) {
1346  if (iv_searched[i] || (_method != SAT && _optVarIsInt && _optVar==i)) {
1347  searched++;
1348  } else if (iv_introduced[2*i]) {
1349  if (iv_introduced[2*i+1]) {
1350  funcdep++;
1351  } else {
1352  introduced++;
1353  }
1354  }
1355  }
1356  std::vector<std::string> iv_sol_names(iv.size()-(introduced+funcdep+searched));
1357  IntVarArgs iv_sol(iv.size()-(introduced+funcdep+searched));
1358  std::vector<std::string> iv_tmp_names(introduced);
1359  IntVarArgs iv_tmp(introduced);
1360  for (int i=iv.size(), j=0, k=0; i--;) {
1361  if (iv_searched[i] || (_method != SAT && _optVarIsInt && _optVar==i))
1362  continue;
1363  if (iv_introduced[2*i]) {
1364  if (!iv_introduced[2*i+1]) {
1365  iv_tmp_names[j] = p.intVarName(i);
1366  iv_tmp[j++] = iv[i];
1367  }
1368  } else {
1369  iv_sol_names[k] = p.intVarName(i);
1370  iv_sol[k++] = iv[i];
1371  }
1372  }
1373 
1374  introduced = 0;
1375  funcdep = 0;
1376  searched = 0;
1377  for (int i=bv.size(); i--;) {
1378  if (bv_searched[i]) {
1379  searched++;
1380  } else if (bv_introduced[2*i]) {
1381  if (bv_introduced[2*i+1]) {
1382  funcdep++;
1383  } else {
1384  introduced++;
1385  }
1386  }
1387  }
1388  std::vector<std::string> bv_sol_names(bv.size()-(introduced+funcdep+searched));
1389  BoolVarArgs bv_sol(bv.size()-(introduced+funcdep+searched));
1390  BoolVarArgs bv_tmp(introduced);
1391  std::vector<std::string> bv_tmp_names(introduced);
1392  for (int i=bv.size(), j=0, k=0; i--;) {
1393  if (bv_searched[i])
1394  continue;
1395  if (bv_introduced[2*i]) {
1396  if (!bv_introduced[2*i+1]) {
1397  bv_tmp_names[j] = p.boolVarName(i);
1398  bv_tmp[j++] = bv[i];
1399  }
1400  } else {
1401  bv_sol_names[k] = p.boolVarName(i);
1402  bv_sol[k++] = bv[i];
1403  }
1404  }
1405 
1406  if (iv_sol.size() > 0 && bv_sol.size() > 0) {
1407  branch(*this, iv_sol, bv_sol, def_intbool_varsel, def_int_valsel);
1408  } else if (iv_sol.size() > 0) {
1409  BrancherGroup bg;
1410  branch(bg(*this), iv_sol, def_int_varsel, def_int_valsel, nullptr,
1411  &varValPrint<IntVar>);
1412  branchInfo.add(bg,def_int_rel_left,def_int_rel_right,iv_sol_names);
1413  } else if (bv_sol.size() > 0) {
1414  BrancherGroup bg;
1415  branch(bg(*this), bv_sol, def_bool_varsel, def_bool_valsel, nullptr,
1416  &varValPrint<BoolVar>);
1417  branchInfo.add(bg,def_bool_rel_left,def_bool_rel_right,bv_sol_names);
1418  }
1419 #ifdef GECODE_HAS_FLOAT_VARS
1420  introduced = 0;
1421  funcdep = 0;
1422  searched = 0;
1423  for (int i=fv.size(); i--;) {
1424  if (fv_searched[i] || (_method != SAT && !_optVarIsInt && _optVar==i)) {
1425  searched++;
1426  } else if (fv_introduced[2*i]) {
1427  if (fv_introduced[2*i+1]) {
1428  funcdep++;
1429  } else {
1430  introduced++;
1431  }
1432  }
1433  }
1434  std::vector<std::string> fv_sol_names(fv.size()-(introduced+funcdep+searched));
1435  FloatVarArgs fv_sol(fv.size()-(introduced+funcdep+searched));
1436  FloatVarArgs fv_tmp(introduced);
1437  std::vector<std::string> fv_tmp_names(introduced);
1438  for (int i=fv.size(), j=0, k=0; i--;) {
1439  if (fv_searched[i] || (_method != SAT && !_optVarIsInt && _optVar==i))
1440  continue;
1441  if (fv_introduced[2*i]) {
1442  if (!fv_introduced[2*i+1]) {
1443  fv_tmp_names[j] = p.floatVarName(i);
1444  fv_tmp[j++] = fv[i];
1445  }
1446  } else {
1447  fv_sol_names[k] = p.floatVarName(i);
1448  fv_sol[k++] = fv[i];
1449  }
1450  }
1451 
1452  if (fv_sol.size() > 0) {
1453  BrancherGroup bg;
1454  branch(bg(*this), fv_sol, def_float_varsel, def_float_valsel, nullptr,
1455  &varValPrintF);
1456  branchInfo.add(bg,def_float_rel_left,def_float_rel_right,fv_sol_names);
1457  }
1458 #endif
1459 #ifdef GECODE_HAS_SET_VARS
1460  introduced = 0;
1461  funcdep = 0;
1462  searched = 0;
1463  for (int i=sv.size(); i--;) {
1464  if (sv_searched[i]) {
1465  searched++;
1466  } else if (sv_introduced[2*i]) {
1467  if (sv_introduced[2*i+1]) {
1468  funcdep++;
1469  } else {
1470  introduced++;
1471  }
1472  }
1473  }
1474  std::vector<std::string> sv_sol_names(sv.size()-(introduced+funcdep+searched));
1475  SetVarArgs sv_sol(sv.size()-(introduced+funcdep+searched));
1476  SetVarArgs sv_tmp(introduced);
1477  std::vector<std::string> sv_tmp_names(introduced);
1478  for (int i=sv.size(), j=0, k=0; i--;) {
1479  if (sv_searched[i])
1480  continue;
1481  if (sv_introduced[2*i]) {
1482  if (!sv_introduced[2*i+1]) {
1483  sv_tmp_names[j] = p.setVarName(i);
1484  sv_tmp[j++] = sv[i];
1485  }
1486  } else {
1487  sv_sol_names[k] = p.setVarName(i);
1488  sv_sol[k++] = sv[i];
1489  }
1490  }
1491 
1492  if (sv_sol.size() > 0) {
1493  BrancherGroup bg;
1494  branch(bg(*this), sv_sol, def_set_varsel, def_set_valsel, nullptr,
1495  &varValPrint<SetVar>);
1496  branchInfo.add(bg,def_set_rel_left,def_set_rel_right,sv_sol_names);
1497 
1498  }
1499 #endif
1500  iv_aux = IntVarArray(*this, iv_tmp);
1501  bv_aux = BoolVarArray(*this, bv_tmp);
1502  int n_aux = iv_aux.size() + bv_aux.size();
1503 #ifdef GECODE_HAS_SET_VARS
1504  sv_aux = SetVarArray(*this, sv_tmp);
1505  n_aux += sv_aux.size();
1506 #endif
1507 #ifdef GECODE_HAS_FLOAT_VARS
1508  fv_aux = FloatVarArray(*this, fv_tmp);
1509  n_aux += fv_aux.size();
1510 #endif
1511 
1512  if (n_aux > 0) {
1513  if (_method == SAT) {
1514  AuxVarBrancher::post(*this, def_int_varsel, def_int_valsel,
1515  def_bool_varsel, def_bool_valsel
1516 #ifdef GECODE_HAS_SET_VARS
1517  , def_set_varsel, def_set_valsel
1518 #endif
1519 #ifdef GECODE_HAS_FLOAT_VARS
1520  , def_float_varsel, def_float_valsel
1521 #endif
1522  );
1523  } else {
1524  {
1525  BrancherGroup bg;
1526  branch(bg(*this),iv_aux,def_int_varsel,def_int_valsel, nullptr,
1527  &varValPrint<IntVar>);
1528  branchInfo.add(bg,def_int_rel_left,def_int_rel_right,iv_tmp_names);
1529  }
1530  {
1531  BrancherGroup bg;
1532  branch(bg(*this),bv_aux,def_bool_varsel,def_bool_valsel, nullptr,
1533  &varValPrint<BoolVar>);
1534  branchInfo.add(bg,def_bool_rel_left,def_bool_rel_right,bv_tmp_names);
1535  }
1536  #ifdef GECODE_HAS_SET_VARS
1537  {
1538  BrancherGroup bg;
1539  branch(bg(*this),sv_aux,def_set_varsel,def_set_valsel, nullptr,
1540  &varValPrint<SetVar>);
1541  branchInfo.add(bg,def_set_rel_left,def_set_rel_right,sv_tmp_names);
1542  }
1543  #endif
1544  #ifdef GECODE_HAS_FLOAT_VARS
1545  {
1546  BrancherGroup bg;
1547  branch(bg(*this),fv_aux,def_float_varsel,def_float_valsel, nullptr,
1548  &varValPrintF);
1549  branchInfo.add(bg,def_float_rel_left,def_float_rel_right,fv_tmp_names);
1550  }
1551  #endif
1552 
1553  }
1554  }
1555 
1556  if (_method == MIN) {
1557  if (_optVarIsInt) {
1558  std::vector<std::string> names(1);
1559  names[0] = p.intVarName(_optVar);
1560  BrancherGroup bg;
1561  branch(bg(*this), iv[_optVar], INT_VAL_MIN(),
1562  &varValPrint<IntVar>);
1563  branchInfo.add(bg,"=","!=",names);
1564  } else {
1565 #ifdef GECODE_HAS_FLOAT_VARS
1566  std::vector<std::string> names(1);
1567  names[0] = p.floatVarName(_optVar);
1568  BrancherGroup bg;
1569  branch(bg(*this), fv[_optVar], FLOAT_VAL_SPLIT_MIN(),
1570  &varValPrintF);
1571  branchInfo.add(bg,"<=",">",names);
1572 #endif
1573  }
1574  } else if (_method == MAX) {
1575  if (_optVarIsInt) {
1576  std::vector<std::string> names(1);
1577  names[0] = p.intVarName(_optVar);
1578  BrancherGroup bg;
1579  branch(bg(*this), iv[_optVar], INT_VAL_MAX(),
1580  &varValPrint<IntVar>);
1581  branchInfo.add(bg,"=","!=",names);
1582  } else {
1583 #ifdef GECODE_HAS_FLOAT_VARS
1584  std::vector<std::string> names(1);
1585  names[0] = p.floatVarName(_optVar);
1586  BrancherGroup bg;
1587  branch(bg(*this), fv[_optVar], FLOAT_VAL_SPLIT_MAX(),
1588  &varValPrintF);
1589  branchInfo.add(bg,"<=",">",names);
1590 #endif
1591  }
1592  }
1593 
1594  }
1595 
1596  AST::Array*
1598  return _solveAnnotations;
1599  }
1600 
1601  void
1603  _method = SAT;
1604  _solveAnnotations = ann;
1605  }
1606 
1607  void
1608  FlatZincSpace::minimize(int var, bool isInt, AST::Array* ann) {
1609  _method = MIN;
1610  _optVar = var;
1611  _optVarIsInt = isInt;
1612  _solveAnnotations = ann;
1613  }
1614 
1615  void
1616  FlatZincSpace::maximize(int var, bool isInt, AST::Array* ann) {
1617  _method = MAX;
1618  _optVar = var;
1619  _optVarIsInt = isInt;
1620  _solveAnnotations = ann;
1621  }
1622 
1624  delete _initData;
1625  delete _solveAnnotations;
1626  }
1627 
1628 #ifdef GECODE_HAS_GIST
1629 
1633  template<class Engine>
1634  class GistEngine {
1635  };
1636 
1638  template<typename S>
1639  class GistEngine<DFS<S> > {
1640  public:
1641  static void explore(S* root, const FlatZincOptions& opt,
1644  o.c_d = opt.c_d(); o.a_d = opt.a_d();
1645  o.inspect.click(i);
1646  o.inspect.compare(c);
1647  (void) Gecode::Gist::dfs(root, o);
1648  }
1649  };
1650 
1652  template<typename S>
1653  class GistEngine<BAB<S> > {
1654  public:
1655  static void explore(S* root, const FlatZincOptions& opt,
1658  o.c_d = opt.c_d(); o.a_d = opt.a_d();
1659  o.inspect.click(i);
1660  o.inspect.compare(c);
1661  (void) Gecode::Gist::bab(root, o);
1662  }
1663  };
1664 
1666  template<class S>
1669  private:
1670  const Printer& p;
1671  public:
1673  FZPrintingInspector(const Printer& p0);
1675  virtual void inspect(const Space& node);
1677  virtual void finalize(void);
1678  };
1679 
1680  template<class S>
1682  : TextOutput("Gecode/FlatZinc"), p(p0) {}
1683 
1684  template<class S>
1685  void
1687  init();
1688  dynamic_cast<const S&>(node).print(getStream(), p);
1689  getStream() << std::endl;
1690  }
1691 
1692  template<class S>
1693  void
1696  }
1697 
1698  template<class S>
1700  : public Gecode::Gist::VarComparator<S> {
1701  private:
1702  const Printer& p;
1703  public:
1705  FZPrintingComparator(const Printer& p0);
1706 
1708  virtual void compare(const Space& s0, const Space& s1);
1709  };
1710 
1711  template<class S>
1713  : Gecode::Gist::VarComparator<S>("Gecode/FlatZinc"), p(p0) {}
1714 
1715  template<class S>
1716  void
1718  this->init();
1719  try {
1720  dynamic_cast<const S&>(s0).compare(dynamic_cast<const S&>(s1),
1721  this->getStream(), p);
1722  } catch (Exception& e) {
1723  this->getStream() << "Exception: " << e.what();
1724  }
1725  this->getStream() << std::endl;
1726  }
1727 
1728 #endif
1729 
1730  template<template<class> class Engine>
1731  void
1732  FlatZincSpace::runEngine(std::ostream& out, const Printer& p,
1733  const FlatZincOptions& opt, Support::Timer& t_total) {
1734  if (opt.restart()==RM_NONE) {
1735  runMeta<Engine,Driver::EngineToMeta>(out,p,opt,t_total);
1736  } else {
1737  runMeta<Engine,RBS>(out,p,opt,t_total);
1738  }
1739  }
1740 
1741 #ifdef GECODE_HAS_CPPROFILER
1742 
1744  public:
1745  const Printer& p;
1746  FlatZincGetInfo(const Printer& printer) : p(printer) {}
1747  virtual std::string
1748  getInfo(const Space& space) const {
1749  std::stringstream ss;
1750  if (const FlatZincSpace* fz_space = dynamic_cast<const FlatZincSpace*>(&space)) {
1751  ss << "{domains = \"";
1752  ss << fz_space->getDomains(p);
1753  ss << "\"}";
1754  }
1755  return ss.str();
1756  }
1758  };
1759 
1760  void printIntVar(std::ostream& os, const std::string name, const Int::IntView& x) {
1761  os << "var ";
1762  if (x.assigned()) {
1763  os << "int: " << name << " = " << x.val() << ";";
1764  } else if (x.range()) {
1765  os << x.min() << ".." << x.max() << ": " << name << ";";
1766  } else {
1767  os << "array_union([";
1769  while (true) {
1770  os << r.min() << ".." << r.max();
1771  ++r;
1772  if (!r()) break;
1773  os << ',';
1774  }
1775  os << "]): " << name << ";";
1776  }
1777  os << "\n";
1778  }
1779  void printBoolVar(std::ostream& os, const std::string name, const BoolVar& b) {
1780  os << "var bool: " << name;
1781  if(b.assigned())
1782  os << " = " << (b.val() ? "true" : "false");
1783  os << ";\n";
1784  }
1785 #ifdef GECODE_HAS_FLOAT_VARS
1786  void printFloatVar(std::ostream& os, const std::string name, const Float::FloatView& f) {
1787  os << "var ";
1788  if(f.assigned())
1789  os << "float: " << name << " = " << f.med() << ";";
1790  else
1791  os << f.min() << ".." << f.max() << ": " << name << ";";
1792  os << "\n";
1793  }
1794 #endif
1795  std::string FlatZincSpace::getDomains(const Printer& p) const {
1796  std::ostringstream oss;
1797 
1798  for (int i = 0; i < iv.size(); i++)
1799  printIntVar(oss, p.intVarName(i), iv[i]);
1800 
1801  for (int i = 0; i < bv.size(); i++)
1802  printBoolVar(oss, p.boolVarName(i), bv[i]);
1803 
1804 #ifdef GECODE_HAS_FLOAT_VARS
1805  for (int i = 0; i < fv.size(); i++)
1806  printFloatVar(oss, p.floatVarName(i), fv[i]);
1807 #endif
1808 #ifdef GECODE_HAS_SET_VARS
1809  for (int i = 0; i < sv.size(); i++)
1810  oss << "var " << sv[i] << ": " << p.setVarName(i) << ";" << std::endl;
1811 #endif
1812 
1813  return oss.str();
1814  }
1815 
1816 #endif
1817 
1818  template<template<class> class Engine,
1819  template<class,template<class> class> class Meta>
1820  void
1821  FlatZincSpace::runMeta(std::ostream& out, const Printer& p,
1822  const FlatZincOptions& opt, Support::Timer& t_total) {
1823 #ifdef GECODE_HAS_GIST
1824  if (opt.mode() == SM_GIST) {
1827  (void) GistEngine<Engine<FlatZincSpace> >::explore(this,opt,&pi,&pc);
1828  return;
1829  }
1830 #endif
1831  StatusStatistics sstat;
1832  unsigned int n_p = 0;
1833  Support::Timer t_solve;
1834  t_solve.start();
1835  if (status(sstat) != SS_FAILED) {
1836  n_p = PropagatorGroup::all.size(*this);
1837  }
1838  Search::Options o;
1839  o.stop = Driver::CombinedStop::create(opt.node(), opt.fail(), opt.time(),
1840  true);
1841  o.c_d = opt.c_d();
1842  o.a_d = opt.a_d();
1843 
1844 #ifdef GECODE_HAS_CPPROFILER
1845 
1846  if (opt.mode() == SM_CPPROFILER) {
1847  FlatZincGetInfo* getInfo = nullptr;
1848  if (opt.profiler_info())
1849  getInfo = new FlatZincGetInfo(p);
1851  opt.name(), opt.profiler_port(),
1852  getInfo);
1853  }
1854 
1855 #endif
1856 
1857 #ifdef GECODE_HAS_FLOAT_VARS
1858  step = opt.step();
1859 #endif
1860  o.threads = opt.threads();
1861  o.nogoods_limit = opt.nogoods() ? opt.nogoods_limit() : 0;
1863  if (opt.interrupt())
1865  Meta<FlatZincSpace,Engine> se(this,o);
1866  int noOfSolutions = opt.solutions();
1867  if (noOfSolutions == -1) {
1868  noOfSolutions = (_method == SAT) ? 1 : 0;
1869  }
1870  bool printAll = _method == SAT || opt.allSolutions() || noOfSolutions != 0;
1871  int findSol = noOfSolutions;
1872  FlatZincSpace* sol = NULL;
1873  while (FlatZincSpace* next_sol = se.next()) {
1874  delete sol;
1875  sol = next_sol;
1876  if (printAll) {
1877  sol->print(out, p);
1878  out << "----------" << std::endl;
1879  }
1880  if (--findSol==0)
1881  goto stopped;
1882  }
1883  if (sol && !printAll) {
1884  sol->print(out, p);
1885  out << "----------" << std::endl;
1886  }
1887  if (!se.stopped()) {
1888  if (sol) {
1889  out << "==========" << std::endl;
1890  } else {
1891  out << "=====UNSATISFIABLE=====" << std::endl;
1892  }
1893  } else if (!sol) {
1894  out << "=====UNKNOWN=====" << std::endl;
1895  }
1896  delete sol;
1897  stopped:
1898  if (opt.interrupt())
1900  if (opt.mode() == SM_STAT) {
1901  Gecode::Search::Statistics stat = se.statistics();
1902  out << std::endl
1903  << "%% runtime: ";
1904  Driver::stop(t_total,out);
1905  out << std::endl
1906  << "%% solvetime: ";
1907  Driver::stop(t_solve,out);
1908  out << std::endl
1909  << "%% solutions: "
1910  << std::abs(noOfSolutions - findSol) << std::endl
1911  << "%% variables: "
1912  << (intVarCount + boolVarCount + setVarCount) << std::endl
1913  << "%% propagators: " << n_p << std::endl
1914  << "%% propagations: " << sstat.propagate+stat.propagate << std::endl
1915  << "%% nodes: " << stat.node << std::endl
1916  << "%% failures: " << stat.fail << std::endl
1917  << "%% restarts: " << stat.restart << std::endl
1918  << "%% peak depth: " << stat.depth << std::endl
1919  << std::endl;
1920  }
1921  delete o.stop;
1922  delete o.tracer;
1923  }
1924 
1925 #ifdef GECODE_HAS_QT
1926  void
1927  FlatZincSpace::branchWithPlugin(AST::Node* ann) {
1928  if (AST::Call* c = dynamic_cast<AST::Call*>(ann)) {
1929  QString pluginName(c->id.c_str());
1930  if (QLibrary::isLibrary(pluginName+".dll")) {
1931  pluginName += ".dll";
1932  } else if (QLibrary::isLibrary(pluginName+".dylib")) {
1933  pluginName = "lib" + pluginName + ".dylib";
1934  } else if (QLibrary::isLibrary(pluginName+".so")) {
1935  // Must check .so after .dylib so that Mac OS uses .dylib
1936  pluginName = "lib" + pluginName + ".so";
1937  }
1938  QPluginLoader pl(pluginName);
1939  QObject* plugin_o = pl.instance();
1940  if (!plugin_o) {
1941  throw FlatZinc::Error("FlatZinc",
1942  "Error loading plugin "+pluginName.toStdString()+
1943  ": "+pl.errorString().toStdString());
1944  }
1945  BranchPlugin* pb = qobject_cast<BranchPlugin*>(plugin_o);
1946  if (!pb) {
1947  throw FlatZinc::Error("FlatZinc",
1948  "Error loading plugin "+pluginName.toStdString()+
1949  ": does not contain valid PluginBrancher");
1950  }
1951  pb->branch(*this, c);
1952  }
1953  }
1954 #else
1955  void
1956  FlatZincSpace::branchWithPlugin(AST::Node*) {
1957  throw FlatZinc::Error("FlatZinc",
1958  "Branching with plugins not supported (requires Qt support)");
1959  }
1960 #endif
1961 
1962  void
1963  FlatZincSpace::run(std::ostream& out, const Printer& p,
1964  const FlatZincOptions& opt, Support::Timer& t_total) {
1965  switch (_method) {
1966  case MIN:
1967  case MAX:
1968  runEngine<BAB>(out,p,opt,t_total);
1969  break;
1970  case SAT:
1971  runEngine<DFS>(out,p,opt,t_total);
1972  break;
1973  }
1974  }
1975 
1976  void
1978  if (_optVarIsInt) {
1979  if (_method == MIN)
1980  rel(*this, iv[_optVar], IRT_LE,
1981  static_cast<const FlatZincSpace*>(&s)->iv[_optVar].val());
1982  else if (_method == MAX)
1983  rel(*this, iv[_optVar], IRT_GR,
1984  static_cast<const FlatZincSpace*>(&s)->iv[_optVar].val());
1985  } else {
1986 #ifdef GECODE_HAS_FLOAT_VARS
1987  if (_method == MIN)
1988  rel(*this, fv[_optVar], FRT_LE,
1989  static_cast<const FlatZincSpace*>(&s)->fv[_optVar].val()-step);
1990  else if (_method == MAX)
1991  rel(*this, fv[_optVar], FRT_GR,
1992  static_cast<const FlatZincSpace*>(&s)->fv[_optVar].val()+step);
1993 #endif
1994  }
1995  }
1996 
1997  bool
1999  if ((mi.type() == MetaInfo::RESTART) && (mi.restart() != 0) &&
2000  (_lns > 0) && (mi.last()==NULL) && (_lnsInitialSolution.size()>0)) {
2001  for (unsigned int i=iv_lns.size(); i--;) {
2002  if (_random(99) <= _lns) {
2003  rel(*this, iv_lns[i], IRT_EQ, _lnsInitialSolution[i]);
2004  }
2005  }
2006  return false;
2007  } else if ((mi.type() == MetaInfo::RESTART) && (mi.restart() != 0) &&
2008  (_lns > 0) && mi.last()) {
2009  const FlatZincSpace& last =
2010  static_cast<const FlatZincSpace&>(*mi.last());
2011  for (unsigned int i=iv_lns.size(); i--;) {
2012  if (_random(99) <= _lns) {
2013  rel(*this, iv_lns[i], IRT_EQ, last.iv_lns[i]);
2014  }
2015  }
2016  return false;
2017  }
2018  return true;
2019  }
2020 
2021  Space*
2023  return new FlatZincSpace(*this);
2024  }
2025 
2028  return _method;
2029  }
2030 
2031  int
2033  return _optVar;
2034  }
2035 
2036  bool
2038  return _optVarIsInt;
2039  }
2040 
2041  void
2042  FlatZincSpace::print(std::ostream& out, const Printer& p) const {
2043  p.print(out, iv, bv
2044 #ifdef GECODE_HAS_SET_VARS
2045  , sv
2046 #endif
2047 #ifdef GECODE_HAS_FLOAT_VARS
2048  , fv
2049 #endif
2050  );
2051  }
2052 
2053  void
2054  FlatZincSpace::compare(const Space& s, std::ostream& out) const {
2055  (void) s; (void) out;
2056 #ifdef GECODE_HAS_GIST
2057  const FlatZincSpace& fs = dynamic_cast<const FlatZincSpace&>(s);
2058  for (int i = 0; i < iv.size(); ++i) {
2059  std::stringstream ss;
2060  ss << "iv[" << i << "]";
2061  std::string result(Gecode::Gist::Comparator::compare(ss.str(), iv[i],
2062  fs.iv[i]));
2063  if (result.length() > 0) out << result << std::endl;
2064  }
2065  for (int i = 0; i < bv.size(); ++i) {
2066  std::stringstream ss;
2067  ss << "bv[" << i << "]";
2068  std::string result(Gecode::Gist::Comparator::compare(ss.str(), bv[i],
2069  fs.bv[i]));
2070  if (result.length() > 0) out << result << std::endl;
2071  }
2072 #ifdef GECODE_HAS_SET_VARS
2073  for (int i = 0; i < sv.size(); ++i) {
2074  std::stringstream ss;
2075  ss << "sv[" << i << "]";
2076  std::string result(Gecode::Gist::Comparator::compare(ss.str(), sv[i],
2077  fs.sv[i]));
2078  if (result.length() > 0) out << result << std::endl;
2079  }
2080 #endif
2081 #ifdef GECODE_HAS_FLOAT_VARS
2082  for (int i = 0; i < fv.size(); ++i) {
2083  std::stringstream ss;
2084  ss << "fv[" << i << "]";
2085  std::string result(Gecode::Gist::Comparator::compare(ss.str(), fv[i],
2086  fs.fv[i]));
2087  if (result.length() > 0) out << result << std::endl;
2088  }
2089 #endif
2090 #endif
2091  }
2092 
2093  void
2094  FlatZincSpace::compare(const FlatZincSpace& s, std::ostream& out,
2095  const Printer& p) const {
2096  p.printDiff(out, iv, s.iv, bv, s.bv
2097 #ifdef GECODE_HAS_SET_VARS
2098  , sv, s.sv
2099 #endif
2100 #ifdef GECODE_HAS_FLOAT_VARS
2101  , fv, s.fv
2102 #endif
2103  );
2104  }
2105 
2106  void
2108  p.shrinkArrays(*this, _optVar, _optVarIsInt, iv, bv
2109 #ifdef GECODE_HAS_SET_VARS
2110  , sv
2111 #endif
2112 #ifdef GECODE_HAS_FLOAT_VARS
2113  , fv
2114 #endif
2115  );
2116  }
2117 
2118  IntArgs
2120  AST::Array* a = arg->getArray();
2121  IntArgs ia(a->a.size()+offset);
2122  for (int i=offset; i--;)
2123  ia[i] = 0;
2124  for (int i=a->a.size(); i--;)
2125  ia[i+offset] = a->a[i]->getInt();
2126  return ia;
2127  }
2128  TupleSet
2130  AST::Array* a = arg->getArray();
2131  int noOfTuples = a->a.size() == 0 ? 0 : (a->a.size()/noOfVars);
2132 
2133  // Build TupleSet
2134  TupleSet ts(noOfVars);
2135  for (int i=0; i<noOfTuples; i++) {
2136  IntArgs t(noOfVars);
2137  for (int j=0; j<noOfVars; j++) {
2138  t[j] = a->a[i*noOfVars+j]->getInt();
2139  }
2140  ts.add(t);
2141  }
2142  ts.finalize();
2143 
2144  if (_initData) {
2145  FlatZincSpaceInitData::TupleSetSet::iterator it = _initData->tupleSetSet.find(ts);
2146  if (it != _initData->tupleSetSet.end()) {
2147  return *it;
2148  }
2149  _initData->tupleSetSet.insert(ts);
2150  }
2151 
2152 
2153  return ts;
2154  }
2157  IntArgs ia(arg2intargs(arg,offset));
2158  SharedArray<int> sia(ia);
2159  if (_initData) {
2160  FlatZincSpaceInitData::IntSharedArraySet::iterator it = _initData->intSharedArraySet.find(sia);
2161  if (it != _initData->intSharedArraySet.end()) {
2162  return *it;
2163  }
2164  _initData->intSharedArraySet.insert(sia);
2165  }
2166 
2167  return sia;
2168  }
2169  IntArgs
2171  AST::Array* a = arg->getArray();
2172  IntArgs ia(a->a.size()+offset);
2173  for (int i=offset; i--;)
2174  ia[i] = 0;
2175  for (int i=a->a.size(); i--;)
2176  ia[i+offset] = a->a[i]->getBool();
2177  return ia;
2178  }
2181  IntArgs ia(arg2boolargs(arg,offset));
2182  SharedArray<int> sia(ia);
2183  if (_initData) {
2184  FlatZincSpaceInitData::IntSharedArraySet::iterator it = _initData->intSharedArraySet.find(sia);
2185  if (it != _initData->intSharedArraySet.end()) {
2186  return *it;
2187  }
2188  _initData->intSharedArraySet.insert(sia);
2189  }
2190 
2191  return sia;
2192  }
2193  IntSet
2195  AST::SetLit* sl = n->getSet();
2196  IntSet d;
2197  if (sl->interval) {
2198  d = IntSet(sl->min, sl->max);
2199  } else {
2200  Region re;
2201  int* is = re.alloc<int>(static_cast<unsigned long int>(sl->s.size()));
2202  for (int i=sl->s.size(); i--; )
2203  is[i] = sl->s[i];
2204  d = IntSet(is, sl->s.size());
2205  }
2206  return d;
2207  }
2208  IntSetArgs
2210  AST::Array* a = arg->getArray();
2211  if (a->a.size() == 0) {
2212  IntSetArgs emptyIa(0);
2213  return emptyIa;
2214  }
2215  IntSetArgs ia(a->a.size()+offset);
2216  for (int i=offset; i--;)
2217  ia[i] = IntSet::empty;
2218  for (int i=a->a.size(); i--;) {
2219  ia[i+offset] = arg2intset(a->a[i]);
2220  }
2221  return ia;
2222  }
2223  IntVarArgs
2225  AST::Array* a = arg->getArray();
2226  if (a->a.size() == 0) {
2227  IntVarArgs emptyIa(0);
2228  return emptyIa;
2229  }
2230  IntVarArgs ia(a->a.size()+offset);
2231  for (int i=offset; i--;)
2232  ia[i] = IntVar(*this, 0, 0);
2233  for (int i=a->a.size(); i--;) {
2234  if (a->a[i]->isIntVar()) {
2235  ia[i+offset] = iv[a->a[i]->getIntVar()];
2236  } else {
2237  int value = a->a[i]->getInt();
2238  IntVar iv(*this, value, value);
2239  ia[i+offset] = iv;
2240  }
2241  }
2242  return ia;
2243  }
2244  BoolVarArgs
2245  FlatZincSpace::arg2boolvarargs(AST::Node* arg, int offset, int siv) {
2246  AST::Array* a = arg->getArray();
2247  if (a->a.size() == 0) {
2248  BoolVarArgs emptyIa(0);
2249  return emptyIa;
2250  }
2251  BoolVarArgs ia(a->a.size()+offset-(siv==-1?0:1));
2252  for (int i=offset; i--;)
2253  ia[i] = BoolVar(*this, 0, 0);
2254  for (int i=0; i<static_cast<int>(a->a.size()); i++) {
2255  if (i==siv)
2256  continue;
2257  if (a->a[i]->isBool()) {
2258  bool value = a->a[i]->getBool();
2259  BoolVar iv(*this, value, value);
2260  ia[offset++] = iv;
2261  } else if (a->a[i]->isIntVar() &&
2262  aliasBool2Int(a->a[i]->getIntVar()) != -1) {
2263  ia[offset++] = bv[aliasBool2Int(a->a[i]->getIntVar())];
2264  } else {
2265  ia[offset++] = bv[a->a[i]->getBoolVar()];
2266  }
2267  }
2268  return ia;
2269  }
2270  BoolVar
2272  BoolVar x0;
2273  if (n->isBool()) {
2274  x0 = BoolVar(*this, n->getBool(), n->getBool());
2275  }
2276  else {
2277  x0 = bv[n->getBoolVar()];
2278  }
2279  return x0;
2280  }
2281  IntVar
2283  IntVar x0;
2284  if (n->isIntVar()) {
2285  x0 = iv[n->getIntVar()];
2286  } else {
2287  x0 = IntVar(*this, n->getInt(), n->getInt());
2288  }
2289  return x0;
2290  }
2291  bool
2293  AST::Array* a = b->getArray();
2294  singleInt = -1;
2295  if (a->a.size() == 0)
2296  return true;
2297  for (int i=a->a.size(); i--;) {
2298  if (a->a[i]->isBoolVar() || a->a[i]->isBool()) {
2299  } else if (a->a[i]->isIntVar()) {
2300  if (aliasBool2Int(a->a[i]->getIntVar()) == -1) {
2301  if (singleInt != -1) {
2302  return false;
2303  }
2304  singleInt = i;
2305  }
2306  } else {
2307  return false;
2308  }
2309  }
2310  return singleInt==-1 || a->a.size() > 1;
2311  }
2312 #ifdef GECODE_HAS_SET_VARS
2313  SetVar
2315  SetVar x0;
2316  if (!n->isSetVar()) {
2317  IntSet d = arg2intset(n);
2318  x0 = SetVar(*this, d, d);
2319  } else {
2320  x0 = sv[n->getSetVar()];
2321  }
2322  return x0;
2323  }
2324  SetVarArgs
2325  FlatZincSpace::arg2setvarargs(AST::Node* arg, int offset, int doffset,
2326  const IntSet& od) {
2327  AST::Array* a = arg->getArray();
2328  SetVarArgs ia(a->a.size()+offset);
2329  for (int i=offset; i--;) {
2330  IntSet d = i<doffset ? od : IntSet::empty;
2331  ia[i] = SetVar(*this, d, d);
2332  }
2333  for (int i=a->a.size(); i--;) {
2334  ia[i+offset] = arg2SetVar(a->a[i]);
2335  }
2336  return ia;
2337  }
2338 #endif
2339 #ifdef GECODE_HAS_FLOAT_VARS
2340  FloatValArgs
2342  AST::Array* a = arg->getArray();
2343  FloatValArgs fa(a->a.size()+offset);
2344  for (int i=offset; i--;)
2345  fa[i] = 0.0;
2346  for (int i=a->a.size(); i--;)
2347  fa[i+offset] = a->a[i]->getFloat();
2348  return fa;
2349  }
2350  FloatVarArgs
2352  AST::Array* a = arg->getArray();
2353  if (a->a.size() == 0) {
2354  FloatVarArgs emptyFa(0);
2355  return emptyFa;
2356  }
2357  FloatVarArgs fa(a->a.size()+offset);
2358  for (int i=offset; i--;)
2359  fa[i] = FloatVar(*this, 0.0, 0.0);
2360  for (int i=a->a.size(); i--;) {
2361  if (a->a[i]->isFloatVar()) {
2362  fa[i+offset] = fv[a->a[i]->getFloatVar()];
2363  } else {
2364  double value = a->a[i]->getFloat();
2365  FloatVar fv(*this, value, value);
2366  fa[i+offset] = fv;
2367  }
2368  }
2369  return fa;
2370  }
2371  FloatVar
2373  FloatVar x0;
2374  if (n->isFloatVar()) {
2375  x0 = fv[n->getFloatVar()];
2376  } else {
2377  x0 = FloatVar(*this, n->getFloat(), n->getFloat());
2378  }
2379  return x0;
2380  }
2381 #endif
2382  IntPropLevel
2384  if (ann) {
2385  if (ann->hasAtom("val"))
2386  return IPL_VAL;
2387  if (ann->hasAtom("domain"))
2388  return IPL_DOM;
2389  if (ann->hasAtom("bounds") ||
2390  ann->hasAtom("boundsR") ||
2391  ann->hasAtom("boundsD") ||
2392  ann->hasAtom("boundsZ"))
2393  return IPL_BND;
2394  }
2395  return IPL_DEF;
2396  }
2397 
2398  DFA
2400  if (_initData) {
2401  FlatZincSpaceInitData::DFASet::iterator it = _initData->dfaSet.find(a);
2402  if (it != _initData->dfaSet.end()) {
2403  return *it;
2404  }
2405  _initData->dfaSet.insert(a);
2406  }
2407  return a;
2408  }
2409 
2410  void
2412  _output = output;
2413  }
2414 
2415  void
2416  Printer::printElem(std::ostream& out,
2417  AST::Node* ai,
2418  const Gecode::IntVarArray& iv,
2419  const Gecode::BoolVarArray& bv
2420 #ifdef GECODE_HAS_SET_VARS
2421  , const Gecode::SetVarArray& sv
2422 #endif
2423 #ifdef GECODE_HAS_FLOAT_VARS
2424  ,
2425  const Gecode::FloatVarArray& fv
2426 #endif
2427  ) const {
2428  int k;
2429  if (ai->isInt(k)) {
2430  out << k;
2431  } else if (ai->isIntVar()) {
2432  out << iv[ai->getIntVar()];
2433  } else if (ai->isBoolVar()) {
2434  if (bv[ai->getBoolVar()].min() == 1) {
2435  out << "true";
2436  } else if (bv[ai->getBoolVar()].max() == 0) {
2437  out << "false";
2438  } else {
2439  out << "false..true";
2440  }
2441 #ifdef GECODE_HAS_SET_VARS
2442  } else if (ai->isSetVar()) {
2443  if (!sv[ai->getSetVar()].assigned()) {
2444  out << sv[ai->getSetVar()];
2445  return;
2446  }
2447  SetVarGlbRanges svr(sv[ai->getSetVar()]);
2448  if (!svr()) {
2449  out << "{}";
2450  return;
2451  }
2452  int min = svr.min();
2453  int max = svr.max();
2454  ++svr;
2455  if (svr()) {
2456  SetVarGlbValues svv(sv[ai->getSetVar()]);
2457  int i = svv.val();
2458  out << "{" << i;
2459  ++svv;
2460  for (; svv(); ++svv)
2461  out << ", " << svv.val();
2462  out << "}";
2463  } else {
2464  out << min << ".." << max;
2465  }
2466 #endif
2467 #ifdef GECODE_HAS_FLOAT_VARS
2468  } else if (ai->isFloatVar()) {
2469  if (fv[ai->getFloatVar()].assigned()) {
2470  FloatVal vv = fv[ai->getFloatVar()].val();
2471  FloatNum v;
2472  if (vv.singleton())
2473  v = vv.min();
2474  else if (vv < 0.0)
2475  v = vv.max();
2476  else
2477  v = vv.min();
2478  std::ostringstream oss;
2479  // oss << std::scientific;
2480  oss << std::setprecision(std::numeric_limits<double>::digits10);
2481  oss << v;
2482  if (oss.str().find(".") == std::string::npos)
2483  oss << ".0";
2484  out << oss.str();
2485  } else {
2486  out << fv[ai->getFloatVar()];
2487  }
2488 #endif
2489  } else if (ai->isBool()) {
2490  out << (ai->getBool() ? "true" : "false");
2491  } else if (ai->isSet()) {
2492  AST::SetLit* s = ai->getSet();
2493  if (s->interval) {
2494  out << s->min << ".." << s->max;
2495  } else {
2496  out << "{";
2497  for (unsigned int i=0; i<s->s.size(); i++) {
2498  out << s->s[i] << (i < s->s.size()-1 ? ", " : "}");
2499  }
2500  }
2501  } else if (ai->isString()) {
2502  std::string s = ai->getString();
2503  for (unsigned int i=0; i<s.size(); i++) {
2504  if (s[i] == '\\' && i<s.size()-1) {
2505  switch (s[i+1]) {
2506  case 'n': out << "\n"; break;
2507  case '\\': out << "\\"; break;
2508  case 't': out << "\t"; break;
2509  default: out << "\\" << s[i+1];
2510  }
2511  i++;
2512  } else {
2513  out << s[i];
2514  }
2515  }
2516  }
2517  }
2518 
2519  void
2520  Printer::printElemDiff(std::ostream& out,
2521  AST::Node* ai,
2522  const Gecode::IntVarArray& iv1,
2523  const Gecode::IntVarArray& iv2,
2524  const Gecode::BoolVarArray& bv1,
2525  const Gecode::BoolVarArray& bv2
2526 #ifdef GECODE_HAS_SET_VARS
2527  , const Gecode::SetVarArray& sv1,
2528  const Gecode::SetVarArray& sv2
2529 #endif
2530 #ifdef GECODE_HAS_FLOAT_VARS
2531  , const Gecode::FloatVarArray& fv1,
2532  const Gecode::FloatVarArray& fv2
2533 #endif
2534  ) const {
2535 #ifdef GECODE_HAS_GIST
2536  using namespace Gecode::Gist;
2537  int k;
2538  if (ai->isInt(k)) {
2539  out << k;
2540  } else if (ai->isIntVar()) {
2541  std::string res(Comparator::compare("",iv1[ai->getIntVar()],
2542  iv2[ai->getIntVar()]));
2543  if (res.length() > 0) {
2544  res.erase(0, 1); // Remove '='
2545  out << res;
2546  } else {
2547  out << iv1[ai->getIntVar()];
2548  }
2549  } else if (ai->isBoolVar()) {
2550  std::string res(Comparator::compare("",bv1[ai->getBoolVar()],
2551  bv2[ai->getBoolVar()]));
2552  if (res.length() > 0) {
2553  res.erase(0, 1); // Remove '='
2554  out << res;
2555  } else {
2556  out << bv1[ai->getBoolVar()];
2557  }
2558 #ifdef GECODE_HAS_SET_VARS
2559  } else if (ai->isSetVar()) {
2560  std::string res(Comparator::compare("",sv1[ai->getSetVar()],
2561  sv2[ai->getSetVar()]));
2562  if (res.length() > 0) {
2563  res.erase(0, 1); // Remove '='
2564  out << res;
2565  } else {
2566  out << sv1[ai->getSetVar()];
2567  }
2568 #endif
2569 #ifdef GECODE_HAS_FLOAT_VARS
2570  } else if (ai->isFloatVar()) {
2571  std::string res(Comparator::compare("",fv1[ai->getFloatVar()],
2572  fv2[ai->getFloatVar()]));
2573  if (res.length() > 0) {
2574  res.erase(0, 1); // Remove '='
2575  out << res;
2576  } else {
2577  out << fv1[ai->getFloatVar()];
2578  }
2579 #endif
2580  } else if (ai->isBool()) {
2581  out << (ai->getBool() ? "true" : "false");
2582  } else if (ai->isSet()) {
2583  AST::SetLit* s = ai->getSet();
2584  if (s->interval) {
2585  out << s->min << ".." << s->max;
2586  } else {
2587  out << "{";
2588  for (unsigned int i=0; i<s->s.size(); i++) {
2589  out << s->s[i] << (i < s->s.size()-1 ? ", " : "}");
2590  }
2591  }
2592  } else if (ai->isString()) {
2593  std::string s = ai->getString();
2594  for (unsigned int i=0; i<s.size(); i++) {
2595  if (s[i] == '\\' && i<s.size()-1) {
2596  switch (s[i+1]) {
2597  case 'n': out << "\n"; break;
2598  case '\\': out << "\\"; break;
2599  case 't': out << "\t"; break;
2600  default: out << "\\" << s[i+1];
2601  }
2602  i++;
2603  } else {
2604  out << s[i];
2605  }
2606  }
2607  }
2608 #else
2609  (void) out;
2610  (void) ai;
2611  (void) iv1;
2612  (void) iv2;
2613  (void) bv1;
2614  (void) bv2;
2615 #ifdef GECODE_HAS_SET_VARS
2616  (void) sv1;
2617  (void) sv2;
2618 #endif
2619 #ifdef GECODE_HAS_FLOAT_VARS
2620  (void) fv1;
2621  (void) fv2;
2622 #endif
2623 
2624 #endif
2625  }
2626 
2627  void
2628  Printer::print(std::ostream& out,
2629  const Gecode::IntVarArray& iv,
2630  const Gecode::BoolVarArray& bv
2631 #ifdef GECODE_HAS_SET_VARS
2632  ,
2633  const Gecode::SetVarArray& sv
2634 #endif
2635 #ifdef GECODE_HAS_FLOAT_VARS
2636  ,
2637  const Gecode::FloatVarArray& fv
2638 #endif
2639  ) const {
2640  if (_output == NULL)
2641  return;
2642  for (unsigned int i=0; i< _output->a.size(); i++) {
2643  AST::Node* ai = _output->a[i];
2644  if (ai->isArray()) {
2645  AST::Array* aia = ai->getArray();
2646  int size = aia->a.size();
2647  out << "[";
2648  for (int j=0; j<size; j++) {
2649  printElem(out,aia->a[j],iv,bv
2650 #ifdef GECODE_HAS_SET_VARS
2651  ,sv
2652 #endif
2653 #ifdef GECODE_HAS_FLOAT_VARS
2654  ,fv
2655 #endif
2656  );
2657  if (j<size-1)
2658  out << ", ";
2659  }
2660  out << "]";
2661  } else {
2662  printElem(out,ai,iv,bv
2663 #ifdef GECODE_HAS_SET_VARS
2664  ,sv
2665 #endif
2666 #ifdef GECODE_HAS_FLOAT_VARS
2667  ,fv
2668 #endif
2669  );
2670  }
2671  }
2672  }
2673 
2674  void
2675  Printer::printDiff(std::ostream& out,
2676  const Gecode::IntVarArray& iv1,
2677  const Gecode::IntVarArray& iv2,
2678  const Gecode::BoolVarArray& bv1,
2679  const Gecode::BoolVarArray& bv2
2680 #ifdef GECODE_HAS_SET_VARS
2681  ,
2682  const Gecode::SetVarArray& sv1,
2683  const Gecode::SetVarArray& sv2
2684 #endif
2685 #ifdef GECODE_HAS_FLOAT_VARS
2686  ,
2687  const Gecode::FloatVarArray& fv1,
2688  const Gecode::FloatVarArray& fv2
2689 #endif
2690  ) const {
2691  if (_output == NULL)
2692  return;
2693  for (unsigned int i=0; i< _output->a.size(); i++) {
2694  AST::Node* ai = _output->a[i];
2695  if (ai->isArray()) {
2696  AST::Array* aia = ai->getArray();
2697  int size = aia->a.size();
2698  out << "[";
2699  for (int j=0; j<size; j++) {
2700  printElemDiff(out,aia->a[j],iv1,iv2,bv1,bv2
2701 #ifdef GECODE_HAS_SET_VARS
2702  ,sv1,sv2
2703 #endif
2704 #ifdef GECODE_HAS_FLOAT_VARS
2705  ,fv1,fv2
2706 #endif
2707  );
2708  if (j<size-1)
2709  out << ", ";
2710  }
2711  out << "]";
2712  } else {
2713  printElemDiff(out,ai,iv1,iv2,bv1,bv2
2714 #ifdef GECODE_HAS_SET_VARS
2715  ,sv1,sv2
2716 #endif
2717 #ifdef GECODE_HAS_FLOAT_VARS
2718  ,fv1,fv2
2719 #endif
2720  );
2721  }
2722  }
2723  }
2724 
2725  void
2726  Printer::addIntVarName(const std::string& n) {
2727  iv_names.push_back(n);
2728  }
2729  void
2730  Printer::addBoolVarName(const std::string& n) {
2731  bv_names.push_back(n);
2732  }
2733 #ifdef GECODE_HAS_FLOAT_VARS
2734  void
2735  Printer::addFloatVarName(const std::string& n) {
2736  fv_names.push_back(n);
2737  }
2738 #endif
2739 #ifdef GECODE_HAS_SET_VARS
2740  void
2741  Printer::addSetVarName(const std::string& n) {
2742  sv_names.push_back(n);
2743  }
2744 #endif
2745 
2746  void
2748  std::map<int,int>& iv, std::map<int,int>& bv,
2749  std::map<int,int>& sv, std::map<int,int>& fv) {
2750  if (node->isIntVar()) {
2751  AST::IntVar* x = static_cast<AST::IntVar*>(node);
2752  if (iv.find(x->i) == iv.end()) {
2753  int newi = iv.size();
2754  iv[x->i] = newi;
2755  }
2756  x->i = iv[x->i];
2757  } else if (node->isBoolVar()) {
2758  AST::BoolVar* x = static_cast<AST::BoolVar*>(node);
2759  if (bv.find(x->i) == bv.end()) {
2760  int newi = bv.size();
2761  bv[x->i] = newi;
2762  }
2763  x->i = bv[x->i];
2764  } else if (node->isSetVar()) {
2765  AST::SetVar* x = static_cast<AST::SetVar*>(node);
2766  if (sv.find(x->i) == sv.end()) {
2767  int newi = sv.size();
2768  sv[x->i] = newi;
2769  }
2770  x->i = sv[x->i];
2771  } else if (node->isFloatVar()) {
2772  AST::FloatVar* x = static_cast<AST::FloatVar*>(node);
2773  if (fv.find(x->i) == fv.end()) {
2774  int newi = fv.size();
2775  fv[x->i] = newi;
2776  }
2777  x->i = fv[x->i];
2778  }
2779  }
2780 
2781  void
2783  int& optVar, bool optVarIsInt,
2784  Gecode::IntVarArray& iv,
2786 #ifdef GECODE_HAS_SET_VARS
2787  ,
2789 #endif
2790 #ifdef GECODE_HAS_FLOAT_VARS
2791  ,
2793 #endif
2794  ) {
2795  if (_output == NULL) {
2796  if (optVarIsInt && optVar != -1) {
2797  IntVar ov = iv[optVar];
2798  iv = IntVarArray(home, 1);
2799  iv[0] = ov;
2800  optVar = 0;
2801  } else {
2802  iv = IntVarArray(home, 0);
2803  }
2804  bv = BoolVarArray(home, 0);
2805 #ifdef GECODE_HAS_SET_VARS
2806  sv = SetVarArray(home, 0);
2807 #endif
2808 #ifdef GECODE_HAS_FLOAT_VARS
2809  if (!optVarIsInt && optVar != -1) {
2810  FloatVar ov = fv[optVar];
2811  fv = FloatVarArray(home, 1);
2812  fv[0] = ov;
2813  optVar = 0;
2814  } else {
2815  fv = FloatVarArray(home,0);
2816  }
2817 #endif
2818  return;
2819  }
2820  std::map<int,int> iv_new;
2821  std::map<int,int> bv_new;
2822  std::map<int,int> sv_new;
2823  std::map<int,int> fv_new;
2824 
2825  if (optVar != -1) {
2826  if (optVarIsInt)
2827  iv_new[optVar] = 0;
2828  else
2829  fv_new[optVar] = 0;
2830  optVar = 0;
2831  }
2832 
2833  for (unsigned int i=0; i< _output->a.size(); i++) {
2834  AST::Node* ai = _output->a[i];
2835  if (ai->isArray()) {
2836  AST::Array* aia = ai->getArray();
2837  for (unsigned int j=0; j<aia->a.size(); j++) {
2838  shrinkElement(aia->a[j],iv_new,bv_new,sv_new,fv_new);
2839  }
2840  } else {
2841  shrinkElement(ai,iv_new,bv_new,sv_new,fv_new);
2842  }
2843  }
2844 
2845  IntVarArgs iva(iv_new.size());
2846  for (std::map<int,int>::iterator i=iv_new.begin(); i != iv_new.end(); ++i) {
2847  iva[(*i).second] = iv[(*i).first];
2848  }
2849  iv = IntVarArray(home, iva);
2850 
2851  BoolVarArgs bva(bv_new.size());
2852  for (std::map<int,int>::iterator i=bv_new.begin(); i != bv_new.end(); ++i) {
2853  bva[(*i).second] = bv[(*i).first];
2854  }
2855  bv = BoolVarArray(home, bva);
2856 
2857 #ifdef GECODE_HAS_SET_VARS
2858  SetVarArgs sva(sv_new.size());
2859  for (std::map<int,int>::iterator i=sv_new.begin(); i != sv_new.end(); ++i) {
2860  sva[(*i).second] = sv[(*i).first];
2861  }
2862  sv = SetVarArray(home, sva);
2863 #endif
2864 
2865 #ifdef GECODE_HAS_FLOAT_VARS
2866  FloatVarArgs fva(fv_new.size());
2867  for (std::map<int,int>::iterator i=fv_new.begin(); i != fv_new.end(); ++i) {
2868  fva[(*i).second] = fv[(*i).first];
2869  }
2870  fv = FloatVarArray(home, fva);
2871 #endif
2872  }
2873 
2875  delete _output;
2876  }
2877 
2878 }}
2879 
2880 // STATISTICS: flatzinc-any
void click(Inspector *i)
Add inspector that reacts on node double clicks.
Definition: gist.hpp:170
void shrinkArrays(Printer &p)
Remove all variables not needed for output.
Definition: flatzinc.cpp:2107
unsigned int a_d
Create a clone during recomputation if distance is greater than a_d (adaptive distance) ...
Definition: search.hh:753
BoolValBranch BOOL_VAL_RND(Rnd r)
Select random value.
Definition: val.hpp:140
Bounds propagation.
Definition: int.hh:953
Which values to select for branching first.
Definition: set.hh:1445
Gecode::SetVarArray sv_aux
The introduced set variables.
Definition: flatzinc.hh:501
Restart with linear sequence.
Definition: driver.hh:109
int floatVarCount
Number of float variables.
Definition: flatzinc.hh:438
int val(void) const
Return assigned value (only if assigned)
Definition: int.hpp:70
const Gecode::FloatNum step
Definition: arithmetic.cpp:785
Passing float arguments.
Definition: float.hh:950
Option< AST::SetLit *> domain
Definition: varspec.hh:74
Options for running FlatZinc models
Definition: flatzinc.hh:226
SetVarBranch SET_VAR_SIZE_MIN(BranchTbl tbl)
Definition: var.hpp:206
NodeType t
Type of node.
Definition: bool-expr.cpp:230
unsigned int nogoods_limit
Depth limit for extraction of no-goods.
Definition: search.hh:761
virtual Choice * choice(Space &home)
Return choice.
Definition: flatzinc.cpp:189
IntVarBranch INT_VAR_NONE(void)
Select first unassigned variable.
Definition: var.hpp:96
RestartMode restart(void) const
Definition: flatzinc.hh:364
Combine variable selection criteria for tie-breaking.
Definition: tiebreak.hpp:38
IntSet vs2is(IntVarSpec *vs)
Definition: flatzinc.cpp:356
virtual void print(const Space &, const Gecode::Choice &c, unsigned int, std::ostream &o) const
Print explanation.
Definition: flatzinc.cpp:220
FlatZincGetInfo(const Printer &printer)
Definition: flatzinc.cpp:1746
Which values to select for branching first.
Definition: float.hh:1817
std::ostream & getStream(void)
Get the stream that is used to output text.
Definition: gist.cpp:85
BoolVarBranch BOOL_VAR_NONE(void)
Select first unassigned variable.
Definition: var.hpp:364
The shared handle.
FloatNum med(void) const
Return median of domain (closest representation)
Definition: float.hpp:68
void finalize(void)
Finalize tuple set.
Definition: tuple-set.hpp:155
IntArgs arg2intargs(AST::Node *arg, int offset=0)
Convert arg (array of integers) to IntArgs.
Definition: flatzinc.cpp:2119
void post(FlatZincSpace &s, const ConExpr &ce)
Post constraint specified by ce.
Definition: registry.cpp:59
FloatValBranch FLOAT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
Definition: val.hpp:60
BoolVarBranch BOOL_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
Definition: var.hpp:394
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:1653
Traits class for search engines.
Definition: flatzinc.cpp:1634
Search engine statistics
Definition: search.hh:145
Boolean variable node.
Definition: ast.hh:197
const int min
Smallest allowed integer in integer set.
Definition: set.hh:99
FloatVarArgs arg2floatvarargs(AST::Node *arg, int offset=0)
Convert n to FloatVarArgs.
Definition: flatzinc.cpp:2351
bool isBool(void)
Test if node is a Boolean node.
Definition: ast.hh:490
BoolAssign BOOL_ASSIGN_MIN(void)
Select smallest value.
Definition: assign.hpp:100
std::vector< bool > sv_introduced
Indicates whether a set variable is introduced by mzn2fzn.
Definition: flatzinc.hh:503
Class to send solution information to CPProfiler.
Definition: search.hh:421
void print(const Brancher &b, unsigned int a, int i, const FloatNumBranch &nl, std::ostream &o) const
Definition: flatzinc.cpp:298
Which values to select for branching first.
Definition: int.hh:4682
bool getBool(void)
Cast this node to a Boolean node.
Definition: ast.hh:446
int size(void) const
Return size of array (number of elements)
Definition: array.hpp:969
const FloatNum max
Largest allowed float value.
Definition: float.hh:844
Gecode::BoolVarArray bv
The Boolean variables.
Definition: flatzinc.hh:492
size_t operator()(const Gecode::DFA &d) const
Return hash key for d.
Definition: flatzinc.cpp:78
void put(unsigned int i)
Add i to the contents.
Definition: archive.hpp:174
void update(Space &home, VarArray< Var > &a)
Update array to be a clone of array a.
Definition: array.hpp:1056
Meth _method
Whether to solve as satisfaction or optimization problem.
Definition: flatzinc.hh:448
unsigned int c_d
Create a clone after every c_d commits (commit distance)
Definition: search.hh:751
FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
Definition: var.hpp:122
Cutoff generator appending two cutoff generators.
Definition: search.hh:634
T * alloc(long unsigned int n)
Allocate block of n objects of type T from region.
Definition: region.hpp:380
SetValBranch ann2svalsel(AST::Node *ann, std::string r0, std::string r1, Rnd rnd)
Definition: flatzinc.cpp:659
Which values to select for branching first.
Definition: int.hh:4647
Search engine options
Definition: search.hh:744
SetLit * getSet(void)
Cast this node to a set literal node.
Definition: ast.hh:458
void newIntVar(IntVarSpec *vs)
Create new integer variable from specification.
Definition: flatzinc.cpp:881
IntVarBranch INT_VAR_SIZE_MAX(BranchTbl tbl)
Select variable with largest domain size.
Definition: var.hpp:211
Group of branchers.
Definition: core.hpp:796
Abstract base class for comparators.
Definition: gist.hh:119
Call * getCall(void)
Return function call.
Definition: ast.hh:343
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:49
int getFloatVar(void)
Cast this node to a Float variable node.
Definition: ast.hh:428
Gecode::ScriptMode mode(void) const
Definition: flatzinc.hh:359
Gecode::IntVarArray iv
The integer variables.
Definition: flatzinc.hh:480
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition: arithmetic.cpp:41
static PropagatorGroup all
Group of all propagators.
Definition: core.hpp:786
void stop(Support::Timer &timer, std::ostream &os)
Get time since start of timer and print user friendly time information.
Definition: script.cpp:42
bool assigned(void) const
Test whether view is assigned.
Definition: var.hpp:119
IntAssign INT_ASSIGN_MED(void)
Select greatest value not greater than the median.
Definition: assign.hpp:60
Passing float variables.
Definition: float.hh:977
Specification for set variables.
Definition: varspec.hh:139
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:227
virtual void compare(const Space &s0, const Space &s1)
Use the compare method of the template class S to compare two spaces.
Definition: flatzinc.cpp:1717
size_t operator()(const Gecode::SharedArray< int > &x) const
Return hash key for x.
Definition: flatzinc.cpp:67
BranchInformation branchInfo
Information for printing branches.
Definition: flatzinc.hh:602
void compare(const Space &s, std::ostream &out) const
Compare this space with space s and print the differences on out.
Definition: flatzinc.cpp:2054
int boolVarCount
Number of Boolean variables.
Definition: flatzinc.hh:436
IntVarBranch INT_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
Definition: var.hpp:121
BoolVarBranch BOOL_VAR_ACTION_MIN(double d, BranchTbl tbl)
Select variable with lowest action with decay factor d.
Definition: var.hpp:414
bool assigned(void) const
Test if all variables are assigned.
Definition: array.hpp:1069
std::size_t hash(void) const
Return hash key.
Definition: dfa.hpp:189
IntVarBranch INT_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
Definition: var.hpp:126
bool singleton(void) const
Test whether float is a singleton.
Definition: val.hpp:92
AuxVarBrancher(Home home, TieBreak< IntVarBranch > int_varsel0, IntValBranch int_valsel0, TieBreak< BoolVarBranch > bool_varsel0, BoolValBranch bool_valsel0, SetVarBranch set_varsel0, SetValBranch set_valsel0, TieBreak< FloatVarBranch > float_varsel0, FloatValBranch float_valsel0)
Construct brancher.
Definition: flatzinc.cpp:107
void dom(Home home, FloatVar x, FloatVal n)
Propagates .
Definition: dom.cpp:40
bool optVarIsInt(void) const
Return whether variable used for optimization is integer (or float)
Definition: flatzinc.cpp:2037
Which values to select for assignment.
Definition: int.hh:4793
void minimize(int var, bool isInt, AST::Array *annotation)
Post that integer variable var should be minimized.
Definition: flatzinc.cpp:1608
unsigned long int fail
Number of failed nodes in search tree.
Definition: search.hh:148
bool isSetVar(void)
Test if node is a set variable node.
Definition: ast.hh:478
bool isBoolVar(void)
Test if node is a Boolean variable node.
Definition: ast.hh:474
virtual SharedHandle::Object * copy(void) const
Definition: flatzinc.cpp:280
std::vector< Node * > a
Definition: ast.hh:233
Information is provided by a restart-based engine.
Definition: core.hpp:1577
unsigned long int depth
Maximum depth of search stack.
Definition: search.hh:152
TieBreak< IntVarBranch > ann2ivarsel(AST::Node *ann, Rnd rnd, double decay)
Definition: flatzinc.cpp:400
Integer variable array.
Definition: int.hh:738
Restart with Luby sequence.
Definition: driver.hh:110
DFASet dfaSet
Hash table of DFAs.
Definition: flatzinc.cpp:768
bool profiler_info(void) const
Definition: flatzinc.hh:382
Definition: flatzinc.cpp:52
FloatValBranch ann2fvalsel(AST::Node *ann, std::string r0, std::string r1)
Definition: flatzinc.cpp:733
No restarts.
Definition: driver.hh:107
Rnd defrnd(0)
Uninitialized default random number generator.
Definition: flatzinc.hh:415
BoolAssign ann2asnbvalsel(AST::Node *ann, Rnd rnd)
Definition: flatzinc.cpp:603
Less ( )
Definition: float.hh:1069
BoolAssign BOOL_ASSIGN_MAX(void)
Select largest value.
Definition: assign.hpp:105
int vs2bsh(BoolVarSpec *bs)
Definition: flatzinc.cpp:388
IntVarBranch INT_VAR_REGRET_MIN_MAX(BranchTbl tbl)
Select variable with largest min-regret.
Definition: var.hpp:291
SetVarBranch SET_VAR_MAX_MAX(BranchTbl tbl)
Definition: var.hpp:201
void init(int intVars, int boolVars, int setVars, int floatVars)
Initialize space with given number of variables.
Definition: flatzinc.cpp:856
Handle to region.
Definition: region.hpp:53
Greater ( )
Definition: int.hh:906
static void explore(S *root, const FlatZincOptions &opt, Gist::Inspector *i, Gist::Comparator *c)
Definition: flatzinc.cpp:1641
BoolValBranch ann2bvalsel(AST::Node *ann, std::string &r0, std::string &r1, Rnd rnd)
Definition: flatzinc.cpp:552
Class to record search trace info for CPProfiler.
Definition: search.hh:418
void varValPrint(const Space &home, const Brancher &b, unsigned int a, Var, int i, const int &n, std::ostream &o)
Definition: flatzinc.cpp:340
void printIntVar(std::ostream &os, const std::string name, const Int::IntView &x)
Definition: flatzinc.cpp:1760
Meth method(void) const
Return whether to solve a satisfaction or optimization problem.
Definition: flatzinc.cpp:2027
void print(const Brancher &b, unsigned int a, int i, int n, std::ostream &o) const
Output branch information.
Definition: flatzinc.cpp:292
unsigned long int propagate
Number of propagator executions.
Definition: core.hpp:1653
#define forceinline
Definition: config.hpp:185
Search::Cutoff * createCutoff(const Options &o)
Create cutoff object from options.
Definition: script.hpp:153
const int max
Largest allowed integer in integer set.
Definition: set.hh:97
SetVarBranch SET_VAR_NONE(void)
Definition: var.hpp:96
Array * getArray(void)
Cast this node to an array node.
Definition: ast.hh:396
unsigned int id(void) const
Return a unique id for the group.
Definition: core.hpp:4893
const int max
Largest allowed integer value.
Definition: int.hh:112
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:247
Float variable array.
Definition: float.hh:1027
int vs2bsl(BoolVarSpec *bs)
Definition: flatzinc.cpp:376
Computation spaces.
Definition: core.hpp:1701
An inspector for printing simple text output.
Definition: flatzinc.cpp:1667
Abstract base class for inspectors.
Definition: gist.hh:99
FloatVarBranch FLOAT_VAR_NONE(void)
Select first unassigned variable.
Definition: var.hpp:97
IntSharedArray arg2intsharedarray(AST::Node *arg, int offset=0)
Convert arg (array of integers) to IntSharedArray.
Definition: flatzinc.cpp:2156
unsigned int profiler_port(void) const
Definition: flatzinc.hh:381
unsigned int size(Space &home) const
Return number of propagators in a group.
Definition: core.cpp:926
const int min
Smallest allowed integer value.
Definition: int.hh:114
Base-class for both propagators and branchers.
Definition: core.hpp:627
virtual size_t size(void) const
Report size occupied.
Definition: flatzinc.cpp:145
Statistics for execution of status
Definition: core.hpp:1650
virtual Gecode::Space * copy(void)
Copy function.
Definition: flatzinc.cpp:2022
void newSetVar(SetVarSpec *vs)
Create new set variable from specification.
Definition: flatzinc.cpp:920
IntAssign INT_ASSIGN_MIN(void)
Select smallest value.
Definition: assign.hpp:55
IntValBranch INT_VAL_RND(Rnd r)
Select random value.
Definition: val.hpp:70
virtual Choice * choice(const Space &, Archive &e)
Return choice.
Definition: flatzinc.cpp:211
std::vector< bool > iv_introduced
Indicates whether an integer variable is introduced by mzn2fzn.
Definition: flatzinc.hh:488
Gecode::IntSet d(v, 7)
IntVarBranch INT_VAR_MAX_MAX(BranchTbl tbl)
Select variable with largest max.
Definition: var.hpp:201
void newBoolVar(BoolVarSpec *vs)
Create new Boolean variable from specification.
Definition: flatzinc.cpp:908
const BoolInstr * bi[]
Definition: mm-bool.cpp:4169
IntSharedArray arg2boolsharedarray(AST::Node *arg, int offset=0)
Convert arg (array of integers) to IntSharedArray.
Definition: flatzinc.cpp:2180
bool alias
Whether the variable aliases another variable.
Definition: varspec.hh:59
SetVarBranch ann2svarsel(AST::Node *ann, Rnd rnd, double decay)
Definition: flatzinc.cpp:621
void start(void)
Start timer.
Definition: timer.hpp:66
DFA getSharedDFA(DFA &a)
Share DFA a if possible.
Definition: flatzinc.cpp:2399
SetVar arg2SetVar(AST::Node *n)
Convert n to SetVar.
Definition: flatzinc.cpp:2314
unsigned int nogoods_limit(void) const
Definition: flatzinc.hh:375
int getSetVar(void)
Cast this node to a set variable node.
Definition: ast.hh:434
double getFloat(void)
Cast this node to a Float node.
Definition: ast.hh:452
Gecode::FloatVal c(-8, 8)
std::size_t hash(void) const
Return hash key.
Definition: tuple-set.hpp:227
FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl)
Select variable with largest domain size.
Definition: var.hpp:212
Cutoff * cutoff
Cutoff for restart-based search.
Definition: search.hh:765
int optVar(void) const
Return index of variable used for optimization.
Definition: flatzinc.cpp:2032
double threads
Number of threads to use.
Definition: search.hh:749
void sort(TaskViewArray< TaskView > &t)
Sort task view array t according to sto and inc (increasing or decreasing)
Definition: sort.hpp:133
size_t operator()(const Gecode::TupleSet &x) const
Return hash key for x.
Definition: flatzinc.cpp:58
SetVarBranch SET_VAR_AFC_MAX(double d, BranchTbl tbl)
Definition: var.hpp:136
Deterministic finite automaton (DFA)
Definition: int.hh:2023
int p
Number of positive literals for node type.
Definition: bool-expr.cpp:232
IntVarBranch INT_VAR_ACTION_MAX(double d, BranchTbl tbl)
Select variable with highest action with decay factor d.
Definition: var.hpp:156
T * alloc(long unsigned int n)
Allocate block of n objects of type T from heap.
Definition: heap.hpp:431
Gecode::FloatVarArray fv
The float variables.
Definition: flatzinc.hh:507
const FloatNum min
Smallest allowed float value.
Definition: float.hh:846
BoolValBranch BOOL_VAL_MIN(void)
Select smallest value.
Definition: val.hpp:130
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:236
Gecode::IntArgs i(4, 1, 2, 3, 4)
IntAssign ann2asnivalsel(AST::Node *ann, Rnd rnd)
Definition: flatzinc.cpp:500
Base-class for branchers.
Definition: core.hpp:1401
FloatNum n
The middle value for branching.
Definition: float.hh:1462
virtual bool status(const Space &_home) const
Check status of brancher, return true if alternatives left.
Definition: flatzinc.cpp:170
BoolValBranch BOOL_VAL_MAX(void)
Select largest value.
Definition: val.hpp:135
int n
Number of negative literals for node type.
Definition: bool-expr.cpp:234
BrancherGroup group(void) const
Return group brancher belongs to.
Definition: core.hpp:3553
Equality ( )
Definition: int.hh:901
#define GECODE_HAS_SET_VARS
Definition: config.hpp:56
std::vector< bool > fv_introduced
Indicates whether a float variable is introduced by mzn2fzn.
Definition: flatzinc.hh:511
Options opt
The options.
Definition: test.cpp:97
IntPropLevel ann2ipl(AST::Node *ann)
Convert ann to integer propagation level.
Definition: flatzinc.cpp:2383
Option< std::pair< double, double > > domain
Definition: varspec.hh:121
int dfs(Space *root, const Gist::Options &opt)
Create a new stand-alone Gist for root.
Definition: gist.hpp:203
IntAssign INT_ASSIGN_RND(Rnd r)
Select random value.
Definition: assign.hpp:70
Depth-first branch-and-bound search engine.
Definition: search.hh:1069
static void post(Home home, TieBreak< IntVarBranch > int_varsel, IntValBranch int_valsel, TieBreak< BoolVarBranch > bool_varsel, BoolValBranch bool_valsel, SetVarBranch set_varsel, SetValBranch set_valsel, TieBreak< FloatVarBranch > float_varsel, FloatValBranch float_valsel)
Post brancher.
Definition: flatzinc.cpp:232
Execution has resulted in failure.
Definition: core.hpp:473
Specification for Boolean variables.
Definition: varspec.hh:97
Value description class for branching.
Definition: float.hh:1459
double threads(void) const
Definition: flatzinc.hh:348
const Space * last(void) const
Return last solution found (possibly NULL)
Definition: core.hpp:3058
Node representing an atom
Definition: ast.hh:290
SharedHandle::Object * object(void) const
Access to the shared object.
int _optVar
Index of the variable to optimize.
Definition: flatzinc.hh:443
int getIntVar(void)
Cast this node to an integer variable node.
Definition: ast.hh:416
void finalize(void)
Clean up when Gist exits.
Definition: gist.cpp:64
int size(void) const
Return number of elements.
Output support class for FlatZinc interpreter.
Definition: flatzinc.hh:107
IntVarBranch INT_VAR_MIN_MIN(BranchTbl tbl)
Select variable with smallest min.
Definition: var.hpp:186
IntVar arg2IntVar(AST::Node *n)
Convert n to IntVar.
Definition: flatzinc.cpp:2282
Choice(const Brancher &b, bool fail0)
Initialize choice for brancher b.
Definition: flatzinc.cpp:142
FZPrintingInspector(const Printer &p0)
Constructor.
Definition: flatzinc.cpp:1681
Space * clone(CloneStatistics &stat=unused_clone) const
Clone space.
Definition: core.hpp:3181
static void installCtrlHandler(bool install, bool force=false)
Install handler for catching Ctrl-C.
Definition: script.hpp:116
static Search::Stop * create(unsigned int node, unsigned int fail, unsigned int time, bool intr)
Create appropriate stop-object.
Definition: script.hpp:90
IntAssign INT_ASSIGN_MAX(void)
Select largest value.
Definition: assign.hpp:65
FloatNum min(void) const
Return minimum of domain.
Definition: float.hpp:60
Which integer or Boolean variable to select for branching.
Definition: branch.hh:44
Simple propagation levels.
Definition: int.hh:951
int getBoolVar(void)
Cast this node to a Boolean variable node.
Definition: ast.hh:422
The Gecode Interactive Search Tool.
virtual const char * what(void) const
Return information.
Definition: exception.cpp:55
Type type(void) const
Return type of information.
Definition: core.hpp:3039
virtual void archive(Archive &e) const
Archive into e.
Definition: flatzinc.cpp:149
bool isSet(void)
Test if node is a set literal node.
Definition: ast.hh:498
std::vector< int > s
Definition: ast.hh:175
void fail(void)
Fail space.
Definition: core.hpp:3949
unsigned int size(void) const
Return size (cardinality) of set.
Definition: int-set-1.hpp:157
BoolVarArgs arg2boolvarargs(AST::Node *arg, int offset=0, int siv=-1)
Convert arg to BoolVarArgs.
Definition: flatzinc.cpp:2245
IntValBranch INT_VAL_MIN(void)
Select smallest value.
Definition: val.hpp:55
struct Gecode::Space::@58::@59 p
Data only available during propagation or branching.
const std::string & floatVarName(int i) const
Definition: flatzinc.hh:192
std::string what(void) const
Definition: ast.hh:61
unsigned int size(I &i)
Size of all ranges of range iterator i.
void newFloatVar(FloatVarSpec *vs)
Create new float variable from specification.
Definition: flatzinc.cpp:967
static void explore(S *root, const FlatZincOptions &opt, Gist::Inspector *i, Gist::Comparator *c)
Definition: flatzinc.cpp:1655
Value propagation.
Definition: int.hh:952
virtual ExecStatus commit(Space &, const Gecode::Choice &c, unsigned int)
Perform commit for choice c.
Definition: flatzinc.cpp:216
int min(void) const
Return smallest value of range.
IntValBranch INT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
Definition: val.hpp:80
void shrinkElement(AST::Node *node, std::map< int, int > &iv, std::map< int, int > &bv, std::map< int, int > &sv, std::map< int, int > &fv)
Definition: flatzinc.cpp:2747
bool l
Whether to try the lower or upper half first.
Definition: float.hh:1464
const char * name(void) const
Return name of script.
Definition: options.hpp:166
IntVarBranch INT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
Definition: var.hpp:101
iterator begin(void)
Return an iterator at the beginning of the array.
Definition: array.hpp:1673
Iterator for the greatest lower bound ranges of a set variable.
Definition: set.hh:270
Gecode::BoolVarArray bv_aux
The introduced Boolean variables.
Definition: flatzinc.hh:494
struct Gecode::Space::@58::@60 c
Data available only during copying.
void branch(Home home, const IntVarArgs &x, const BoolVarArgs &y, IntBoolVarBranch vars, IntValBranch vals)
Branch function for integer and Boolean variables.
Definition: branch.cpp:120
bool clone
Whether engines create a clone when being initialized.
Definition: search.hh:747
int min(void) const
Return minimum of domain.
Definition: int.hpp:58
void print(std::ostream &out, const Gecode::IntVarArray &iv, const Gecode::BoolVarArray &bv, const Gecode::SetVarArray &sv, const Gecode::FloatVarArray &fv) const
Definition: flatzinc.cpp:2628
Array * getArgs(unsigned int n)
Definition: ast.hh:265
BoolAssign BOOL_ASSIGN_RND(Rnd r)
Select random value.
Definition: assign.hpp:110
FlatZincSpaceInitData * _initData
Initialisation data (only used for posting constraints)
Definition: flatzinc.hh:432
FloatValBranch FLOAT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
Definition: val.hpp:55
void addSetVarName(const std::string &n)
Definition: flatzinc.cpp:2741
bool funcDep
Whether the variable functionally depends on another variable.
Definition: varspec.hh:65
Less ( )
Definition: int.hh:904
Integer sets.
Definition: int.hh:170
const int * pi[]
Definition: photo.cpp:14262
void createBranchers(Printer &p, AST::Node *ann, FlatZincOptions &opt, bool ignoreUnknown, std::ostream &err=std::cerr)
Create branchers corresponding to the solve item annotations.
Definition: flatzinc.cpp:1037
SetVarBranch SET_VAR_AFC_MIN(double d, BranchTbl tbl)
Definition: var.hpp:126
IntVarBranch INT_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
Definition: var.hpp:136
FloatVarBranch FLOAT_VAR_AFC_MIN(double d, BranchTbl tbl)
Select variable with smallest accumulated failure count with decay factor d.
Definition: var.hpp:127
Float variable node.
Definition: ast.hh:214
virtual std::string getInfo(const Space &space) const
Return info for a space.
Definition: flatzinc.cpp:1748
virtual void compare(const Space &s0, const Space &s1)=0
Call-back function.
Set variable node
Definition: ast.hh:222
Choice that only signals failure or success
Definition: flatzinc.cpp:137
bool range(void) const
Test whether domain is a range.
Definition: int.hpp:103
SetVarBranch SET_VAR_RND(Rnd r)
Definition: var.hpp:101
IntSharedArraySet intSharedArraySet
Hash table of shared integer arrays.
Definition: flatzinc.cpp:763
A simple comparator.
Definition: gist.hh:211
unsigned int node(void) const
Definition: flatzinc.hh:352
Option< AST::SetLit *> domain
Definition: varspec.hh:99
TieBreak< BoolVarBranch > ann2bvarsel(AST::Node *ann, Rnd rnd, double decay)
Definition: flatzinc.cpp:518
IntVarArgs arg2intvarargs(AST::Node *arg, int offset=0)
Convert arg to IntVarArgs.
Definition: flatzinc.cpp:2224
virtual void constrain(const Space &s)
Implement optimization.
Definition: flatzinc.cpp:1977
SearchTracer * tracer
Tracer object for tracing search.
Definition: search.hh:767
bool isIntVar(void)
Test if node is an integer variable node.
Definition: ast.hh:470
std::unordered_set< SharedArray< int > > IntSharedArraySet
Hash table of shared integer arrays.
Definition: flatzinc.cpp:761
const std::string & intVarName(int i) const
Definition: flatzinc.hh:187
FloatVarBranch FLOAT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
Definition: var.hpp:112
Passing integer variables.
Definition: int.hh:633
bool isBoolArray(AST::Node *b, int &singleInt)
Check if b is array of Booleans (or has a single integer)
Definition: flatzinc.cpp:2292
std::vector< bool > bv_introduced
Indicates whether a Boolean variable is introduced by mzn2fzn.
Definition: flatzinc.hh:496
SetValBranch SET_VAL_MIN_EXC(void)
Definition: val.hpp:60
SharedArray< int > IntSharedArray
Arrays of integers that can be shared among several element constraints.
Definition: int.hh:1451
bool done
Flag whether brancher is done.
Definition: flatzinc.cpp:105
Passing integer arguments.
Definition: int.hh:604
Passing Boolean variables.
Definition: int.hh:687
SetValBranch SET_VAL_MIN_INC(void)
Definition: val.hpp:55
static const IntSet empty
Empty set.
Definition: int.hh:259
bool isInt(int &i)
Test if node is int, if yes set i to the value.
Definition: ast.hh:364
Float view for float variables.
Definition: view.hpp:52
bool _optVarIsInt
Whether variable to optimize is integer (or float)
Definition: flatzinc.hh:445
FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl)
Select variable with smallest domain size.
Definition: var.hpp:207
IntSet arg2intset(AST::Node *n)
Convert n to IntSet.
Definition: flatzinc.cpp:2194
Gecode::FloatVarArray fv_aux
The introduced float variables.
Definition: flatzinc.hh:509
void add(BrancherGroup bg, const std::string &rel0, const std::string &rel1, const std::vector< std::string > &n)
Add new brancher information.
Definition: flatzinc.cpp:321
Boolean variable array.
Definition: int.hh:783
Greater ( )
Definition: float.hh:1071
Boolean integer variables.
Definition: int.hh:488
bool isString(void)
Test if node is a string node.
Definition: ast.hh:502
SetValBranch SET_VAL_MAX_EXC(void)
Definition: val.hpp:80
Post propagator for SetVar SetOpType SetVar SetRelType r
Definition: set.hh:765
virtual bool slave(const MetaInfo &mi)
Slave function for restarts.
Definition: flatzinc.cpp:1998
void init(void)
Initialize the implementation object.
Definition: gist.cpp:77
const int v[7]
Definition: distinct.cpp:259
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition: arithmetic.cpp:67
Class represeting a set of tuples.
Definition: int.hh:2140
bool assigned
Whether the variable is assigned.
Definition: varspec.hh:61
IntValBranch INT_VAL_MAX(void)
Select largest value.
Definition: val.hpp:65
SetValBranch SET_VAL_MAX_INC(void)
Definition: val.hpp:75
IntPropLevel
Propagation levels for integer propagators.
Definition: int.hh:949
Cutoff generator for constant sequence.
Definition: search.hh:523
AST::Array * args
Constraint arguments.
Definition: conexpr.hh:48
int getInt(void)
Cast this node to an integer node.
Definition: ast.hh:440
void print(std::basic_ostream< Char, Traits > &s, bool assigned, IL &lb, IU &ub, unsigned int cardMin, unsigned int cardMax)
Print set view.
Definition: print.hpp:63
struct Gecode::@585::NNF::@62::@63 b
For binary nodes (and, or, eqv)
Integer variable node.
Definition: ast.hh:206
void printDiff(std::ostream &out, const Gecode::IntVarArray &iv1, const Gecode::IntVarArray &iv2, const Gecode::BoolVarArray &bv1, const Gecode::BoolVarArray &bv2, const Gecode::SetVarArray &sv1, const Gecode::SetVarArray &sv2, const Gecode::FloatVarArray &fv1, const Gecode::FloatVarArray &fv2) const
Definition: flatzinc.cpp:2675
Passing set variables.
Definition: set.hh:488
IntVarBranch INT_VAR_SIZE_MIN(BranchTbl tbl)
Select variable with smallest domain size.
Definition: var.hpp:206
Post propagator for f(x \diamond_{\mathit{op}} y) \sim_r z \f$ void rel(Home home
Integer view for integer variables.
Definition: view.hpp:129
SetVarBranch SET_VAR_SIZE_MAX(BranchTbl tbl)
Definition: var.hpp:211
void postConstraints(std::vector< ConExpr *> &ces)
Post a constraint specified by ce.
Definition: flatzinc.cpp:1004
BoolVarBranch BOOL_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
Definition: var.hpp:404
bool assigned(void) const
Test whether view is assigned.
Definition: view.hpp:504
Exception: Base-class for exceptions
Definition: exception.hpp:42
Print statistics for script.
Definition: driver.hh:97
Base class for variables.
Definition: var.hpp:40
Float value type.
Definition: float.hh:334
IntValBranch INT_VALUES_MIN(void)
Try all values starting from smallest.
Definition: val.hpp:100
Run script with CP-profiler.
Definition: driver.hh:99
void free(T *b, long unsigned int n)
Delete n objects starting at b.
Definition: heap.hpp:457
virtual void print(std::ostream &)=0
Output string representation.
BranchInformation(void)
Constructor.
Definition: flatzinc.cpp:308
Exception signaling type error
Definition: ast.hh:55
Node * x
Pointer to corresponding Boolean expression node.
Definition: bool-expr.cpp:249
BoolVarBranch BOOL_VAR_DEGREE_MAX(BranchTbl tbl)
Select variable with largest degree.
Definition: var.hpp:389
Set variables
Definition: set.hh:127
FloatNum max(void) const
Return maximum of domain.
Definition: float.hpp:64
Home operator()(Propagator &p)
Return a home for this space with the information that p is being rewritten.
Definition: core.hpp:3244
void print(std::ostream &out, const Printer &p) const
Produce output on out using p.
Definition: flatzinc.cpp:2042
virtual void archive(Archive &e) const
Archive into e.
Definition: core.cpp:863
struct Gecode::@585::NNF::@62::@64 a
For atomic nodes.
Choice for performing commit
Definition: core.hpp:1371
unsigned int fail(void) const
Definition: flatzinc.hh:353
bool hasAtom(const std::string &id)
Test if node has atom with id.
Definition: ast.hh:321
virtual Actor * copy(Space &home)
Copy brancher.
Definition: flatzinc.cpp:228
Restart with geometric sequence.
Definition: driver.hh:111
bool isFloatVar(void)
Test if node is a float variable node.
Definition: ast.hh:482
Archive representation
Definition: archive.hpp:42
int i
Variable index.
Definition: varspec.hh:57
IntBoolVarBranch INTBOOL_VAR_AFC_SIZE_MAX(double d=1.0)
Select variable with largest accumulated failure count divided by domain size.
Definition: branch.hpp:138
Set literal node
Definition: ast.hh:171
void init(void)
Initialise for use.
Definition: flatzinc.cpp:315
ExecStatus
Definition: core.hpp:471
void flattenAnnotations(AST::Array *ann, std::vector< AST::Node *> &out)
Definition: flatzinc.cpp:1022
SetVarBranch SET_VAR_AFC_SIZE_MIN(double d, BranchTbl tbl)
Definition: var.hpp:226
FloatVarBranch FLOAT_VAR_AFC_MAX(double d, BranchTbl tbl)
Select variable with largest accumulated failure count with decay factor d.
Definition: var.hpp:137
Integer variables.
Definition: int.hh:347
Heap heap
The single global heap.
Definition: heap.cpp:44
Iterator for the values in the greatest lower bound of a set variable.
Definition: set.hh:366
FlatZincSpace(FlatZincSpace &)
Copy constructor.
Definition: flatzinc.cpp:774
IntVarBranch INT_VAR_ACTION_MIN(double d, BranchTbl tbl)
Select variable with lowest action with decay factor d.
Definition: var.hpp:146
BoolVarBranch BOOL_VAR_ACTION_MAX(double d, BranchTbl tbl)
Select variable with highest action with decay factor d.
Definition: var.hpp:424
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:226
Which values to select for assignment.
Definition: int.hh:4764
std::unordered_set< TupleSet > TupleSetSet
Hash table of tuple sets.
Definition: flatzinc.cpp:756
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n)
Propagates .
Definition: rel.cpp:43
Exception class for FlatZinc errors
Definition: flatzinc.hh:660
Specification for floating point variables.
Definition: varspec.hh:119
FloatVarBranch FLOAT_VAR_ACTION_MIN(double d, BranchTbl tbl)
Select variable with lowest action with decay factor d.
Definition: var.hpp:147
Domain propagation Options: basic versus advanced propagation.
Definition: int.hh:954
TieBreak< FloatVarBranch > ann2fvarsel(AST::Node *ann, Rnd rnd, double decay)
Definition: flatzinc.cpp:689
unsigned long int restart(void) const
Return number of restarts.
Definition: core.hpp:3043
int bab(Space *root, const Gist::Options &opt)
Create a new stand-alone Gist for branch-and-bound search of root.
Definition: gist.hpp:208
AST::Array * _solveAnnotations
Annotations on the solve item.
Definition: flatzinc.hh:460
virtual void inspect(const Space &node)
Use the print method of the template class S to print a space.
Definition: flatzinc.cpp:1686
unsigned int c_d(void) const
Definition: flatzinc.hh:350
IntValBranch INT_VAL_MED(void)
Select greatest value not greater than the median.
Definition: val.hpp:60
std::unordered_set< DFA > DFASet
Hash table of DFAs.
Definition: flatzinc.cpp:766
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:246
void printFloatVar(std::ostream &os, const std::string name, const Float::FloatView &f)
Definition: flatzinc.cpp:1786
~FlatZincSpace(void)
Destructor.
Definition: flatzinc.cpp:1623
An window for simple text output.
Definition: gist.hh:160
void add(BrancherGroup bg, const std::string &rel0, const std::string &rel1, const std::vector< std::string > &n)
Add new brancher information.
Definition: flatzinc.cpp:284
Run script in Gist.
Definition: driver.hh:98
bool needAuxVars
Whether the introduced variables still need to be copied.
Definition: flatzinc.hh:516
double restart_base(void) const
Definition: flatzinc.hh:370
virtual std::string name(void)
Return name.
Definition: gist.hpp:55
void printBoolVar(std::ostream &os, const std::string name, const BoolVar &b)
Definition: flatzinc.cpp:1779
int max(void) const
Return largest value of range.
void solve(AST::Array *annotation)
Post the solve item.
Definition: flatzinc.cpp:1602
unsigned int time(void) const
Definition: flatzinc.hh:354
Post propagator for SetVar x
Definition: set.hh:765
Execution is okay.
Definition: core.hpp:475
unsigned long int restart
Number of restarts.
Definition: search.hh:154
AST::Array * solveAnnotations(void) const
Return the solve item annotations.
Definition: flatzinc.cpp:1597
BoolVarBranch BOOL_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking)
Definition: var.hpp:369
TieBreak< FloatVarBranch > float_varsel
Definition: flatzinc.cpp:164
bool isArray(void)
Test if node is an array node.
Definition: ast.hh:506
TupleSet & add(const IntArgs &t)
Add tuple t to tuple set.
Definition: tuple-set.hpp:142
Float variables.
Definition: float.hh:870
void aliasBool2Int(int iv, int bv)
Link integer variable iv to Boolean variable bv.
Definition: flatzinc.cpp:899
Rnd _random
Random number generator.
Definition: flatzinc.hh:457
FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl)
Select variable with smallest min.
Definition: var.hpp:187
#define GECODE_HAS_FLOAT_VARS
Definition: config.hpp:35
A space that can be initialized with a FlatZinc model.
Definition: flatzinc.hh:423
Gecode::IntVarArray iv_aux
The introduced integer variables.
Definition: flatzinc.hh:482
unsigned int restart_scale(void) const
Definition: flatzinc.hh:372
Set variable array
Definition: set.hh:568
void addBoolVarName(const std::string &n)
Definition: flatzinc.cpp:2730
void shrinkArrays(Space &home, int &optVar, bool optVarIsInt, Gecode::IntVarArray &iv, Gecode::BoolVarArray &bv, Gecode::SetVarArray &sv, Gecode::FloatVarArray &fv)
Definition: flatzinc.cpp:2782
TieBreak< BoolVarBranch > bool_varsel
Definition: flatzinc.cpp:157
CompareStatus compare(I &i, J &j)
Check whether range iterator i is a subset of j, or whether they are disjoint.
Stop * stop
Stop object for stopping search.
Definition: search.hh:763
class Gecode::Gist::Options::_I inspect
const std::string & setVarName(int i) const
Definition: flatzinc.hh:196
IntValBranch INT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
Definition: val.hpp:75
int explore(Space *root, bool bab, const Options &opt)
Create a new stand-alone Gist for root using bab.
Definition: gist.cpp:102
void print(const Brancher &b, unsigned int a, int i, int n, std::ostream &o) const
Output branch information.
Definition: flatzinc.cpp:328
void run(std::ostream &out, const Printer &p, const FlatZincOptions &opt, Gecode::Support::Timer &t_total)
Run the search.
Definition: flatzinc.cpp:1963
Gecode toplevel namespace
int max(void) const
Return maximum of domain.
Definition: int.hpp:62
Information passed by meta search engines.
Definition: core.hpp:1572
void addIntVarName(const std::string &n)
Definition: flatzinc.cpp:2726
int * iv_boolalias
Indicates whether an integer variable aliases a Boolean variable.
Definition: flatzinc.hh:490
unsigned long int node
Number of nodes expanded.
Definition: search.hh:150
void maximize(int var, bool isInt, AST::Array *annotation)
Post that integer variable var should be maximized.
Definition: flatzinc.cpp:1616
int setVarCount
Number of set variables.
Definition: flatzinc.hh:440
Node representing a function call
Definition: ast.hh:255
int intVarCount
Number of integer variables.
Definition: flatzinc.hh:434
unsigned int a_d(void) const
Definition: flatzinc.hh:351
FZPrintingComparator(const Printer &p0)
Constructor.
Definition: flatzinc.cpp:1712
IntValBranch ann2ivalsel(AST::Node *ann, std::string &r0, std::string &r1, Rnd rnd)
Definition: flatzinc.cpp:449
SetVarArgs arg2setvarargs(AST::Node *arg, int offset=0, int doffset=0, const IntSet &od=IntSet::empty)
Convert n to SetVarArgs.
Definition: flatzinc.cpp:2325
A node in a FlatZinc abstract syntax tree.
Definition: ast.hh:67
SetVarBranch SET_VAR_ACTION_MAX(double d, BranchTbl tbl)
Definition: var.hpp:156
SetVarBranch SET_VAR_MIN_MIN(BranchTbl tbl)
Definition: var.hpp:186
IntArgs arg2boolargs(AST::Node *arg, int offset=0)
Convert arg (array of Booleans) to IntArgs.
Definition: flatzinc.cpp:2170
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:257
Which variable to select for branching.
Definition: set.hh:1294
Random number generator.
Definition: rnd.hpp:42
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:237
SetVarBranch SET_VAR_AFC_SIZE_MAX(double d, BranchTbl tbl)
Definition: var.hpp:236
void addFloatVarName(const std::string &n)
Definition: flatzinc.cpp:2735
Space is failed
Definition: core.hpp:1641
unsigned int _lns
Percentage of variables to keep in LNS (or 0 for no LNS)
Definition: flatzinc.hh:451
friend FloatVal max(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:386
iterator end(void)
Return an iterator past the end of the array.
Definition: array.hpp:1685
TupleSet arg2tupleset(AST::Node *n, int noOfVars)
Convert n to TupleSet.
Definition: flatzinc.cpp:2129
void assign(Home home, const FloatVarArgs &x, FloatAssign fa, FloatBranchFilter bf, FloatVarValPrint vvp)
Assign all x with value selection vals.
Definition: branch.cpp:111
FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl)
Select variable with largest max.
Definition: var.hpp:202
void varValPrintF(const Space &home, const Brancher &b, unsigned int a, FloatVar, int i, const FloatNumBranch &nl, std::ostream &o)
Definition: flatzinc.cpp:348
friend FloatVal min(const FloatVal &x, const FloatVal &y)
Definition: val.hpp:398
Gecode::SetVarArray sv
The set variables.
Definition: flatzinc.hh:499
Home class for posting propagators
Definition: core.hpp:853
FloatVarBranch FLOAT_VAR_ACTION_MAX(double d, BranchTbl tbl)
Select variable with highest action with decay factor d.
Definition: var.hpp:157
Options for Gist
Definition: gist.hh:234
std::string getDomains(const Printer &p) const
Get string representing the domains of variables (for cpprofiler)
Definition: flatzinc.cpp:1795
void cmb_hash(std::size_t &seed, const T h)
Combine hash value h into seed.
Definition: hash.hpp:44
double FloatNum
Floating point number base type.
Definition: float.hh:106
Specification for integer variables.
Definition: varspec.hh:72
void compare(Comparator *c)
Add comparator.
Definition: gist.hpp:182
SetVarBranch SET_VAR_ACTION_SIZE_MAX(double d, BranchTbl tbl)
Definition: var.hpp:256
const std::string & boolVarName(int i) const
Definition: flatzinc.hh:189
bool introduced
Whether the variable was introduced in the mzn2fzn translation.
Definition: varspec.hh:63
virtual void finalize(void)
Finalize when Gist exits.
Definition: flatzinc.cpp:1694
Restart with constant sequence.
Definition: driver.hh:108
std::string getString(void)
Cast this node to a string node.
Definition: ast.hh:464
Gecode::IntVarArray iv_lns
The integer variables used in LNS.
Definition: flatzinc.hh:485
FloatVar arg2FloatVar(AST::Node *n)
Convert n to FloatVar.
Definition: flatzinc.cpp:2372
Depth-first search engine.
Definition: search.hh:1035
Branching on the introduced variables.
Definition: flatzinc.cpp:102
const Val & some(void) const
Definition: option.hh:47
SetVarBranch SET_VAR_ACTION_SIZE_MIN(double d, BranchTbl tbl)
Definition: var.hpp:246
IntSharedArray _lnsInitialSolution
Initial solution to start the LNS (or NULL for no LNS)
Definition: flatzinc.hh:454
Registry & registry(void)
Return global registry object.
Definition: registry.cpp:53
TupleSetSet tupleSetSet
Hash table of tuple sets.
Definition: flatzinc.cpp:758
FloatValArgs arg2floatargs(AST::Node *arg, int offset=0)
Convert n to FloatValArgs.
Definition: flatzinc.cpp:2341
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:256
Option< AST::SetLit * > upperBound
Definition: varspec.hh:141
virtual size_t dispose(Space &)
Delete brancher and return its size.
Definition: flatzinc.cpp:259
T * a
Element array.
Definition: array.hpp:515
bool fail
Whether brancher should fail.
Definition: flatzinc.cpp:140
AuxVarBrancher(Space &home, AuxVarBrancher &b)
Copy constructor.
Definition: flatzinc.cpp:133
TieBreak< IntVarBranch > int_varsel
Definition: flatzinc.cpp:155
int val(void) const
Return assigned value.
Definition: bool.hpp:57
void init(AST::Array *output)
Definition: flatzinc.cpp:2411
BoolVar arg2BoolVar(AST::Node *n)
Convert n to BoolVar.
Definition: flatzinc.cpp:2271
IntSetArgs arg2intsetargs(AST::Node *arg, int offset=0)
Convert arg to IntSetArgs.
Definition: flatzinc.cpp:2209
SetVarBranch SET_VAR_ACTION_MIN(double d, BranchTbl tbl)
Definition: var.hpp:146
Abstract representation of a constraint.
Definition: conexpr.hh:43