1 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ 2 /* 3 * Main authors: 4 * Christian Schulte <schulte@gecode.org> 5 * 6 * Copyright: 7 * Christian Schulte, 2009 8 * 9 * This file is part of Gecode, the generic constraint 10 * development environment: 11 * http://www.gecode.org 12 * 13 * Permission is hereby granted, free of charge, to any person obtaining 14 * a copy of this software and associated documentation files (the 15 * "Software"), to deal in the Software without restriction, including 16 * without limitation the rights to use, copy, modify, merge, publish, 17 * distribute, sublicense, and/or sell copies of the Software, and to 18 * permit persons to whom the Software is furnished to do so, subject to 19 * the following conditions: 20 * 21 * The above copyright notice and this permission notice shall be 22 * included in all copies or substantial portions of the Software. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 28 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 29 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 30 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 31 * 32 */ 33 34 #ifndef GECODE_DRIVER_HH 35 #define GECODE_DRIVER_HH 36 37 #include <gecode/minimodel.hh> 38 #include <gecode/search.hh> 39 #ifdef GECODE_HAS_GIST 40 #include <gecode/gist.hh> 41 #endif 42 43 /* 44 * Configure linking 45 * 46 */ 47 #if !defined(GECODE_STATIC_LIBS) && \ 48 (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER)) 49 50 #ifdef GECODE_BUILD_DRIVER 51 #define GECODE_DRIVER_EXPORT __declspec( dllexport ) 52 #else 53 #define GECODE_DRIVER_EXPORT __declspec( dllimport ) 54 #endif 55 56 #else 57 58 #ifdef GECODE_GCC_HAS_CLASS_VISIBILITY 59 #define GECODE_DRIVER_EXPORT __attribute__ ((visibility("default"))) 60 #else 61 #define GECODE_DRIVER_EXPORT 62 #endif 63 64 #endif 65 66 // Configure auto-linking 67 #ifndef GECODE_BUILD_DRIVER 68 #define GECODE_LIBRARY_NAME "Driver" 69 #include <gecode/support/auto-link.hpp> 70 #endif 71 72 /** 73 * \namespace Gecode::Driver 74 * \brief Script commandline driver 75 * 76 * The Gecode::Driver namespace contains support for passing common 77 * commandline options and for scripts that use the commandline 78 * options. 79 * 80 */ 81 82 namespace Gecode { 83 84 85 /** 86 * \defgroup TaskDriverCmd Commandline options for running scripts 87 * \ingroup TaskDriver 88 */ 89 90 /** 91 * \brief Different modes for executing scripts 92 * \ingroup TaskDriverCmd 93 */ 94 enum ScriptMode { 95 SM_SOLUTION, ///< Print solution and some statistics 96 SM_TIME, ///< Measure average runtime 97 SM_STAT, ///< Print statistics for script 98 SM_GIST, ///< Run script in Gist 99 }; 100 101 /** 102 * \brief Different modes for restart-based search 103 * \ingroup TaskDriverCmd 104 */ 105 enum RestartMode { 106 RM_NONE, ///< No restarts 107 RM_CONSTANT, ///< Restart with constant sequence 108 RM_LINEAR, ///< Restart with linear sequence 109 RM_LUBY, ///< Restart with Luby sequence 110 RM_GEOMETRIC ///< Restart with geometric sequence 111 }; 112 113 class BaseOptions; 114 115 namespace Driver { 116 /** 117 * \brief Base class for options 118 * 119 */ 120 class GECODE_DRIVER_EXPORT BaseOption { 121 friend class Gecode::BaseOptions; 122 protected: 123 const char* eopt; ///< String for option (excluding hyphen) 124 const char* iopt; ///< String for option (including hyphen) 125 const char* exp; ///< Short explanation 126 BaseOption* next; ///< Next option 127 /// Check for option and return its argument 128 char* argument(int argc, char* argv[]) const; 129 public: 130 /// Initialize for option \a o and explanation \a e 131 BaseOption(const char* o, const char* e); 132 /// Parse option at first position and return number of parsed arguments 133 virtual int parse(int argc, char* argv[]) = 0; 134 /// Print help text 135 virtual void help(void) = 0; 136 /// Destructor 137 virtual ~BaseOption(void); 138 /// Create heap-allocated copy of string \a s 139 static char* strdup(const char* s); 140 /// Create heap-allocated copy of string \a s with hyphen added 141 static char* stredup(const char* s); 142 /// Delete heap-allocated copy of string \a s 143 static void strdel(const char* s); 144 }; 145 146 /** 147 * \brief String-valued option 148 * 149 */ 150 class GECODE_DRIVER_EXPORT StringValueOption : public BaseOption { 151 protected: 152 const char* cur; ///< Current value 153 public: 154 /// Initialize for option \a o and explanation \a e and default value \a v 155 StringValueOption(const char* o, const char* e, const char* v=nullptr); 156 /// Set default value to \a v 157 void value(const char* v); 158 /// Return current option value 159 const char* value(void) const; 160 /// Parse option at first position and return number of parsed arguments 161 virtual int parse(int argc, char* argv[]); 162 /// Print help text 163 virtual void help(void); 164 /// Destructor 165 virtual ~StringValueOption(void); 166 }; 167 168 169 /** 170 * \brief String-valued option (integer value defined by strings) 171 * 172 */ 173 class GECODE_DRIVER_EXPORT StringOption : public BaseOption { 174 protected: 175 /// Option value 176 class Value { 177 public: 178 int val; ///< Value for an option value 179 const char* opt; ///< String for option value 180 const char* help; ///< Optional help text 181 Value* next; ///< Next option value 182 }; 183 int cur; ///< Current value 184 Value* fst; ///< First option value 185 Value* lst; ///< Last option value 186 public: 187 /// Initialize for option \a o and explanation \a e and default value \a v 188 StringOption(const char* o, const char* e, int v=0); 189 /// Set default value to \a v 190 void value(int v); 191 /// Return current option value 192 int value(void) const; 193 /// Add option value for value \a v, string \a o, and help text \a h 194 void add(int v, const char* o, const char* h = nullptr); 195 /// Parse option at first position and return number of parsed arguments 196 virtual int parse(int argc, char* argv[]); 197 /// Print help text 198 virtual void help(void); 199 /// Destructor 200 virtual ~StringOption(void); 201 }; 202 203 204 /** 205 * \brief Integer option 206 * 207 */ 208 class GECODE_DRIVER_EXPORT IntOption : public BaseOption { 209 protected: 210 int cur; ///< Current value 211 public: 212 /// Initialize for option \a o and explanation \a e and default value \a v 213 IntOption(const char* o, const char* e, int v=0); 214 /// Set default value to \a v 215 void value(int v); 216 /// Return current option value 217 int value(void) const; 218 /// Parse option at first position and return number of parsed arguments 219 virtual int parse(int argc, char* argv[]); 220 /// Print help text 221 virtual void help(void); 222 }; 223 224 /** 225 * \brief Unsigned integer option 226 * 227 */ 228 class GECODE_DRIVER_EXPORT UnsignedIntOption : public BaseOption { 229 protected: 230 unsigned int cur; ///< Current value 231 public: 232 /// Initialize for option \a o and explanation \a e and default value \a v 233 UnsignedIntOption(const char* o, const char* e, unsigned int v=0); 234 /// Set default value to \a v 235 void value(unsigned int v); 236 /// Return current option value 237 unsigned int value(void) const; 238 /// Parse option at first position and return number of parsed arguments 239 virtual int parse(int argc, char* argv[]); 240 /// Print help text 241 virtual void help(void); 242 }; 243 244 /** 245 * \brief Unsigned long long integer option 246 * 247 */ 248 class GECODE_DRIVER_EXPORT UnsignedLongLongIntOption : public BaseOption { 249 protected: 250 unsigned long long int cur; ///< Current value 251 public: 252 /// Initialize for option \a o and explanation \a e and default value \a v 253 UnsignedLongLongIntOption(const char* o, const char* e, 254 unsigned long long int v=0); 255 /// Set default value to \a v 256 void value(unsigned long long int v); 257 /// Return current option value 258 unsigned long long int value(void) const; 259 /// Parse option at first position and return number of parsed arguments 260 virtual int parse(int argc, char* argv[]); 261 /// Print help text 262 virtual void help(void); 263 }; 264 265 /** 266 * \brief Double option 267 * 268 */ 269 class GECODE_DRIVER_EXPORT DoubleOption : public BaseOption { 270 protected: 271 double cur; ///< Current value 272 public: 273 /// Initialize for option \a o and explanation \a e and default value \a v 274 DoubleOption(const char* o, const char* e, double v=0); 275 /// Set default value to \a v 276 void value(double v); 277 /// Return current option value 278 double value(void) const; 279 /// Parse option at first position and return number of parsed arguments 280 virtual int parse(int argc, char* argv[]); 281 /// Print help text 282 virtual void help(void); 283 }; 284 285 /** 286 * \brief Boolean option 287 * 288 */ 289 class GECODE_DRIVER_EXPORT BoolOption : public BaseOption { 290 protected: 291 bool cur; ///< Current value 292 public: 293 /// Initialize for option \a o and explanation \a e and default value \a v 294 BoolOption(const char* o, const char* e, bool v=false); 295 /// Set default value to \a v 296 void value(bool v); 297 /// Return current option value 298 bool value(void) const; 299 /// Parse option at first position and return number of parsed arguments 300 virtual int parse(int argc, char* argv[]); 301 /// Print help text 302 virtual void help(void); 303 }; 304 305 /** 306 * \brief Integer propagation level option 307 * 308 */ 309 class GECODE_DRIVER_EXPORT IplOption : public BaseOption { 310 protected: 311 IntPropLevel cur; ///< Current value 312 public: 313 /// Initialize with default value \a ipl 314 IplOption(IntPropLevel ipl=IPL_DEF); 315 /// Set default level to \a l 316 void value(IntPropLevel l); 317 /// Return current option value 318 IntPropLevel value(void) const; 319 /// Parse option at first position and return number of parsed arguments 320 virtual int parse(int argc, char* argv[]); 321 /// Print help text 322 virtual void help(void); 323 }; 324 325 /** 326 * \brief Trace flag option 327 * 328 */ 329 class GECODE_DRIVER_EXPORT TraceOption : public BaseOption { 330 protected: 331 int cur; ///< Current value 332 public: 333 /// Initialize with no tracing 334 TraceOption(int f=0); 335 /// Set default trace flags to \a f 336 void value(int f); 337 /// Return current option value 338 int value(void) const; 339 /// Parse option at first position and return number of parsed arguments 340 virtual int parse(int argc, char* argv[]); 341 /// Print help text 342 virtual void help(void); 343 }; 344 345 /** 346 * \brief Profiler option 347 * 348 */ 349 class GECODE_DRIVER_EXPORT ProfilerOption : public BaseOption { 350 protected: 351 unsigned int cur_port; ///< Current port 352 int cur_execution_id; ///< Current execution ID 353 public: 354 /// Initialize for option \a o and explanation \a e and default value \a v 355 ProfilerOption(const char* o, const char* e, unsigned int p = 0, int v = -1); 356 /// Set default port to \a p 357 void port(unsigned int p); 358 /// Return current port 359 unsigned int port(void) const; 360 /// Set default execution ID to \a i 361 void execution_id(int i); 362 /// Return current execution ID 363 int execution_id(void) const; 364 /// Parse option at first position and return number of parsed arguments 365 virtual int parse(int argc, char* argv[]); 366 /// Print help text 367 virtual void help(void); 368 }; 369 } 370 371 /** 372 * \brief Base class for script options 373 * \ingroup TaskDriverCmd 374 */ 375 class GECODE_DRIVER_EXPORT BaseOptions { 376 protected: 377 Driver::BaseOption* fst; ///< First registered option 378 Driver::BaseOption* lst; ///< Last registered option 379 const char* _name; ///< Script name 380 public: 381 /// Initialize options for script with name \a s 382 BaseOptions(const char* s); 383 /// Print help text 384 virtual void help(void); 385 386 /// Add new option \a o 387 void add(Driver::BaseOption& o); 388 /** 389 * \brief Parse options from arguments \a argv (number is \a argc) 390 * 391 * The options are parsed from position one onwards until no more options 392 * are detected. After parsing, the parsed arguments have been removed. 393 * 394 */ 395 void parse(int& argc, char* argv[]); 396 397 /// Return name of script 398 const char* name(void) const; 399 /// Set name of script 400 void name(const char*); 401 402 /// Destructor 403 virtual ~BaseOptions(void); 404 }; 405 406 /** 407 * \brief %Options for scripts 408 * \ingroup TaskDriverCmd 409 */ 410 class GECODE_DRIVER_EXPORT Options : public BaseOptions { 411 protected: 412 /// \name Model options 413 //@{ 414 Driver::StringOption _model; ///< General model options 415 Driver::StringOption _symmetry; ///< General symmetry options 416 Driver::StringOption _propagation; ///< Propagation options 417 Driver::IplOption _ipl; ///< Integer propagation level 418 Driver::StringOption _branching; ///< Branching options 419 Driver::DoubleOption _decay; ///< Decay option 420 Driver::UnsignedIntOption _seed; ///< Seed option 421 Driver::DoubleOption _step; ///< Step option 422 //@} 423 424 /// \name Search options 425 //@{ 426 Driver::StringOption _search; ///< Search options 427 Driver::UnsignedLongLongIntOption 428 _solutions; ///< How many solutions 429 Driver::DoubleOption _threads; ///< How many threads to use 430 Driver::UnsignedIntOption _c_d; ///< Copy recomputation distance 431 Driver::UnsignedIntOption _a_d; ///< Adaptive recomputation distance 432 Driver::UnsignedIntOption _d_l; ///< Discrepancy limit for LDS 433 Driver::UnsignedLongLongIntOption 434 _node; ///< Cutoff for number of nodes 435 Driver::UnsignedLongLongIntOption 436 _fail; ///< Cutoff for number of failures 437 Driver::DoubleOption _time; ///< Cutoff for time 438 Driver::UnsignedIntOption _assets; ///< Number of assets in a portfolio 439 Driver::UnsignedIntOption _slice; ///< Size of a portfolio slice 440 Driver::StringOption _restart; ///< Restart method option 441 Driver::DoubleOption _r_base; ///< Restart base 442 Driver::UnsignedIntOption _r_scale; ///< Restart scale factor 443 Driver::BoolOption _nogoods; ///< Whether to use no-goods 444 Driver::UnsignedIntOption _nogoods_limit; ///< Limit for no-good extraction 445 Driver::DoubleOption _relax; ///< Probability to relax variable 446 Driver::BoolOption _interrupt; ///< Whether to catch SIGINT 447 //@} 448 449 /// \name Execution options 450 //@{ 451 Driver::StringOption _mode; ///< Script mode to run 452 Driver::UnsignedIntOption _samples; ///< How many samples 453 Driver::UnsignedIntOption _iterations; ///< How many iterations per sample 454 Driver::BoolOption _print_last; ///< Print only last solution found 455 Driver::StringValueOption _out_file; ///< Where to print solutions 456 Driver::StringValueOption _log_file; ///< Where to print statistics 457 Driver::TraceOption _trace; ///< Trace flags for tracing 458 459 #ifdef GECODE_HAS_CPPROFILER 460 Driver::ProfilerOption _profiler; ///< Options for the CP Profiler 461 #endif 462 463 //@} 464 465 public: 466 /// Initialize options for script with name \a s 467 Options(const char* s); 468 469 /// \name Model options 470 //@{ 471 /// Set default model value 472 void model(int v); 473 /// Add model option value for value \a v, string \a o, and help \a h 474 void model(int v, const char* o, const char* h = nullptr); 475 /// Return model value 476 int model(void) const; 477 478 /// Set default symmetry value 479 void symmetry(int v); 480 /// Add symmetry option value for value \a v, string \a o, and help \a h 481 void symmetry(int v, const char* o, const char* h = nullptr); 482 /// Return symmetry value 483 int symmetry(void) const; 484 485 /// Set default propagation value 486 void propagation(int v); 487 /// Add propagation option value for value \a v, string \a o, and help \a h 488 void propagation(int v, const char* o, const char* h = nullptr); 489 /// Return propagation value 490 int propagation(void) const; 491 492 /// Set default integer propagation level 493 void ipl(IntPropLevel i); 494 /// Return integer propagation level 495 IntPropLevel ipl(void) const; 496 497 /// Set default branching value 498 void branching(int v); 499 /// Add branching option value for value \a v, string \a o, and help \a h 500 void branching(int v, const char* o, const char* h = nullptr); 501 /// Return branching value 502 int branching(void) const; 503 504 /// Set default decay factor 505 void decay(double d); 506 /// Return decay factor 507 double decay(void) const; 508 509 /// Set default seed value 510 void seed(unsigned int s); 511 /// Return seed value 512 unsigned int seed(void) const; 513 514 /// Set default step value 515 void step(double s); 516 /// Return step value 517 double step(void) const; 518 //@} 519 520 /// \name Search options 521 //@{ 522 /// Set default search value 523 void search(int v); 524 /// Add search option value for value \a v, string \a o, and help \a h 525 void search(int v, const char* o, const char* h = nullptr); 526 /// Return search value 527 int search(void) const; 528 529 /// Set default number of solutions to search for 530 void solutions(unsigned long long int n); 531 /// Return number of solutions to search for 532 unsigned long long int solutions(void) const; 533 534 /// Set number of parallel threads 535 void threads(double n); 536 /// Return number of parallel threads 537 double threads(void) const; 538 539 /// Set default copy recomputation distance 540 void c_d(unsigned int d); 541 /// Return copy recomputation distance 542 unsigned int c_d(void) const; 543 544 /// Set default adaptive recomputation distance 545 void a_d(unsigned int d); 546 /// Return adaptive recomputation distance 547 unsigned int a_d(void) const; 548 549 /// Set default discrepancy limit for LDS 550 void d_l(unsigned int d); 551 /// Return discrepancy limit for LDS 552 unsigned int d_l(void) const; 553 554 /// Set default node cutoff 555 void node(unsigned long long int n); 556 /// Return node cutoff 557 unsigned long long int node(void) const; 558 559 /// Set default failure cutoff 560 void fail(unsigned long long int n); 561 /// Return failure cutoff 562 unsigned long long int fail(void) const; 563 564 /// Set default time cutoff 565 void time(double t); 566 /// Return time cutoff 567 double time(void) const; 568 569 /// Set default number of assets in a portfolio 570 void assets(unsigned int n); 571 /// Return slice size in a portfolio 572 unsigned int assets(void) const; 573 574 /// Set default slice size in a portfolio 575 void slice(unsigned int n); 576 /// Return slice size in a portfolio 577 unsigned int slice(void) const; 578 579 /// Set default restart mode 580 void restart(RestartMode r); 581 /// Return restart mode 582 RestartMode restart(void) const; 583 584 /// Set default restart base 585 void restart_base(double base); 586 /// Return restart base 587 double restart_base(void) const; 588 589 /// Set default restart scale factor 590 void restart_scale(unsigned int scale); 591 /// Return restart scale factor 592 unsigned int restart_scale(void) const; 593 594 /// Set default nogoods posting behavior 595 void nogoods(bool b); 596 /// Return whether nogoods are used 597 bool nogoods(void) const; 598 599 /// Set default nogoods depth limit 600 void nogoods_limit(unsigned int l); 601 /// Return depth limit for nogoods 602 unsigned int nogoods_limit(void) const; 603 604 /// Set default relax probability 605 void relax(double d); 606 /// Return default relax probability 607 double relax(void) const; 608 609 /// Set default interrupt behavior 610 void interrupt(bool b); 611 /// Return interrupt behavior 612 bool interrupt(void) const; 613 //@} 614 615 /// \name Execution options 616 //@{ 617 /// Set default mode 618 void mode(ScriptMode em); 619 /// Return mode 620 ScriptMode mode(void) const; 621 622 /// Set default number of samples 623 void samples(unsigned int s); 624 /// Return number of samples 625 unsigned int samples(void) const; 626 627 /// Set default number of iterations 628 void iterations(unsigned int i); 629 /// Return number of iterations 630 unsigned int iterations(void) const; 631 632 /// Set whether to print only last solution found 633 void print_last(bool p); 634 /// Return whether to print only last solution found 635 bool print_last(void) const; 636 637 /// Set default output file name for solutions 638 void out_file(const char* f); 639 /// Get file name for solutions 640 const char* out_file(void) const; 641 642 /// Set default output file name for Gecode stats 643 void log_file(const char* f); 644 /// Get file name for Gecode stats 645 const char* log_file(void) const; 646 647 /// Set trace flags 648 void trace(int f); 649 /// Return trace flags 650 int trace(void) const; 651 652 #ifdef GECODE_HAS_CPPROFILER 653 /// Set profiler execution identifier 654 void profiler_id(int i); 655 /// Return profiler execution id 656 int profiler_id(void) const; 657 /// Set profiler port 658 void profiler_port(unsigned int p); 659 /// Return profiler execution id 660 unsigned int profiler_port(void) const; 661 #endif 662 //@} 663 664 #ifdef GECODE_HAS_GIST 665 /// Helper class storing Gist inspectors 666 class I_ { 667 private: 668 /// The double click inspectors 669 Support::DynamicArray<Gist::Inspector*,Heap> _click; 670 /// Number of double click inspectors 671 unsigned int n_click; 672 /// The solution inspectors 673 Support::DynamicArray<Gist::Inspector*,Heap> _solution; 674 /// Number of solution inspectors 675 unsigned int n_solution; 676 /// The move inspectors 677 Support::DynamicArray<Gist::Inspector*,Heap> _move; 678 /// Number of move inspectors 679 unsigned int n_move; 680 /// The comparators 681 Support::DynamicArray<Gist::Comparator*,Heap> _compare; 682 /// Number of comparators 683 unsigned int n_compare; 684 public: 685 /// Constructor 686 I_(void); 687 /// Add inspector that reacts on node double clicks 688 void click(Gist::Inspector* i); 689 /// Add inspector that reacts on each new solution that is found 690 void solution(Gist::Inspector* i); 691 /// Add inspector that reacts on each move of the cursor 692 void move(Gist::Inspector* i); 693 /// Add comparator 694 void compare(Gist::Comparator* i); 695 696 /// Return click inspector number \a i, or nullptr if it does not exist 697 Gist::Inspector* click(unsigned int i) const; 698 /// Return solution inspector number \a i, or nullptr if it does not exist 699 Gist::Inspector* solution(unsigned int i) const; 700 /// Return move inspector number \a i, or nullptr if it does not exist 701 Gist::Inspector* move(unsigned int i) const; 702 /// Return comparator number \a i, or nullptr if it does not exist 703 Gist::Comparator* compare(unsigned int i) const; 704 } inspect; 705 #endif 706 }; 707 708 } 709 710 namespace Gecode { 711 712 /** 713 * \brief %Options for scripts with additional size parameter 714 * \ingroup TaskDriverCmd 715 */ 716 class GECODE_DRIVER_EXPORT SizeOptions : public Options { 717 protected: 718 unsigned int _size; ///< Size value 719 public: 720 /// Initialize options for script with name \a s 721 SizeOptions(const char* s); 722 /// Print help text 723 virtual void help(void); 724 /// Parse options from arguments \a argv (number is \a argc) 725 void parse(int& argc, char* argv[]); 726 727 /// Set default size 728 void size(unsigned int s); 729 /// Return size 730 unsigned int size(void) const; 731 }; 732 733 /** 734 * \brief %Options for scripts with additional instance parameter 735 * \ingroup TaskDriverCmd 736 */ 737 class GECODE_DRIVER_EXPORT InstanceOptions : public Options { 738 protected: 739 const char* _inst; ///< Instance string 740 public: 741 /// Initialize options for script with name \a s 742 InstanceOptions(const char* s); 743 /// Print help text 744 virtual void help(void); 745 /// Parse options from arguments \a argv (number is \a argc) 746 void parse(int& argc, char* argv[]); 747 748 /// Set default instance name 749 void instance(const char* s); 750 /// Return instance name 751 const char* instance(void) const; 752 /// Destructor 753 ~InstanceOptions(void); 754 }; 755 756 } 757 758 #include <gecode/driver/options.hpp> 759 760 namespace Gecode { namespace Driver { 761 762 /** 763 * \brief Parametric base-class for scripts 764 * 765 * All scripts must inherit from this class 766 * - adds printing and comparison for Gist to scripts 767 * - run allows to execute scripts 768 */ 769 template<class BaseSpace> 770 class ScriptBase : public BaseSpace { 771 public: 772 /// Constructor 773 ScriptBase(const Options& opt); 774 /// Constructor used for cloning 775 ScriptBase(ScriptBase& e); 776 /// Print a solution to \a os 777 virtual void print(std::ostream& os) const; 778 /// Compare with \a s 779 virtual void compare(const Space& home, std::ostream& os) const; 780 /// Choose output stream according to \a sn 781 static std::ostream& select_ostream(const char* sn, std::ofstream& ofs); 782 /** Run script with search engine \a Engine and options \a opt 783 * 784 * In the solution and stat modes, search can be aborted by sending 785 * SIGINT to the process (i.e., pressing Ctrl-C on the command 786 * line). 787 * 788 * In case \a s is different from nullptr, the search engine uses 789 * \a s as root of the search tree. 790 */ 791 template<class Script, template<class> class Engine, class Options> 792 static void run(const Options& opt, Script* s=nullptr); 793 private: 794 template<class Script, template<class> class Engine, class Options, 795 template<class, template<class> class> class Meta> 796 static void runMeta(const Options& opt, Script* s); 797 }; 798 799 #ifdef GECODE_HAS_FLOAT_VARS 800 801 /// Class to extract the step option value 802 template<class BaseSpace> 803 class ExtractStepOption : public BaseSpace { 804 public: 805 /// Constructor that extracts the step value ExtractStepOption(const Options & opt)806 ExtractStepOption(const Options& opt) 807 : BaseSpace(opt.step()) {} 808 /// Constructor used for cloning ExtractStepOption(BaseSpace & e)809 ExtractStepOption(BaseSpace& e) 810 : BaseSpace(e) {} 811 }; 812 813 #endif 814 815 /// Class to ignore the step option value 816 template<class BaseSpace> 817 class IgnoreStepOption : public BaseSpace { 818 public: 819 /// Constructor IgnoreStepOption(const Options &)820 IgnoreStepOption(const Options&) {} 821 /// Constructor used for cloning IgnoreStepOption(BaseSpace & e)822 IgnoreStepOption(BaseSpace& e) 823 : BaseSpace(e) {} 824 }; 825 826 }} 827 828 #include <gecode/driver/script.hpp> 829 830 namespace Gecode { 831 832 /** 833 * \defgroup TaskDriverScript Script classes 834 * \ingroup TaskDriver 835 */ 836 837 /** 838 * \brief Base-class for scripts 839 * \ingroup TaskDriverScript 840 */ 841 typedef Driver::ScriptBase<Driver::IgnoreStepOption<Space> > 842 Script; 843 844 /** 845 * \brief Base-class for scripts for finding solution of lowest integer cost 846 * \ingroup TaskDriverScript 847 */ 848 typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMinimizeSpace> > 849 IntMinimizeScript; 850 /** 851 * \brief Base-class for scripts for finding solution of highest integer cost 852 * \ingroup TaskDriverScript 853 */ 854 typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMaximizeSpace> > 855 IntMaximizeScript; 856 857 /** 858 * \brief Base-class for scripts for finding solution of lexically lowest integer costs 859 * \ingroup TaskDriverScript 860 */ 861 typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntLexMinimizeSpace> > 862 IntLexMinimizeScript; 863 /** 864 * \brief Base-class for scripts for finding solution of lexically highest integer costs 865 * \ingroup TaskDriverScript 866 */ 867 typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntLexMaximizeSpace> > 868 IntLexMaximizeScript; 869 870 #ifdef GECODE_HAS_FLOAT_VARS 871 872 /** 873 * \brief Base-class for scripts for finding solution of lowest float cost 874 * \ingroup TaskDriverScript 875 */ 876 typedef Driver::ScriptBase<Driver::ExtractStepOption<FloatMinimizeSpace> > 877 FloatMinimizeScript; 878 /** 879 * \brief Base-class for scripts for finding solution of highest float cost 880 * \ingroup TaskDriverScript 881 */ 882 typedef Driver::ScriptBase<Driver::ExtractStepOption<FloatMaximizeSpace> > 883 FloatMaximizeScript; 884 885 #endif 886 887 } 888 889 #endif 890 891 // STATISTICS: driver-any 892