pax_global_header00006660000000000000000000000064130413420610014504gustar00rootroot0000000000000052 comment=afc06a74d7b2e056979c869189ac96913d7cd8fa clasp-3.2.2/000077500000000000000000000000001304134206100126125ustar00rootroot00000000000000clasp-3.2.2/CHANGES000066400000000000000000001202311304134206100136040ustar00rootroot00000000000000clasp 3.2.2: Monday, 23rd January 2017 * added experimental support for MiniCard's CNF+ format * added missing stats key "summary.winner" for getting id of winner thread from clingo * fixed regression in sat/pb reader * fixed regression in handling of unsatisfiable optimization problems * fixed regression in component-wise shifting and preprocessing of disjunctive rules * fixed: ClaspFacade::startSolve() could produce duplicate and/or miss models * fixed: failed to handle empty clauses added from theory propagator * fixed: invalid logged lemmas due to buggy minimization in Solver::resolveToFlagged() * fixed: LogicProgram::dispose() must reset pointers * fixed compilation problems on Cygwin and Alpha clasp 3.2.1: Thursday, 13th October 2016 * added support for adding variables from theory propagator * fixed output of "--pre" wrt to externals in incremental setting * fixed regression in projective enumeration in incremental setting * fixed regression in handling of minimize statements containing only zero-weighted literals * fixed possible invalid access to empty input vector in ClaspAppBase::run() * added workaround to fix emcc code-gen bug * fixed type mismatch and warnings when compiled with x64 and _DEBUG * fixed compilation problems on MacOS and ARM clasp 3.2.0: Thursday, 8th September 2016 * added experimental support for new asp format and changed "--pre" option to use it * added propagator for acyclicity constraint (#edge-directive) * added option "--parse-ext" for enabling input extentions: - acyc constraints in smodels, dimacs, and opb format, - objective function in dimacs format, - projection, assumption, output, heuristic directives in dimacs and opb format * added stratification heuristic for weights in core-guided optimization enabled via "--opt-strategy=usc,{8-15}" * added support for parallel solving via C++11 threads instead of Intel TBB (see README) * added ClaspFacade::startSolve() for synchronous (possibly single-threaded) model generation * added option "--vsids-acids" for enabling average conflict-index decision scoring in vsids * added option "--vsids-progress" for enabling Glucose-style decreasing decay scheme * added option "--block-restarts" for enabling Glucose-style blocking of restarts * added option "--del-protect" for enabling Glucose-style temporary freezing of learnt nogods * option "--dom-mod" now also supports modifiers "factor" and "init" and also applies to problems in dimacs and opb format * added support for updating heuristic options in multishot solving (init-moms, score-res, score-other, berk-huang, dom-mod) * added support for config inheritance in portfolio configurations * changed default configuration of tester in disjunctive asp solving * improved handling of extended rules in computation of loop nogoods * improved handling of equivalent and complementary atoms in domain heuristic * option "--nant" now also applies to lookback heuristics * option "--lemma-out" now resolves lemmas to problem variables - added "--lemma-out-dom" for setting variable domain to either input or output - added "--lemma-out-txt" for logging lemmas in ground lp format - added "--lemma-out-max" for limiting number of logged lemmas * replaced "--sign-def=4" with "--sign-def-disj=" for setting default sign of disjunctive atoms * made lower bound updates in parallel optimization lock-free * switched to a more compact representation of input facts in smodels format * replaced old symbol table with simple output list clasp 3.1.5: Friday, 5th August 2016 (updated: 11th August 2016) * fixed: projective enumeration failed to work with option "--no-lookback" * fixed: invalid models in parallel disjunctive solving due to unsynchronized simplifications * fixed: Json output sometimes failed to report correct number of optimal models * fixed: SAT-frontend must retain pure literals for cautious/brave reasoning * fixed: ClaspFacade::start() sometimes failed to reset SharedContext * fixed: Sat-Preprocessor failed to propagate resolution of empty clause * fixed: simplifications after end of incremental step not always propagated to all threads * fixed too strong assertion in eq-preprocessor clasp 3.1.4: Thursday, 10th December 2015 * fixed: "--pre" failed to handle choice/disjunctive heads defined by extended bodies * fixed: "--backprop" failed to backpropagte certain constraints when used with "--eq=0" * fixed: potential deadlock during shutdown/join() in async solving * fixed: DomainHeuristic failed to handle nested heuristic predicates * fixed: invalid delete in DomainHeuristic destructor * fixed: configuration sometimes failed to initialize solver id * rewrote Clause::updateWatch() loop to workaround bug #67892 in gcc 5 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67892) clasp 3.1.3: Friday, 31th July 2015 * fixed: possible livelock in multi-threaded enumeration of optimal models * fixed: parser for _heuristic atoms failed to handle atoms containing strings * fixed: over-satisfied PB constraints not always handled correctly * fixed: incorrect handling of aux vars in Solver::numWatches() * fixed: C++11 isnan issue on Mac clasp 3.1.2: Tuesday, 5th May 2015 * fixed: Option "--heuristic" failed to accept decay factor for domain heuristic * fixed: LogicProgram::getDisjFor() failed to handle hash collisions correctly * fixed: facts in disjunctions not always correctly handled * fixed: domain heuristic failed to distinguish atom names sharing a common prefix * fixed: domain heuristic failed to handle atoms with complementary literals correctly * fixed: LogicProgram::write() must not output gamma rules and/or atoms that are false * fixed regression in handling of sign modifier in domain heuristic * fixed regression in backpropagation during preprocessing clasp 3.1.1: Wednesday, 12th November 2014 * LparseReader now handles "external statement" * fixed: low-level config interface failed to correctly handle successive changes of "opt-bound" * fixed: wrong completition nogoods with option "--no-gamma" * fixed regression in rule simplification (regression in 3.0.x) * fixed regression in "--configuration=jumpy" * fixed regression in handling of modifiers true/false in domain heuristic clasp 3.1.0: Friday, 15th August 2014 * added new strategies for unsatisfiable-core based optimization * added alternative distribution mode via thread-local queues (option " --dist-mode") * generators now propagate top-level assignment to testers * removed optimization options from default configurations * CLI changes: - option "--sat-prepro" now expects the algorithm followed by an optional list of limits - option "--opt-strategy" now takes two arguments; the first mandatory argument selects the major strategy (i.e. branch and bound or unsat-core), while the optional second argument controls fine tuning of said strategy - combined options "--dom-mod" and "--dom-pref" and added enum mode "domRec" for enabling subset optimization via domain heuristic - added "--forget-on-step=2" for discarding previously set variable phases and changed value for discarding nogood activities and learnt nogoods to 4 and 8, respectively - replaced option "--hparam" (and its aliases) with second argument for "--heuristic" - replaced "--berk-once" with more general "--score-res" - renamed option "--number" to "--models" * Integration/clingo: - added support for open (i.e. unassigned) externals - added support for adding constraints via model callback - added low-level interface for accessing a clasp configuration - cleaned up some stats keys and replaced "camelCase" with "snake_case" in keys clasp 3.0.6: Monday, 21st July 2014 * fixed: parallel unsat-core based enumeration of optimal models could skip valid models * fixed: possible race condition in signal handling * fixed: ABA-problem in parallel cb-enumerator could lead to duplicate models (regression in 3.0.x) * fixed: "--share=auto" (default) failed to enable physical sharing in mt-mode (regression in 3.0.x) * fixed: eq over complementary atoms not always correctly handled (regression in 3.0.x) * fixed: incremental domain heuristic failed to apply values to atoms from previous steps * fixed: eq over bodies of size 1 not always correctly handled * fixed: typo in description of "--quiet" clasp 3.0.5: Monday, 19th May 2014 * added support for ThreadTime::getTime() on MacOS X * removed pointless "--del-init" option from config tweety * fixed: non-hcf components not always correctly added in incremental disjunctive programs (clingo) * fixed: empty soft clauses not correctly handled in MaxSAT frontend * fixed: unfounded sets from 2nd level test not always correctly handled * fixed: json output must not print NaN * fixed: asp options not correctly set on configuration update (from clingo) * fixed: regression in handling of (incremental) projection clasp 3.0.4: Thursday, 24th April 2014 * replaced "s SATISFIABLE" with "s UNKNOWN" when called with option "--opt-sat" * improved handling of weight constraints containing incremental assumptions * fixed: typo in output of "--help" * fixed: unsatisfiable-core based optimization sometimes fails to assign all active assumptions * fixed: superfluous rules for facts not always correctly handled * fixed: assigned values for external atoms not always carried over to next step * fixed: clasp sometimes fails on incremental problems if "--lookahead" is used with "--forget-on-step" clasp 3.0.3: Friday, 28th March 2014 * fixed: AsyncResult destructor fails if called after destruction of ClaspFacade * fixed: projective enumeration sometimes fails when used with option "--restart-on-model" * fixed: regression in handling of negative lower bound in optimization clasp 3.0.2: Monday, 17th March 2014 * patch 1 (March 19th, 2014): fixed regression in projective enumeration * added ClaspFacade::startSolveAsync() for enumerating models in an iterator-like fashion * added "--forget-on-step" for simulating iclingo's "--ilearnt" and "--iheuristic" * added "--dom-mod=6" for simulating hclasp's subset minimization * fixed: DefaultUnfoundedCheck sometimes fails with assertion in incremental setting * fixed: wcnf frontend fails if top weight >= 2^31 * fixed: unit cores not always correctly handled in unsatisfiable-core based optimization * fixed: negative lower bound not correctly handled in hierarchical optimization * fixed: projection not correctly handled in incremental setting * fixed: clasp sometimes reports bogus timing values when interrupted via Ctrl-C on Windows * fixed: lookahead fails on non-asp problems if combined with option "--nant" * fixed: wrong/missing models because of incorrect backpropagation with option "--backprop" clasp 3.0.1: Friday, 21th February 2014 * added support for disabling "--opt-bound" via "--opt-bound=no" * added support for passing on/off values for option flags on config update * fixed: multiple occurrences of literal with negative weight not correctly merged (see also: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=739628) * fixed: negative literals not correctly formatted in PB output * fixed: excess bounds in "--opt-bound" not correctly handled * fixed: negatable otions like "[no]-init-moms" not recognized * fixed libprogram_opts: string to long long conversion fails clasp 3.0.0: Friday, 14th February 2014 1. Integrated support for disjunctive solving from claspD-2 2. Integrated domain heuristic from hclasp via option "--heuristic=domain" * added "--dom-pref" and "--dom-mod" for applying domain modifications to certain subsets of atoms 3. Optimization * replaced global "--opt-hierarch" option with more general per thread option "--opt-strategy" to enable competition-based optimization during parallel solving * integrated unsatisfiable-core based optimization from unclasp via "--opt-strategy={4,5}" * replaced "--opt-ignore", "--opt-all", "--opt-best" with option "--opt-mode" and added new reasoning mode for enumerating optimal models via option "--opt-mode=optN" * renamed "--opt-value" to "--opt-bound" 4. Misc * added a new configuration "tweety" and made it the default for asp problems * removed option "--portfolio" in favour of "--configuration=" * added second argument to "--contraction" for replacing long nogoods with decision sequence/all uip clause * added option "--out-hide-aux" for hiding atoms starting with "_" in models * added option "--out-atomf" for setting atom output format * added "--outf=3" for disabling output * simplified deletion options 5. Internals & Integration with clingo * implemented new configuration class * moved option handling and output classes to libclasp * simplified/cleaned up major interfaces * added support for asynchronous solving * added support for incremental/volatile enumeration/optimization * added support for adding/removing aux variables during solving * added low-level interface for accessing statistics clasp 2.1.5: Tuesday, 28th January 2014 * fixed a bug in the handling of unary projection nogoods * fixed a bug in the interplay between lookahead and minimization clasp 2.1.4: Tuesday, 26th November 2013 * fixed a possible crash bug in handling of conditional constraints * fixed a regression in handling of physically shared clauses * fixed compilation issues with clang-500.2.79 on Mac clasp 2.1.3: Friday, 12th April 2013 * fixed a regression in the handling of choice rules in the unfounded set checker clasp 2.1.2: Friday, 5th April 2013 * updated "--outf=1" to ASP-Comp'13 format and added corresponding exit codes * fixed: Wrong/missing models because of incorrect handling of recursive aggregates * fixed: Counter implication restart on root level could introduce an invalid conflict * fixed: clasp does not compile in C++11 mode * fixed regression: Inconsistent behaviour in dimacs front-end when running with or without option "--number=1" clasp 2.1.1: Thursday, 22th November 2012 * fixed regression: MaxSAT-frontend must not assert pure literals / relaxation variables * fixed: spurious warning when using option "--no-lookback" * fixed: "--shuffle" and "--counter-restarts" not working as intended with hierarchical optimization * fixed: Backslashes in JSON output not correctly quoted clasp 2.1.0: Monday, 27th August 2012 * restructured help and revised options and their defaults * added "--help[={1..3}]" for showing basic, advanced, or all options * added "--configuration" for selecting between prefabricated default configurations * revised deletion options and grouped them via common prefix "--del-" * revised thread options and added options for size-/topology-based lemma exchange * added support for dynamic restarts via "--restarts=D," * added "--sign-def" for setting default sign used in decision heuristic * added "--sign-fix" for disabling sign-heuristic * added "--init-moms" for enabling/disabling initialization of heuristic with MOMS-score * added "--fast-exit" for forcing app exit without cleanup * added "--update-act" for enabling LBD-based activity bumping * added "--update-mode" for configuring when update/integrate messages are handled in parallel-search * added "--learn-explicit" to disable usage of implication graph for learnt constraints * added "--share" for configuring physical constraint sharing * added "--init-watches" for controlling initialization of watched literals * added "--counter-restarts" and "--counter-bump" for enabling counter implication restarts * added "--lemma-out-lbd" for restricting lemmas written via "--lemma-out" * added "--lemma-in-lbd" for setting initial lbd of lemmas read via "--lemma-in" * replaced "--loops-in-heu" with more general "--score-other" * replaced "--rand-watches" with more general "--init-watches" * replaced "--initial-lookahead" with "--lookahead=[,]" * replaced "--recursive-str" with "--strengthen=[,]" * replaced "--copy-problem" with more general "--share" * removed options "--brave", "--cautious", "--solution-recording": all superseded by "--enum-mode=" * option "--restarts" now always requires a type; and the "limit" parameter now sets the (initial) length of the sequence * disbaled signal handling during printing of models * fixed: Overflow on parsing large opt-values (issue 3528852) * fixed: Parallel bt-enumerator enumerated duplicate models under certain conditions * fixed: Sat-Preprocessor failed to expand models correctly under very rare conditions * fixed: Erroneous interplay between "otfs=2" and "reverse-arcs" could lead to the unjustified removal of problem constraints * fixed: Incorrect ordering-predicate in MinimizeConstraint could lead to wrong optima * fixed: Solve loop failed to handle restart on total assignment correctly resulting in an infinite loop on some optimization problems * fixed: Duplicate key in JSON-Output of lemma stats clasp 2.0.6: Tuesday, 3rd April 2012 * added better error detection to portfolio parser and fixed a bug in the initialization of thread configs * first attempt at decoupling learnt db growing from restart schedule using independent grow schedule configurable via (hidden) option "--dgrowS" * added "--update-lbd=2" to enable usage of "strict" lbds * added (experimental) support for counter implication restarts and dynamic restarts via hidden options * fixed bugs in code for shared clause integration that could led to unpleasant results ranging from duplicate/missing models in enumeration to crashing if option "--otfs" was used clasp 2.0.5: Sunday, 29th January 2012 * fixed: Input parser for opb and (w)cnf failed to read 64bit integers. * fixed: Outer bound of inner-outer-restarts sometimes remained constant because of integer arithmetic. * fixed: Minimize constraint must not update optimum in enumeration-mode (opt-all). Bug introduced in version 2.0.3 * fixed: Minimize constraint must not update initial (user-set) bound until a model is found. Bug introduced in version 2.0.3 * fixed: Right hand side of minimize constraint not correctly initialized if "--opt-hierarch" was used. * fixed: SharedMinimizeData assumed monotonicity of individual levels - could fail after merging complementary literals in multi-level minimize constraints. Added extra "adjustment"-values to represent values resulting from such merges. clasp 2.0.4: Tuesday, 29th November 2011 * some cleanup in help output * moved general ASP-specific options to separate group * moved "--opt-sat" to basic options * simplified default command-line and made "input-dependent" defaults more explicit * updated interface spec of ProgramBuilder to make it more robust w.r.t incremental update * fixed parsing of "--global-restarts" * fixed: default value for option "--rand-watches" was not applied * fixed: Enumerator did not broadcast last model/optimum of current GP in parallel search * fixed: clauses simplified to binary/ternary are no longer counted twice in stats * fixed: eq-preprocessor sometimes did not reorder head list after merging two bodies * fixed: dimacs front-end failed to read empty dimacs file clasp 2.0.3: Tuesday, 23rd August 2011 * added option "--enum-mode" for setting enumeration algorithm and deprecated superseded options "--solution-recording", "--brave", and "cautious" * made "--enum-mode=record" the default for optimization * added default portfolio settable via "--portfolio=default" * added support for arithmetic restarts * moved "--opt-heuristic" to "Search Options" to allow for different settings in portfolios * fixed: clasp crashes with --pre (issue 3393095) * fixed: value given via "--opt-val" not checked against initial inconsistency * fixed: command line options not applied to portfolio configurations * fixed: parallel enumeration of models did not always respect "--number" * fixed: possible deadlock in parallel hierarchical optimization * fixed: failed to always propagate literals enqueued by PostPropagator::isModel() * fixed: possible crash bug because ReasonStore32::value_type did not decode stored data clasp 2.0.2: Thursday, 30th June 2011 * applied fixes from version 1.3.9 * fixed problem in call to linker (issue 3324430) * fixed a bug in "otfs" which could not handle unsimplified lemmas * fixed a potential invalid memory access in ImplicationList::hasLearnt() * fixed potential underflow in output of solved guiding paths * fixed a problem in UnitHeuristic which failed to handle stop conflicts in parallel solving * fixed various exception-related issues in parallel solving and made it more robust in the face of exceptions * re-enabled optimized unit clause handling for MaxSAT clasp 2.0.1: Wednesday, 27th April 2011 * fixed various (spurious) warnings * updated ProgramOptions to circumvent tellg() bug in g++-4.{4,5,6} under Debian (see also: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=623850) * fixed some issues in build scripts (many thanks to Thomas Krennwallner) * configure.sh no longer sets RPATH unless "--set-rpath" is given * check for libtbb now also works on Mac OS * added code for finding TBB in default paths * fixed argument order in calls to compiler * removed spaces in specification of include/library directories clasp 2.0.0: Thursday, 21st April 2011 1. Support for parallel (multithreaded) solving (requires Intel(R) Threading Building Blocks) * configurable number of threads via option "--threads" * splitting-based search via guiding path and dynamic load-balancing * global restarts via option "--global-restarts" to escape from bad initial splits * competition-based search via freely configurable portfolios (option "--portfolio") * combination of splitting-based and portfolio-based search (option "--force-gp") * configurable lemma exchange via Distributor interface and options "--distribute" and "--integrate" * support for parallel enumeration, optimization, and computation of brave-/cautious consequences 2. Optimization * hierarchical (multi-level) optimization via option "--opt-hierarch=1" * hierarchical optimization with varying step lengths via option "--opt-hierarch={2,3}" * changed switch "--opt-heu" to option "--opt-heuristic={1,2,3}", where * 1: use optimize statements in sign heuristic * 2: use optimize statements in model heuristic * 3: use optimize statements in both sign and model heuristic * changed switch "--opt-all" to option "--opt-all=value"; now enumerates all models with optimize value less than or equal to given value 3. New language front-ends * added support for MaxSAT via optimization (option "--opt-sat") * added support for weighted partial MaxSAT problems in wcnf format * added support for weighted boolean optimization (WBO) problems * added support for non-linear constraints to pseudo-Boolean parser 4. New output handling * option "--outf={0,1,2}" for selecting between (0) default output format, (1) competition output format, and (2) output in JSON format * option "--quiet" now accepts a pair for configuring printing of models and optimize values * added verbosity level 3 to enable printing of progress messages * new (hidden) option "--ifs" for setting separator used when printing models 5. Preprocessing & Learning * added (optional) support for blocked clause elimination to SAT-preprocessor * added option "--reverse-arcs" for ManySAT-like conflict analysis with "reverse arcs" * added option "--otfs" for enabling "on the fly subsumption" * added (optional) support for secondary nogood reduction schedule via option "--dsched" * added option "--dinit=min,max" for limiting initial learnt db size to range [min,max] * added option "--dglue=x" to prevent deletion of nogoods with lbd <= x * added option "--update-lbd" for enabling dynamic updates of lbds of learnt nogoods 6. Internals * reimplemented constraints to enable sharing (and cloning); forced clear distinction between read-only, shared, and thread-local data * separated read-only program dependency graph from thread-local unfounded set checker so that the former can be shared between multiple threads * added SharedContext object for hosting information to be shared between solving threads * added shareable weight constraints * updated clause representation and added a shared clause constraint * splitted binary-/ternary implication graph into shared read-only static and fine-grained lock-protected dynamic part * implemented lock-free MultiQueue as first concrete nogood distributor (passive, global distribution) * implemented linear-time recursive-strengthen algorithm * switched to new version of ProgramOptions library * added support for "tagged" knowledge, i.e. nogoods tagged with an initial assumption * separated local (solver & search related) from global (enumeration & preprocessing) options in ClaspFacade * implemented more cache-efficient left_right_sequence for storing and distinguishing between clause and general watches * added (hidden) option "--dfrac" to set fraction of nogoods to delete on reduction * added new deletion algorithms and hidden option "--dalgo" for selecting between them * added hidden option "--dscore" for selecting between different nogood activity scoring schemes * added (hidden) option "--berk-once" for switching between multiset and set-based scoring in BerkMin clasp 1.3.6: Friday, 19th November 2010 * added missing copyright information to tests and examples * fixed a bug in preprocessing of weight rules where only literals but not their weights were swapped * fixed: lookahead accessed unitialized memory in incremental setting (concerns iclingo only) * fixed: inner-outer restart sequence always used hard-coded grow-factor clasp 1.3.5: Friday, 24th September 2010 * Removed warning for minimization under projection if safe * fixed inconsequent output format in time and statistics output * fixed bug in output of choice rules with empty head * fixed: truth-value of complementary eq-atom not correctly set * fixed: SAT-preprocessor must not reuse clause ids from previous incremental steps clasp 1.3.4: Monday, 14th June 2010 * moved claspre functionality to clasp (run configure with "--with-claspre" to enable it) * added "--search-limit" to limit search to a certain number of conflicts or restarts * calling clasp with "--stats=2" now prints jump statistics * long loop nogoods are now replaced with decision sequence if the latter is considerably shorter * sat-based preprocessing is now again enabled by default if input format is dimacs or OPB * fixed: option "--rand-prob" not always correctly parsed * fixed: lookahead not correctly initialized in incremental setting (only concerns iclingo) * fixed: enumerators not always correctly terminated when solving under assumptions * fixed: sat-output failed to '0'-terminate models * fixed: "--opt-value" did not work with negative numbers * simplified some code to avoid internal compiler error in gcc-3.4.3 clasp 1.3.3: Thursday, 1st April 2010 (April Fools' Day) * added "--trans-ext=card" and "--trans-ext=integ" for transforming cardinality rules resp. extended integrity constraints * added "--lemma-out=" and "--lemma-in=" for writing lemmas to resp. reading lemmas from * clasp now prints suboptimal models in PB-mode if called with "--verbosity=2" * added more timing statistics * application now reports actual average size of learnt lemmas instead of average contracted size * fixed: "--del=no" did not fully disable nogood deletion * fixed: "--opt-value" not checked against initial sum of minimize constraint * fixed: dimacs parser must not assign undefined literals to false if more than one model is requested * fixed: possible double-deletion in option "--pre" * fixed: unfounded set checker sometimes too lazy w.r.t heads of recursive extended rules * fixed a minor bug in eq-preprocessing * changed some code to avoid code generation bug in Visual C++ 2008 x64 see: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=526921 clasp 1.3.2: Friday, 15th January 2010 * fixed a 64-bit portability problem; clasp should now also run under Mac OS X 10.6 * fixed option "--pre" * fixed: SAT-preprocessor not correctly initialized on SAT-problems with more than 4 Mio. clauses clasp 1.3.1: Tuesday, 8th December 2009 * changed some internal interface to simplify integration of clasp in clingo/iclingo/clingcon * fixed a couple of bugs in the eq-preprocessing * fixed a bug in transformation of weight rules in incremental setting * fixed a crash bug in experimental "--backprop" preprocessor * fixed a bug that made clasp exit with code S_UNKNOWN (0) instead of S_UNSAT (20) on unsat problems (computation was correct, though) * fixed a command-line problem: option "--recursive-str" wrongly required an argument * fixed a small problem in PB-frontend that led to wrong optima clasp 1.3.0: Tuesday, 20th October 2009 * added an OPB front-end for solving linear Pseudo-Boolean constraint problems and removed switch "--dimacs": the input format (Smodels-input, dimacs, or OPB) is now automatically detected * added switch "--opt-ignore" and "--opt-heu" for ignoring optimize statements during search, resp. for setting the preferred value of literals occurring in minimize statements to false * added switch "--estimate" for initializing size of learnt DB based on estimated problem complexity * added switch "--reset-restart" for resetting restart schedule after each model found * added switch "--asp09" for enabling ASP'09 competition output format * added switch "--pre" for only printing preprocessed program * added switch "--backprop" for enabling backpropagation in ASP-preprocessor. Note: EXPERIMENTAL FEATURE * added option "--time-limit=" for setting a solving time limit of seconds * added option "--verbose=" for controlling status messages, where "--verbose=0" disables all status messages "--verbose=1" is the default and prints basic status information "--verbose=2" prints more status messages * option "--quiet" no longer controls status messages; it only disables printing of models * replaced option "--lookback=" with switch "--no-lookback" * option "--save-progress" now takes an int to enable progress saving only on jumps >= > 0 * default heuristic now disables MOMs-based top-level heuristic on large problems * removed auto_lookahead option * internal: added better interfaces for users of clasp library (iClingo, Clingcon, ...) * fixed an optimization that violated gcc's strict aliasing rules and could led to crashes * fixed a bug in the interplay of projective enumeration and sat-preprocessing that could led to the enumeration of duplicate models (w.r.t the projection variables) * fixed two bugs w.r.t optimization: first, clasp sometimes reported unknown optimum although last model was optimal. Second, reported optima for minimize statements containing facts were too low (optimality of models was correct, though) * fixed a lookahead bug which occurred only together with sat-preprocessing * fixed a small glitch in the recursive nogood minimization (switch "--recursive-str") clasp 1.2.1: Tuesday, 14th April 2009 * fixed a crash bug in handling of weight rules with bound 0 (introduced in 1.2.0) * added warning for minimization under projection * reverted behaviour of "--number" to pre 1.2.0, i.e. "--number" is again considered during optimization/computation of consequences * removed spurious warning when "--number" is not explicitly set on optimization * disabled printing of cautious consequences and optimization for UNSAT problems * clasp now also prints current optimum on interrupt clasp 1.2.0: Tuesday, 10th March 2009 * added "--project" for enabling projective enumeration * added "--solution-recording" for enabling alternative enumeration mode based on (solution) nogoods * added "--restart-on-model" for restarting search after each model (randomize enumeration) * changed "--initial-lookahead" to "--initial-lookahead=", where gives the number of choices to be selected by lookahead. If 0, lookahead is only used during preprocessing. * removed "--opt-restart", which is now superseded by "--restart-on-model" * added support for minimization during consequence computation * added new (platform specific) timer which won't overflow after merely 36 minutes * improved algorithm for handling recursive weight constraints * fixed a bug where B+ atoms were falsely removed during preprocessing * fixed a crash bug where clasp created bogus minimize statements for trivially UNSAT programs * fixed a bug in the unfounded set checker where multiple SCCs were not always handled correctly (bug was introduced in version 1.1.0) * fixed ProgramBuilder::writeProgram so that it now correctly writes integrity constraints (internal) clasp 1.1.3: Monday, 24th November 2008 * fixed handling of zero weighted atoms in minimize statements * fixed a bug that caused "--deletion=no" to constantly delete all learnt nogoods clasp 1.1.2: Saturday, 25th October 2008 * fixed a bug in the unfounded set checker (bug introduced in version 1.1.0) clasp 1.1.1: Monday, 13th October 2008 * revised option names, help text, and error messages * fixed a bug in the preprocessing/simplification of weight rules * fixed several bugs in the handling of incremental programs clasp 1.1.0: Thursday, 31th July 2008 * added "--sat-prepro" for SatElite-like preprocessing * improved eq-Preprocessing and updated "--eq" to reflect new iterative algorithm * added "--cautious" and "--brave" for cautious resp. brave reasoning * added new optimization mode "--opt-rand": similar to optimize-one but restarts after each enumerated model * added "--local-restarts" for local restarts as described in "Local Restarts" by Ryvchin and Strichman * added new inner-outer restart strategy from PicoSat; quadratic-scheme remains default for now * added "--expensiveccm" for expensive conflict clause minimization a la MiniSat; old Beame-scheme remains default for now * replaced old VSIDS heuristic with MiniSat-like VSIDS heuristic * changed growth strategy of learnt db * changed default value of "--contraction" to 250 * added support for incremental program update (internal) clasp 1.0.5: Monday, 31th December 2007 * added "--minimization=all" for conflict clause minimization over all antecedent types * changed default of "--minimization" from "bin" to "all". * added "--save-progress" for RSat-like progress saving * added "--optimize-value" for setting initial value(s) of optimize function * optimized implementation of cardinality-/weight-rules * simplified and improved implementation of ProgramBuilder and preprocessing * unfounded set checker is now also backtrack-free for extended rules * if "--rand-watches" is not used, watches in clauses are initialized to the two least watched literals * fixed a bug regarding lookahead: if lookahead was not used as heuristic, literal dependencies were not cleared; failed-literal detection skipped literals and thus did not always find all conflicts. * fixed a bug that led to wrong answers/crashes if "loops=no" was used * fixed a bug in preprocessing of minimize rules clasp 1.0.4: Wednesday, 22th August 2007 (updated: 24th August 2007) * improved equivalence-preprocessing w.r.t bodies of size > 1 and slightly decreased memory usage * improved look-back heuristics * changed default value of "--trans-ext" to "no", i.e. extended rules are now handled natively by default * simplified output and added "--stats" for enabling printing of extended statistics * implemented non-recursive version of Tarjan's SCC algorithm to prevent stack overflows on large SCCs * fixed another bug in handling of minimize rules * fixed a bug in the command-line interface that led to a crash when an unknown heuristic was given * fixed a bug concerning preprocessing/simplification of weight rules * 08/24/2007: fixed a bug in preprocessing of cardinality/weight rules containing duplicate literals * 10/25/2007: fixed a bug in preprocessing of satisfied bodies * 10/27/2007: fixed a bug where weight constraints were inadvertently handled as cardinality constraints whenever the second weight equaled 1 * 11/09/2007: fixed a bug in preprocessing of unsupported bodies clasp 1.0.3: Monday, 16th July 2007 * added a new parameter "no" to "--loops" which disables learning of loop formulas * improved performance of the equivalence-preprocessing algorithm on certain inputs * adapted lookahead so that it can distinguish equivalent variables * fixed a bug in the dimacs front-end that led to incorrect results on certain inputs * if "--loops=shared" was used, learnt loop formulas were not added to the learnt db and thus not subject to nogood deletion * fixed a bug that led to an infinite loop on certain optimization problems (bug was introduced in version 1.0.2) * added signal handler to intercept standard signals like SIGTERM clasp 1.0.2: Friday, 15th June 2007 * added "--eq" for equivalence-based preprocessing; added "--eq" to default command line * "--contraction" expects threshold length for dynamic compression of long learnt clauses (default: 60) * added a second (optional) grow factor to "--deletion" that is applied after every reduction * added "--reduce-on-restart" that removes some of the learnt nogoods on every restart * added "--optimize" for computing either one or all optimal solutions * fixed a bug that led to a crash when "--evaluate-loops=false" was used together with the default heuristic * fixed a bug that led to a crash on certain problems when lookahead was used in lookback mode clasp 1.0.1: Wednesday, 28th March 2007 * some fixes to make clasp compile on gcc 4.1 and gcc 4.2 * fixed a bug in the RNG that led to array-out-of-bounds accesses using certain standard library implementations * fixed a bug in the (native) handling of constraint-rules - clasp treated their bodies as sets and spuriously removed duplicate atoms * fixed a bug in the handling of compute-statements - clasp failed to produce a conflict if the compute-statement forced an unsupported atom to be true. clasp 1.0: Wednesday, 7th March 2007 * added native support for extended rules (disabled by default) * added support for optimize statements * added "--dimacs" for reading CNF-problems in dimacs-format * added "--contraction": dynamic clause compression for very long learnt clauses * added "--minimize": (weak) conflict clause minimization * added "--lookahead" for (configurable) failed-literal-detection * added "--rand-watches" for random initialization of watches * added "--rand-prop" for support of occasional random-choices * added "--supp-models" for computation of supported models * added "--bounded-restarts" for allowing (bounded) restarts afer solution was found * new and more dynamic VSIDS heuristic * new smodels-like lookahead heuristic * changed nogood deletion heuristic * removed -s option (replaced with --initial-lookahead) * renamed --no-learn option (now: --lookback=no) clasp Asp-Comp: Revision: Wednesday, 20th December 2006 * scaled-down version for the ASP-competition clasp RC4: Wednesday, 25th October 2006 * added new restart strategies * addad a randomization strategy similar to satzoo's "Burst of random variable orders" * added an option to initialize the random number generator * fixed bug in LparseReader that caused an infinite loop on bad input * fixed implementation of BerkMin heuristic * fixed potential memory-leak in clause deletion code clasp RC3: Friday, 29th September 2006 * transformation of extended rules to normal rules * some low-level stuff to improve performance clasp RC2: Monday, 19th June 2006 * version produced for paper * major bug fixes clasp RC1: Friday, 16th June 2006 * initial version clasp-3.2.2/CMakeLists.txt000066400000000000000000000050641304134206100153570ustar00rootroot00000000000000cmake_minimum_required(VERSION 2.8) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/tools") include(CheckCXXCompilerFlag) include(CheckCXXSourceCompiles) include(CheckIncludeFileCXX) project(clasp) if (NOT CMAKE_BUILD_TYPE) message(STATUS "No build type selected, using 'Release'") set(CMAKE_BUILD_TYPE "Release") endif() # clasp control variables set (CLASP_COMPILE_DEFS "") set (CLASP_LINK_LIBS "") set (CLASP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/liblp" "${CMAKE_CURRENT_SOURCE_DIR}/libprogram_opts") option(WITH_THREADS "Try to build with thread support" ON) if (WITH_THREADS) file(READ ${CMAKE_CURRENT_SOURCE_DIR}/tools/has_std_thread.cpp thread_test) check_cxx_compiler_flag("-std=c++11" has_cxx11_flag) if (has_cxx11_flag) SET(CMAKE_REQUIRED_FLAGS "-std=c++11") endif() check_cxx_source_compiles("${thread_test}" has_std_threads) if (has_std_threads) find_package (Threads) MESSAGE (STATUS "Building with std threads (link: ${CMAKE_THREAD_LIBS_INIT})") SET(CLASP_LINK_LIBS ${CMAKE_THREAD_LIBS_INIT}) SET(CLASP_COMPILE_DEFS -DWITH_THREADS=1 -DCLASP_USE_STD_THREAD) if (has_cxx11_flag) add_definitions( -std=c++11 ) endif() else() find_package(TBB) if (TBB_FOUND) MESSAGE (STATUS "TBB found. Building with tbb threads.") SET(CLASP_COMPILE_DEFS -DWITH_THREADS=1) SET(CLASP_LINK_LIBS ${TBB_LIBRARIES}) SET(CLASP_INCLUDE_DIRS ${CLASP_INCLUDE_DIRS} ${TBB_INCLUDE_DIRS}) link_directories(${TBB_LIBRARY_DIRS}) else() MESSAGE (STATUS "Building without threads.") set (CLASP_COMPILE_DEFS -DWITH_THREADS=0) endif() endif() else() set (CLASP_COMPILE_DEFS -DWITH_THREADS=0) endif() message(STATUS "debug flags :${CMAKE_CXX_FLAGS_DEBUG}") message(STATUS "release flags:${CMAKE_CXX_FLAGS_RELEASE}") message(STATUS "clasp flags :${CLASP_COMPILE_DEFS}") message(STATUS "clasp libs :${CLASP_LINK_LIBS}") message(STATUS "clasp include:${CLASP_INCLUDE_DIRS}") add_subdirectory(liblp) add_subdirectory(libprogram_opts) add_subdirectory(libclasp) add_subdirectory(app) check_include_file_cxx("cppunit/Test.h" has_cpp_unit) if (has_cpp_unit) find_library(has_cpp_unit cppunit) endif() if (has_cpp_unit) enable_testing () file(GLOB LIBCLASP_TEST libclasp/tests/*.cpp) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libclasp ${CLASP_INCLUDE_DIRS}) add_definitions(${CLASP_COMPILE_DEFS}) add_executable(claspTest ${LIBCLASP_TEST}) target_link_libraries(claspTest clasp lp program_opts cppunit ${CLASP_LINK_LIBS}) add_test (NAME ClaspTest COMMAND claspTest) else() message(STATUS "cppunit not found - skipping tests") endif() clasp-3.2.2/COPYING000066400000000000000000000431031304134206100136460ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. clasp-3.2.2/README000066400000000000000000000145521304134206100135010ustar00rootroot00000000000000 clasp-3.x A conflict-driven nogood learning answer set solver http://www.cs.uni-potsdam.de/clasp/ https://potassco.org/ OVERVIEW clasp is an answer set solver for (extended) normal and disjunctive logic programs. It combines the high-level modeling capacities of answer set programming with state-of-the-art techniques from the area of Boolean constraint solving. The primary clasp algorithm relies on conflict-driven nogood learning, a technique that proved very successful for satisfiability checking (SAT). Starting with version 2.0, clasp supports parallel (multithreaded) solving. Starting with version 3.0, clasp supports - disjunctive logic programs as in claspD-2, - domain heuristic modifications as in hclasp via option "--heuristic=domain", - unsatisfiable-core based optimization as in unclasp via "--opt-strategy". Starting with version 3.2, clasp supports - new asp intermediate format (aspif) [1], - ASP/SAT/PB modulo acyclicity [2] via option "--parse-ext" and a dedicated acyclicity constraint propagator, - optimization in SAT via option "--parse-ext" and "c minweight l1 w1 ... ln wn 0", - additional unsatisfiable-core based optimization strategies. clasp is written in (mostly) Standard-C++. It was successfully built and run under Linux (x86-32, x86-64) using gcc/clang and Windows (x86-32, x86-64) using either Microsoft Visual Studio or MinGW. Detailed information (including a User's manual), source code, and pre-compiled binaries are available at: https://potassco.org/ LICENSE clasp is part of the Potassco project hosted at SourceForge. It is distributed under the GNU Public License. See COPYING for details regarding the license. PACKAGE CONTENTS COPYING - GNU Public License CHANGES - Major changes between versions README - This file configure.{sh,bat} - Simple script that creates Makefiles for building clasp (library and application) CMakeLists.txt - Alternative configuration file for building clasp with CMake [3] app/ - Source code directory of the command-line interface libclasp/ - Directory of the clasp library (sources, documentation, unit tests) liblp/ - Library for parsing and converting (asp) input format libprogram_opts/ - Library for parsing command-line options (needed by app) build_vc/ - Project files for building clasp with Microsoft Visual Studio [4] tools/ - Some additional files BUILDING & INSTALLING The preferred way to build clasp is to use make and the provided configure script. You'll need to have the GNU Compiler Collection (GCC) version 3 or better installed in order to build clasp. You'll also need GNU make 3.80 or better. On Microsoft Windows, we recommend using MinGW and MinGW-make [5]. In the following it is assumed that 'make' is an alias for the installed GNU make. If this is not the case on your system, replace 'make' with the name of the GNU make executable (e.g. gmake). Furthermore, on Microsoft Windows use ./configure.bat instead of ./configure.sh. clasp's multithreaded solving requires either the use of a modern C++ compiler with support for C++11 threads or the Intel Threading Building Blocks (TBB) library (version >= 3.x) [6]. Type ./configure.sh --help to get an overview of all supported build configurations/options. To build clasp: ./configure.sh cd build/release make To build clasp with multithread support using C++11: ./configure.sh --with-mt=std cd build/release_mt make To build clasp with multithread support using TBB: ./configure.sh --with-mt=tbb cd build/release_mt make To build clasp with multithread support using TBB in a custom directory: ./configure.sh --with-mt=tbb TBB_INCLUDE= TBB_LIB= cd build/release_mt make To install clasp: make install By default, 'make install' will install clasp in '/usr/local/bin' You can specify an installation prefix other than '/usr/local' by running the configure-script with the option '--prefix=PATH'. Alternatively, use option '--bindir=PATH' to directly specify the installation path. Finally, you can always skip installation and simply copy the clasp executable to a directory of your choice. BUILDING WITH cmake To build clasp with cmake, you need cmake version 2.8 or newer. First, create a new build directory: mkdir build_cmake Second, run cmake and make from the newly created directory: cd build_cmake/ cmake ../ make Finally, copy ./bin/clasp to a directory of your choice. BUILDING WITH Microsoft Visual Studio In the directory build_vc/ we provide project files for building clasp from within Microsoft Visual Studio. Free express editions of Visual Studio are available from [7]. BUILDING the documentation A User's Guide is available from https://potassco.org/ Source code documentation can be generated with Doxygen [8]. Either explicitly: cd libclasp/doc/api doxygen clasp or when building with cmake: make doc USAGE clasp reads problem instances either from stdin, e.g cat problem | clasp or from a given file, e.g clasp problem Beside logic programs, clasp also supports SAT-problems in DIMACS-, Max-SAT in (extended) DIMACS-, and PB-problems in OPB and WBO-format. Type clasp --help to get a basic overview of options supported by clasp or clasp --help={2,3} for a more detailed list. In addition to printing status information, clasp also provides information about the computation via its exit status. The exit status is: 10: if the problem was found to be satisfiable 20: if the problem was proved to be unsatisfiable 0 : if the satisfiability of problem is not known, because search was either interrupted or not started 127: if clasp ran out of memory Furthermore, the exit status of 1 indicates an error. REFERENCES [1] http://www.cs.uni-potsdam.de/wv/pdfformat/gekakaosscwa16b.pdf [2] http://www.cs.uni-potsdam.de/wv/pdfformat/bogejakasc15b.pdf [3] https://cmake.org/ [4] https://www.visualstudio.com/ [5] http://www.mingw.org/ [6] http://threadingbuildingblocks.org/ [7] http://www.microsoft.com/express/Downloads/ [8] http://www.stack.nl/~dimitri/doxygen/clasp-3.2.2/app/000077500000000000000000000000001304134206100133725ustar00rootroot00000000000000clasp-3.2.2/app/CMakeLists.txt000066400000000000000000000010451304134206100161320ustar00rootroot00000000000000file(GLOB CLASP_APP_SRC *.cpp) include_directories(${CMAKE_SOURCE_DIR}/libclasp ${CMAKE_SOURCE_DIR}/liblp ${CMAKE_SOURCE_DIR}/libprogram_opts) add_definitions(${CLASP_COMPILE_DEFS}) add_executable(clasp_app ${CLASP_APP_SRC}) target_link_libraries(clasp_app clasp lp program_opts ${CLASP_LINK_LIBS}) set_target_properties(clasp_app PROPERTIES OUTPUT_NAME clasp) SET( EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin) file(GLOB LPCONVERT_SRC lpconvert/*.cpp) add_executable(lpconvert ${LPCONVERT_SRC}) target_link_libraries(lpconvert lp program_opts) clasp-3.2.2/app/clasp_app.cpp000066400000000000000000000640071304134206100160470ustar00rootroot00000000000000// // Copyright (c) 2006-2012, Benjamin Kaufmann // // This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ // // Clasp is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // Clasp is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with Clasp; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA // #include "clasp_app.h" #include #include #include #include #include #include #include #include #include #ifdef _WIN32 #define snprintf _snprintf #pragma warning (disable : 4996) #endif #if defined(__GLIBC__) || defined(__GNU_LIBRARY__) #include #if defined(_FPU_EXTENDED) && defined(_FPU_SINGLE) && defined(_FPU_DOUBLE) && defined(_FPU_GETCW) && defined(_FPU_SETCW) #define CLASP_HAS_FPU_CONTROL inline unsigned fpuReset(unsigned m) { _FPU_SETCW(m); return m; } inline unsigned fpuInit() { unsigned r; _FPU_GETCW(r); fpuReset((r & ~_FPU_EXTENDED & ~_FPU_SINGLE) | _FPU_DOUBLE); return r; } #endif #elif defined (_MSC_VER) && !defined(_WIN64) #include #define CLASP_HAS_FPU_CONTROL inline unsigned fpuReset(unsigned m) { _controlfp(m, _MCW_PC); return m; } inline unsigned fpuInit() { unsigned r = _controlfp(0, 0); fpuReset(_PC_53); return r; } #pragma fenv_access (on) #endif #if !defined(CLASP_HAS_FPU_CONTROL) inline unsigned fpuReset(unsigned) { return 0u; } inline unsigned fpuInit() { return 0u; } #endif inline bool setFpuMode() { return (sizeof(void*)*CHAR_BIT) < size_t(64u); } namespace Clasp { ///////////////////////////////////////////////////////////////////////////////////////// // Some helpers ///////////////////////////////////////////////////////////////////////////////////////// static double shutdownTime_g; static const std::string stdinStr = "stdin"; static const std::string stdoutStr = "stdout"; inline bool isStdIn(const std::string& in) { return in == "-" || in == stdinStr; } inline bool isStdOut(const std::string& out) { return out == "-" || out == stdoutStr; } ///////////////////////////////////////////////////////////////////////////////////////// // ClaspAppOptions ///////////////////////////////////////////////////////////////////////////////////////// namespace Cli { ClaspAppOptions::ClaspAppOptions() : outf(0), compute(0), ifs(' '), hideAux(false), onlyPre(0), printPort(false) { quiet[0] = quiet[1] = quiet[2] = static_cast(UCHAR_MAX); } void ClaspAppOptions::initOptions(ProgramOptions::OptionContext& root) { using namespace ProgramOptions; OptionGroup basic("Basic Options"); basic.addOptions() ("quiet,q" , notify(this, &ClaspAppOptions::mappedOpts)->implicit("2,2,2")->arg(""), "Configure printing of models, costs, and calls\n" " %A: [,][,]\n" " : print {0=all|1=last|2=no} models\n" " : print {0=all|1=last|2=no} optimize values []\n" " : print {0=all|1=last|2=no} call steps [2]") ("pre", notify(this, &ClaspAppOptions::mappedOpts)->arg("")->implicit("1"), "Print simplified program and exit\n" " %A: Output format: {1=auto|2=aspif}") ("print-portfolio" , flag(printPort), "Print default portfolio and exit") ("outf,@1", storeTo(outf)->arg(""), "Use {0=default|1=competition|2=JSON|3=no} output") ("out-atomf,@1" , storeTo(outAtom), "Set atom format string (
?%%0?)")
		("out-ifs,@1"   , notify(this, &ClaspAppOptions::mappedOpts), "Set internal field separator")
		("out-hide-aux,@1" , flag(hideAux), "Hide auxiliary atoms in answers")
		("lemma-in,@1"     , storeTo(lemmaIn)->arg(""), "Read additional lemmas from %A")
		("lemma-out,@1"    , storeTo(lemmaLog)->arg(""), "Log learnt lemmas to %A")
		("lemma-out-lbd,@1", storeTo(lemma.lbdMax)->arg(""), "Only log lemmas with lbd <= %A")
		("lemma-out-max,@1", storeTo(lemma.logMax)->arg(""), "Stop logging after %A lemmas")
		("lemma-out-dom,@1", notify(this, &ClaspAppOptions::mappedOpts), "Log lemmas over  variables")
		("lemma-out-txt,@1", flag(lemma.logText), "Log lemmas as ground integrity constraints")
		("hcc-out,@1", storeTo(hccOut)->arg(""), "Write non-hcf programs to %A.#scc")
		("file,f,@2" , storeTo(input)->composing(), "Input files")
		("compute,@2", storeTo(compute)->arg(""), "Force given literal to true")
	;
	root.add(basic);
}
bool ClaspAppOptions::mappedOpts(ClaspAppOptions* this_, const std::string& name, const std::string& value) {
	if (name == "quiet") {
		const char* err = 0;
		uint32      q[3]= {uint32(UCHAR_MAX),uint32(UCHAR_MAX),uint32(UCHAR_MAX)};
		int      parsed = bk_lib::xconvert(value.c_str(), q, &err);
		for (int i = 0; i != parsed; ++i) { this_->quiet[i] = static_cast(q[i]); }
		return parsed && *err == 0;
	}
	else if (name == "out-ifs") {
		if (value.empty() || value.size() > 2) { return false;}
		if (value.size() == 1) { this_->ifs = value[0]; return true; }
		if (value[1] == 't')   { this_->ifs = '\t'; return true; }
		if (value[1] == 'n')   { this_->ifs = '\n'; return true; }
		if (value[1] == 'v')   { this_->ifs = '\v'; return true; }
		if (value[1] == '\\')  { this_->ifs = '\\'; return true; }
	}
	else if (name == "lemma-out-dom") {
		return (this_->lemma.domOut = (strcasecmp(value.c_str(), "output") == 0)) == true || strcasecmp(value.c_str(), "input") == 0;
	}
	else if (name == "pre") {
		return value.size() == 1 && (this_->onlyPre = static_cast(Potassco::BufferedStream::toDigit(value[0]))) <= 2;
	}
	return false;
}
bool ClaspAppOptions::validateOptions(const ProgramOptions::ParsedOptions&) {
	if (quiet[1] == static_cast(UCHAR_MAX)) { quiet[1] = quiet[0]; }
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspAppBase
/////////////////////////////////////////////////////////////////////////////////////////
ClaspAppBase::ClaspAppBase() { }
ClaspAppBase::~ClaspAppBase(){ }
const int* ClaspAppBase::getSignals() const {
	static const int signals[] = {
		SIGINT, SIGTERM
#if !defined (_WIN32)
		, SIGUSR1, SIGUSR2, SIGQUIT, SIGHUP, SIGXCPU, SIGXFSZ
#endif
		, 0};
		return signals;
}
bool ClaspAppBase::parsePositional(const std::string& t, std::string& out) {
	int num;
	if   (bk_lib::string_cast(t, num)) { out = "number"; }
	else                               { out = "file";   }
	return true;
}
void ClaspAppBase::initOptions(ProgramOptions::OptionContext& root) {
	claspConfig_.addOptions(root);
	claspAppOpts_.initOptions(root);
	root.find("verbose")->get()->value()->defaultsTo("1");
}

void ClaspAppBase::validateOptions(const ProgramOptions::OptionContext&, const ProgramOptions::ParsedOptions& parsed, const ProgramOptions::ParsedValues& values) {
	if (claspAppOpts_.printPort) {
		printTemplate();
		exit(E_UNKNOWN);
	}
	setExitCode(E_NO_RUN);
	using ProgramOptions::Error;
	ProblemType pt = getProblemType();
	if (!claspAppOpts_.validateOptions(parsed) || !claspConfig_.finalize(parsed, pt, true)) {
		throw Error("command-line error!");
	}
	ClaspAppOptions& app = claspAppOpts_;
	if (!app.lemmaLog.empty() && !isStdOut(app.lemmaLog)) {
		if (std::find(app.input.begin(), app.input.end(), app.lemmaLog) != app.input.end() || app.lemmaIn == app.lemmaLog) {
			throw Error("'lemma-out': cowardly refusing to overwrite input file!");
		}
	}
	if (!app.lemmaIn.empty() && !isStdIn(app.lemmaIn) && !std::ifstream(app.lemmaIn.c_str()).is_open()) {
		error("'lemma-in': could not open file!");
		exit(E_NO_RUN);
	}
	for (std::size_t i = 1; i < app.input.size(); ++i) {
		if (!isStdIn(app.input[i]) && !std::ifstream(app.input[i].c_str()).is_open()) {
			throw Error(ClaspStringBuffer().appendFormat("'%s': could not open input file!", app.input[i].c_str()).c_str());
		}
	}
	if (app.onlyPre && pt != Problem_t::Asp) {
		throw Error("Option '--pre' only supported for ASP!");
	}
	setExitCode(0);
	storeCommandArgs(values);
}
void ClaspAppBase::setup() {
	ProblemType pt = getProblemType();
	clasp_         = new ClaspFacade();
	if (setFpuMode()) { fpuMode_ = fpuInit(); }
	if (!claspAppOpts_.onlyPre) {
		out_ = createOutput(pt);
		Event::Verbosity verb	= (Event::Verbosity)std::min(verbose(), (uint32)Event::verbosity_max);
		if (out_.get() && out_->verbosity() < (uint32)verb) { verb = (Event::Verbosity)out_->verbosity(); }
		if (!claspAppOpts_.lemmaLog.empty()) {
			logger_ = new LemmaLogger(claspAppOpts_.lemmaLog.c_str(), claspAppOpts_.lemma);
		}
		EventHandler::setVerbosity(Event::subsystem_facade , verb);
		EventHandler::setVerbosity(Event::subsystem_load   , verb);
		EventHandler::setVerbosity(Event::subsystem_prepare, verb);
		EventHandler::setVerbosity(Event::subsystem_solve  , verb);
		clasp_->ctx.setEventHandler(this, logger_.get() == 0 ? SharedContext::report_default : SharedContext::report_conflict);
	}
}

void ClaspAppBase::shutdown() {
	if (!clasp_.get()) { return; }
	if (logger_.get()) { logger_->close(); }
	lemmaIn_ = 0;
	const ClaspFacade::Summary& result = clasp_->shutdown();
	if (shutdownTime_g) {
		shutdownTime_g += RealTime::getTime();
		char msg[80];
		info(clasp_format(msg, sizeof(msg), "Shutdown completed in %.3f seconds", shutdownTime_g));
	}
	if (out_.get())  { out_->shutdown(result); }
	setExitCode(getExitCode() | exitCode(result));
	if (setFpuMode()){ fpuReset(fpuMode_); }
}

void ClaspAppBase::run() {
	if (out_.get()) {
		Potassco::Span in = !claspAppOpts_.input.empty() ? Potassco::toSpan(claspAppOpts_.input) : Potassco::toSpan(&stdinStr, 1);
		out_->run(getName(), getVersion(), Potassco::begin(in), Potassco::end(in));
	}
	try        { run(*clasp_); }
	catch(...) {
		try { blockSignals(); setExitCode(E_ERROR); throw; }
		catch (const std::bad_alloc&  ) { setExitCode(E_MEMORY); error("std::bad_alloc"); }
		catch (const std::exception& e) { error(e.what()); }
		catch (...)                     { ; }
	}
}

bool ClaspAppBase::onSignal(int sig) {
	if (!clasp_.get() || !clasp_->interrupt(sig)) {
		info("INTERRUPTED by signal!");
		setExitCode(E_INTERRUPT);
		shutdown();
		exit(getExitCode());
	}
	else {
		// multiple threads are active - shutdown was initiated
		shutdownTime_g = -RealTime::getTime();
		info("Sending shutdown signal...");
	}
	return false; // ignore all future signals
}

void ClaspAppBase::onEvent(const Event& ev) {
	const LogEvent* log = event_cast(ev);
	if (log && log->isWarning()) {
		warn(log->msg);
		return;
	}
	else if (const NewConflictEvent* cfl = event_cast(ev)) {
		if (logger_.get()) { logger_->add(*cfl->solver, *cfl->learnt, cfl->info); }
		return;
	}
	if (out_.get()) {
		blockSignals();
		out_->onEvent(ev);
		unblockSignals(true);
	}
}

bool ClaspAppBase::onModel(const Solver& s, const Model& m) {
	bool ret = true;
	if (out_.get() && !out_->quiet()) {
		blockSignals();
		ret = out_->onModel(s, m);
		unblockSignals(true);
	}
	return ret;
}
bool ClaspAppBase::onUnsat(const Solver& s, const Model& m) {
	bool ret = true;
	if (out_.get() && !out_->quiet()) {
		blockSignals();
		ret = out_->onUnsat(s, m);
		unblockSignals(true);
	}
	return ret;
}

int ClaspAppBase::exitCode(const RunSummary& run) const {
	int ec = 0;
	if (run.sat())               { ec |= E_SAT;       }
	if (run.complete())          { ec |= E_EXHAUST;   }
	if (run.result.interrupted()){ ec |= E_INTERRUPT; }
	return ec;
}

void ClaspAppBase::printTemplate() const {
	printf(
		"# clasp %s configuration file\n"
		"# A configuration file contains a (possibly empty) list of configurations.\n"
		"# Each of which must have the following format:\n"
		"#   [()]: \n"
		"# where  is a string that must not contain ':',\n"
		"#  is one of clasp's default configs (and optional)\n"
		"# and     is a command-line string of clasp options in long-format, e.g.\n"
		"# ('--heuristic=vsids --restarts=L,100').\n"
		"#\n"
		"# SEE: clasp --help\n"
		"#\n"
		"# NOTE: The options '--configuration' and '--tester' must not occur in a\n"
		"#       configuration file. Furthermore, global options are ignored in all\n"
		"#       but the first configuration.\n"
		"#\n"
		"# NOTE: Options given on the command-line are added to all configurations in a\n"
		"#       configuration file. If an option is given both on the command-line and\n"
		"#       in a configuration file, the one from the command-line is preferred.\n"
		"#\n"
		"# NOTE: If, after adding command-line options, a configuration\n"
		"#       contains mutually exclusive options an error is raised.\n"
		"#\n", CLASP_VERSION);
	for (ConfigIter it = ClaspCliConfig::getConfig(Clasp::Cli::config_many); it.valid(); it.next()) {
		printf("%s: %s\n", it.name(), it.args());
	}
}

void ClaspAppBase::printVersion() {
	ProgramOptions::Application::printVersion();
	printLibClaspVersion();
}

void ClaspAppBase::printLibClaspVersion() const {
	if (strcmp(getName(), "clasp") != 0) {
		printf("libclasp version %s\n", CLASP_VERSION);
	}
	printf("Configuration: WITH_THREADS=%d", WITH_THREADS);
#if defined(WITH_THREADS) && defined(TBB_VERSION_MAJOR) && WITH_THREADS
	printf(" (Intel TBB version %d.%d)", TBB_VERSION_MAJOR, TBB_VERSION_MINOR);
#endif
	printf("\n%s\n", CLASP_LEGAL);
	fflush(stdout);
}

void ClaspAppBase::printHelp(const ProgramOptions::OptionContext& root) {
	ProgramOptions::Application::printHelp(root);
	if (root.getActiveDescLevel() >= ProgramOptions::desc_level_e1) {
		printf("[asp] %s\n", ClaspCliConfig::getDefaults(Problem_t::Asp));
		printf("[cnf] %s\n", ClaspCliConfig::getDefaults(Problem_t::Sat));
		printf("[opb] %s\n", ClaspCliConfig::getDefaults(Problem_t::Pb));
	}
	if (root.getActiveDescLevel() >= ProgramOptions::desc_level_e2) {
		printf("\nDefault configurations:\n");
		printDefaultConfigs();
	}
	fflush(stdout);
}

void ClaspAppBase::printDefaultConfigs() const {
	uint32 minW = 2, maxW = 80;
	std::string cmd;
	for (int i = Clasp::Cli::config_default+1; i != Clasp::Cli::config_default_max_value; ++i) {
		ConfigIter it = ClaspCliConfig::getConfig(static_cast(i));
		printf("%s:\n%*c", it.name(), minW-1, ' ');
		cmd = it.args();
		// split options into formatted lines
		std::size_t sz = cmd.size(), off = 0, n = maxW - minW;
		while (n < sz) {
			while (n != off  && cmd[n] != ' ') { --n; }
			if (n != off) { cmd[n] = 0; printf("%s\n%*c", &cmd[off], minW-1, ' '); }
			else          { break; }
			off = n+1;
			n   = (maxW - minW) + off;
		}
		printf("%s\n", cmd.c_str()+off);
	}
}
void ClaspAppBase::writeNonHcfs(const PrgDepGraph& graph) const {
	char buf[10];
	for (PrgDepGraph::NonHcfIter it = graph.nonHcfBegin(), end = graph.nonHcfEnd(); it != end; ++it) {
		snprintf(buf, 10, ".%u", (*it)->id());
		WriteCnf cnf(claspAppOpts_.hccOut + buf);
		const SharedContext& ctx = (*it)->ctx();
		cnf.writeHeader(ctx.numVars(), ctx.numConstraints());
		cnf.write(ctx.numVars(), ctx.shortImplications());
		Solver::DBRef db = ctx.master()->constraints();
		for (uint32 i = 0; i != db.size(); ++i) {
			if (ClauseHead* x = db[i]->clause()) { cnf.write(x); }
		}
		for (uint32 i = 0; i != ctx.master()->trail().size(); ++i) {
			cnf.write(ctx.master()->trail()[i]);
		}
		cnf.close();
	}
}
std::istream& ClaspAppBase::getStream(bool reopen) const {
	static std::ifstream file;
	static bool isOpen = false;
	if (!isOpen || reopen) {
		file.close();
		isOpen = true;
		if (!claspAppOpts_.input.empty() && !isStdIn(claspAppOpts_.input[0])) {
			file.open(claspAppOpts_.input[0].c_str());
			if (!file.is_open()) {
				throw std::runtime_error(ClaspStringBuffer().appendFormat("Can not read from '%s'", claspAppOpts_.input[0].c_str()).c_str());
			}
		}
	}
	return file.is_open() ? file : std::cin;
}

// Creates output object suitable for given input format
Output* ClaspAppBase::createOutput(ProblemType f) {
	SingleOwnerPtr out;
	if (claspAppOpts_.outf == ClaspAppOptions::out_none) {
		return 0;
	}
	if (claspAppOpts_.outf != ClaspAppOptions::out_json || claspAppOpts_.onlyPre) {
		TextOutput::Format outFormat = TextOutput::format_asp;
		if      (f == Problem_t::Sat){ outFormat = TextOutput::format_sat09; }
		else if (f == Problem_t::Pb) { outFormat = TextOutput::format_pb09;  }
		else if (f == Problem_t::Asp && claspAppOpts_.outf == ClaspAppOptions::out_comp) {
			outFormat = TextOutput::format_aspcomp;
		}
		out.reset(new TextOutput(verbose(), outFormat, claspAppOpts_.outAtom.c_str(), claspAppOpts_.ifs));
		if (claspConfig_.solve.maxSat && f == Problem_t::Sat) {
			static_cast(out.get())->result[TextOutput::res_sat] = "UNKNOWN";
		}
	}
	else {
		out.reset(new JsonOutput(verbose()));
	}
	if (claspAppOpts_.quiet[0] != static_cast(UCHAR_MAX)) {
		out->setModelQuiet((Output::PrintLevel)std::min(uint8(Output::print_no), claspAppOpts_.quiet[0]));
	}
	if (claspAppOpts_.quiet[1] != static_cast(UCHAR_MAX)) {
		out->setOptQuiet((Output::PrintLevel)std::min(uint8(Output::print_no), claspAppOpts_.quiet[1]));
	}
	if (claspAppOpts_.quiet[2] != static_cast(UCHAR_MAX)) {
		out->setCallQuiet((Output::PrintLevel)std::min(uint8(Output::print_no), claspAppOpts_.quiet[2]));
	}
	if (claspAppOpts_.hideAux && clasp_.get()) {
		clasp_->ctx.output.setFilter('_');
	}
	return out.release();
}
void ClaspAppBase::storeCommandArgs(const ProgramOptions::ParsedValues&) {
	/* We don't need the values */
}
void ClaspAppBase::handleStartOptions(ClaspFacade& clasp) {
	if (!clasp.incremental()) {
		claspConfig_.releaseOptions();
	}
	if (claspAppOpts_.compute && clasp.program()->type() == Problem_t::Asp) {
		Potassco::Lit_t lit = Potassco::neg(claspAppOpts_.compute);
		static_cast(clasp.program())->addRule(Potassco::Head_t::Disjunctive, Potassco::toSpan(), Potassco::toSpan(&lit, 1));
	}
	if (!claspAppOpts_.lemmaIn.empty()) {
		class LemmaIn : public Potassco::AspifInput {
		public:
			typedef Potassco::AbstractProgram PrgAdapter;
			LemmaIn(const std::string& fn, PrgAdapter* prg) : Potassco::AspifInput(*prg), prg_(prg) {
				if (!isStdIn(fn)) { file_.open(fn.c_str()); }
				CLASP_FAIL_IF(!accept(getStream()), "'lemma-in': invalid input file");
			}
			~LemmaIn() { delete prg_; }
		private:
			std::istream& getStream() { return file_.is_open() ? file_ : std::cin; }
			PrgAdapter*   prg_;
			std::ifstream file_;
		};
		SingleOwnerPtr prgTemp;
		if (clasp.program()->type() == Problem_t::Asp) { prgTemp = new Asp::LogicProgramAdapter(*static_cast(clasp.program())); }
		else { prgTemp = new BasicProgramAdapter(*clasp.program()); }
		lemmaIn_ = new LemmaIn(claspAppOpts_.lemmaIn, prgTemp.release());
	}
}
bool ClaspAppBase::handlePostGroundOptions(ProgramBuilder& prg) {
	if (!claspAppOpts_.onlyPre) {
		if (lemmaIn_.get()) { lemmaIn_->parse(); }
		if (logger_.get())  { logger_->startStep(prg, clasp_->incremental()); }
		return true;
	}
	prg.endProgram();
	if (prg.type() == Problem_t::Asp) {
		Asp::LogicProgram& asp = static_cast(prg);
		AspParser::Format outf = claspAppOpts_.onlyPre == 2 || !asp.supportsSmodels() ? AspParser::format_aspif : AspParser::format_smodels;
		AspParser::write(asp, std::cout, outf);
	}
	else {
		error("Option '--pre': unsupported input format!");
		setExitCode(E_ERROR);
	}
	return false;
}
bool ClaspAppBase::handlePreSolveOptions(ClaspFacade& clasp) {
	if (!claspAppOpts_.hccOut.empty() && clasp.ctx.sccGraph.get()){ writeNonHcfs(*clasp.ctx.sccGraph); }
	return true;
}
void ClaspAppBase::run(ClaspFacade& clasp) {
	clasp.start(claspConfig_, getStream());
	handleStartOptions(clasp);
	while (clasp.read()) {
		if (handlePostGroundOptions(*clasp.program())) {
			clasp.prepare();
			if (handlePreSolveOptions(clasp)) { clasp.solve(); }
		}
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspApp
/////////////////////////////////////////////////////////////////////////////////////////
ClaspApp::ClaspApp() {}

ProblemType ClaspApp::getProblemType() {
	return ClaspFacade::detectProblemType(getStream());
}

void ClaspApp::run(ClaspFacade& clasp) {
	ClaspAppBase::run(clasp);
}

void ClaspApp::printHelp(const ProgramOptions::OptionContext& root) {
	ClaspAppBase::printHelp(root);
	printf("\nclasp is part of Potassco: %s\n", "https://potassco.org/clasp/");
	printf("Get help/report bugs via : %s\n", "https://potassco.org/support/");
	fflush(stdout);
}
/////////////////////////////////////////////////////////////////////////////////////////
// LemmaLogger
/////////////////////////////////////////////////////////////////////////////////////////
LemmaLogger::LemmaLogger(const std::string& to, const Options& o)
	: str_(isStdOut(to) ? stdout : fopen(to.c_str(), "w"))
	, inputType_(Problem_t::Asp)
	, options_(o)
	, step_(0) {
	CLASP_FAIL_IF(!str_, "Could not open lemma log file '%s'!", to.c_str());
}
LemmaLogger::~LemmaLogger() { close(); }
void LemmaLogger::startStep(ProgramBuilder& prg, bool inc) {
	logged_ = 0;
	++step_;
	if (!options_.logText) {
		if (step_ == 1) { fprintf(str_, "asp 1 0 0%s\n", inc ? " incremental" : ""); }
		else            { fprintf(str_, "0\n"); }
	}
	if ((inputType_ = static_cast(prg.type())) == Problem_t::Asp && prg.endProgram()) {
		// create solver variable to potassco literal mapping
		Asp::LogicProgram& asp = static_cast(prg);
		for (Asp::Atom_t a = asp.startAtom(); a != asp.startAuxAtom(); ++a) {
			Literal sLit = asp.getLiteral(a);
			if (sLit.var() >= solver2asp_.size()) {
				solver2asp_.resize(sLit.var() + 1, 0);
			}
			Potassco::Lit_t& p = solver2asp_[sLit.var()];
			if (!p || (!sLit.sign() && p < 0)) {
				p = !sLit.sign() ? Potassco::lit(a) : Potassco::neg(a);
			}
		}
	}
	solver2NameIdx_.clear();
	if (options_.logText && prg.endProgram()) {
		const SharedContext& ctx = *prg.ctx();
		for (OutputTable::pred_iterator beg = ctx.output.pred_begin(), it = beg, end = ctx.output.pred_end(); it != end; ++it) {
			Var v = it->cond.var();
			if (ctx.varInfo(v).output()) {
				if (solver2NameIdx_.size() <= v) { solver2NameIdx_.resize(v + 1, UINT32_MAX); }
				solver2NameIdx_[v] = static_cast(it - beg);
			}
		}
	}
}
void LemmaLogger::add(const Solver& s, const LitVec& cc, const ConstraintInfo& info) {
	LitVec temp;
	const LitVec* out = &cc;
	uint32 lbd = info.lbd();
	if (lbd > options_.lbdMax || logged_ >= options_.logMax) { return; }
	if (info.aux() || options_.domOut || std::find_if(cc.begin(), cc.end(), std::not1(std::bind1st(std::mem_fun(&Solver::inputVar), &s))) != cc.end()) {
		uint8 vf = options_.domOut ? VarInfo::Input|VarInfo::Output : VarInfo::Input;
		if (!s.resolveToFlagged(cc, vf, temp, lbd) || lbd > options_.lbdMax) { return; }
		out = &temp;
	}
	ClaspStringBuffer lemma;
	if (options_.logText) { formatText(*out, s.sharedContext()->output, lbd, lemma); }
	else                  { formatAspif(*out, lbd, lemma); }
	fwrite(lemma.c_str(), sizeof(char), lemma.size(), str_);
	++logged_;
}
void LemmaLogger::formatAspif(const LitVec& cc, uint32, ClaspStringBuffer& out) const {
	out.appendFormat("1 0 0 0 %u", (uint32)cc.size());
	for (LitVec::const_iterator it = cc.begin(), end = cc.end(); it != end; ++it) {
		Literal sLit = ~*it; // clause -> constraint
		Potassco::Lit_t a = toInt(sLit);
		if (inputType_ == Problem_t::Asp) {
			a = sLit.var() < solver2asp_.size() ? solver2asp_[sLit.var()] : 0;
			if (!a) { return; }
			if (sLit.sign() != (a < 0)) { a = -a; }
		}
		out.appendFormat(" %d", a);
	}
	out.append("\n");
}
void LemmaLogger::formatText(const LitVec& cc, const OutputTable& tab, uint32 lbd, ClaspStringBuffer& out) const {
	out.append(":-");
	const char* sep = " ";
	for (LitVec::const_iterator it = cc.begin(), end = cc.end(); it != end; ++it) {
		Literal sLit = ~*it; // clause -> constraint
		uint32 idx = sLit.var() < solver2NameIdx_.size() ? solver2NameIdx_[sLit.var()] : UINT32_MAX;
		if (idx != UINT32_MAX) {
			const OutputTable::PredType& p = *(tab.pred_begin() + idx);
			assert(sLit.var() == p.cond.var());
			out.appendFormat("%s%s%s", sep, sLit.sign() != p.cond.sign() ? "not " : "", p.name.c_str());
		}
		else {
			if (inputType_ == Problem_t::Asp) {
				Potassco::Lit_t a = sLit.var() < solver2asp_.size() ? solver2asp_[sLit.var()] : 0;
				if (!a) { return; }
				if (sLit.sign() != (a < 0)) { a = -a; }
				sLit = Literal(Potassco::atom(a), a < 0);
			}
			out.appendFormat("%s%s__atom(%u)", sep, sLit.sign() ? "not " : "", sLit.var());
		}
		sep = ", ";
	}
	out.appendFormat(".  %%lbd = %u\n", lbd);
}
void LemmaLogger::close() {
	if (!str_) { return; }
	if (!options_.logText) { fprintf(str_, "0\n"); }
	fflush(str_);
	if (str_ != stdout) { fclose(str_); }
	str_ = 0;
	solver2asp_.clear();
}
/////////////////////////////////////////////////////////////////////////////////////////
// WriteCnf
/////////////////////////////////////////////////////////////////////////////////////////
WriteCnf::WriteCnf(const std::string& outFile) : str_(fopen(outFile.c_str(), "w")) {
	CLASP_FAIL_IF(!str_, "Could not open cnf file '%s'!", outFile.c_str());
}
WriteCnf::~WriteCnf() { close(); }
void WriteCnf::writeHeader(uint32 numVars, uint32 numCons) {
	fprintf(str_, "p cnf %u %u\n", numVars, numCons);
}
void WriteCnf::write(ClauseHead* h) {
	lits_.clear();
	h->toLits(lits_);
	for (LitVec::const_iterator it = lits_.begin(), end = lits_.end(); it != end; ++it) {
		fprintf(str_, "%d ", toInt(*it));
	}
	fprintf(str_, "%d\n", 0);
}
void WriteCnf::write(Var maxVar, const ShortImplicationsGraph& g) {
	for (Var v = 1; v <= maxVar; ++v) {
		g.forEach(posLit(v), *this);
		g.forEach(negLit(v), *this);
	}
}
void WriteCnf::write(Literal u) {
	fprintf(str_, "%d 0\n", toInt(u));
}
bool WriteCnf::unary(Literal p, Literal x) const {
	return p.rep() >= x.rep() || fprintf(str_, "%d %d 0\n", toInt(~p), toInt(x)) > 0;
}
bool WriteCnf::binary(Literal p, Literal x, Literal y) const {
	return p.rep() >= x.rep() || p.rep() >= y.rep() || fprintf(str_, "%d %d %d 0\n", toInt(~p), toInt(x), toInt(y)) > 0;
}
void WriteCnf::close() {
	if (str_) {
		fflush(str_);
		fclose(str_);
		str_ = 0;
	}
}

}} // end of namespace Clasp::Cli

clasp-3.2.2/app/clasp_app.h000066400000000000000000000224101304134206100155040ustar00rootroot00000000000000//
// Copyright (c) 2006-2012, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLASP_APP_H_INCLUDED
#define CLASP_CLASP_APP_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp { namespace Cli {
/////////////////////////////////////////////////////////////////////////////////////////
// clasp exit codes
/////////////////////////////////////////////////////////////////////////////////////////
enum ExitCode {
	E_UNKNOWN   = 0,  /*!< Satisfiablity of problem not knwon; search not started.    */
	E_INTERRUPT = 1,  /*!< Run was interrupted.                                       */
	E_SAT       = 10, /*!< At least one model was found.                              */
	E_EXHAUST   = 20, /*!< Search-space was completely examined.                      */
	E_MEMORY    = 33, /*!< Run was interrupted by out of memory exception.            */
	E_ERROR     = 65, /*!< Run was interrupted by internal error.                     */
	E_NO_RUN    = 128 /*!< Search not started because of syntax or command line error.*/
};
/////////////////////////////////////////////////////////////////////////////////////////
// clasp app helpers
/////////////////////////////////////////////////////////////////////////////////////////
class WriteCnf {
public:
	WriteCnf(const std::string& outFile);
	~WriteCnf();
	void writeHeader(uint32 numVars, uint32 numCons);
	void write(Var maxVar, const ShortImplicationsGraph& g);
	void write(ClauseHead* h);
	void write(Literal unit);
	void close();
	bool unary(Literal, Literal) const;
	bool binary(Literal, Literal, Literal) const;
private:
	WriteCnf(const WriteCnf&);
	WriteCnf& operator=(const WriteCnf&);
	FILE*  str_;
	LitVec lits_;
};
class LemmaLogger {
public:
	struct Options {
		Options() : logMax(UINT32_MAX), lbdMax(UINT32_MAX), domOut(false), logText(false) {}
		uint32 logMax;  // log at most logMax lemmas
		uint32 lbdMax;  // only log lemmas with lbd <= lbdMax
		bool   domOut;  // only log lemmas that can be expressed over out variables
		bool   logText; // log lemmas in ground lp format
	};
	LemmaLogger(const std::string& outFile, const Options& opts);
	~LemmaLogger();
	void startStep(ProgramBuilder& prg, bool inc);
	void add(const Solver& s, const LitVec& cc, const ConstraintInfo& info);
	void close();
private:
	typedef PodVector::type Var2Idx;
	typedef Atomic_t::type Counter;
	LemmaLogger(const LemmaLogger&);
	LemmaLogger& operator=(const LemmaLogger&);
	void formatAspif(const LitVec& cc, uint32 lbd, ClaspStringBuffer& out)  const;
	void formatText(const LitVec& cc, const OutputTable& tab, uint32 lbd, ClaspStringBuffer& out) const;
	FILE*            str_;
	Potassco::LitVec solver2asp_;
	Var2Idx          solver2NameIdx_;
	ProblemType      inputType_;
	Options          options_;
	int              step_;
	Counter          logged_;
};
/////////////////////////////////////////////////////////////////////////////////////////
// clasp specific application options
/////////////////////////////////////////////////////////////////////////////////////////
struct ClaspAppOptions {
	typedef LemmaLogger::Options LogOptions;
	ClaspAppOptions();
	typedef std::vector  StringSeq;
	static bool mappedOpts(ClaspAppOptions*, const std::string&, const std::string&);
	void initOptions(ProgramOptions::OptionContext& root);
	bool validateOptions(const ProgramOptions::ParsedOptions& parsed);
	StringSeq   input;     // list of input files - only first used!
	std::string lemmaLog;  // optional file name for writing learnt lemmas
	std::string lemmaIn;   // optional file name for reading learnt lemmas
	std::string hccOut;    // optional file name for writing scc programs
	std::string outAtom;   // optional format string for atoms
	uint32      outf;      // output format
	int         compute;   // force literal compute to true
	LogOptions  lemma;     // options for lemma logging
	char        ifs;       // output field separator
	bool        hideAux;   // output aux atoms?
	uint8       quiet[3];  // configure printing of models, optimization values, and call steps
	uint8       onlyPre;   // run preprocessor and exit
	bool        printPort; // print portfolio and exit
	enum OutputFormat { out_def = 0, out_comp = 1, out_json = 2, out_none = 3 };
};
/////////////////////////////////////////////////////////////////////////////////////////
// clasp application base
/////////////////////////////////////////////////////////////////////////////////////////
// Base class for applications using the clasp library.
class ClaspAppBase : public ProgramOptions::Application, public Clasp::EventHandler {
public:
	typedef ClaspFacade::Summary  RunSummary;
	typedef ProgramOptions::PosOption PosOption;
protected:
	using ProgramOptions::Application::run;
	ClaspAppBase();
	~ClaspAppBase();
	// -------------------------------------------------------------------------------------------
	// Functions to be implemented by subclasses
	virtual ProblemType   getProblemType()             = 0;
	virtual void          run(ClaspFacade& clasp)      = 0;
	virtual Output*       createOutput(ProblemType f);
	virtual void          storeCommandArgs(const ProgramOptions::ParsedValues& values);
	// -------------------------------------------------------------------------------------------
	// Helper functions that subclasses might call during run
	void handleStartOptions(ClaspFacade& clasp);
	bool handlePostGroundOptions(ProgramBuilder& prg);
	bool handlePreSolveOptions(ClaspFacade& clasp);
	// -------------------------------------------------------------------------------------------
	// Application functions
	virtual const int*  getSignals()    const;
	virtual HelpOpt     getHelpOption() const { return HelpOpt("Print {1=basic|2=more|3=full} help and exit", 3); }
	virtual PosOption   getPositional() const { return parsePositional; }
	virtual void        initOptions(ProgramOptions::OptionContext& root);
	virtual void        validateOptions(const ProgramOptions::OptionContext& root, const ProgramOptions::ParsedOptions& parsed, const ProgramOptions::ParsedValues& values);
	virtual void        setup();
	virtual void        run();
	virtual void        shutdown();
	virtual bool        onSignal(int);
	virtual void        printHelp(const ProgramOptions::OptionContext& root);
	virtual void        printVersion();
	static  bool        parsePositional(const std::string& s, std::string& out);
	// -------------------------------------------------------------------------------------------
	// Event handler
	virtual void onEvent(const Event& ev);
	virtual bool onModel(const Solver& s, const Model& m);
	virtual bool onUnsat(const Solver& s, const Model& m);
	// -------------------------------------------------------------------------------------------
	// Status information & output
	int  exitCode(const RunSummary& sol)    const;
	void printTemplate()                    const;
	void printDefaultConfigs()              const;
	void printLibClaspVersion()             const;
	std::istream& getStream(bool reopen = false) const;
	// -------------------------------------------------------------------------------------------
	// Functions called in handlePreSolveOptions()
	void writeNonHcfs(const PrgDepGraph& graph) const;
	typedef Potassco::ProgramReader     LemmaReader;
	typedef SingleOwnerPtr      OutPtr;
	typedef SingleOwnerPtr ClaspPtr;
	typedef SingleOwnerPtr LogPtr;
	typedef SingleOwnerPtr LemmaPtr;
	ClaspCliConfig  claspConfig_;
	ClaspAppOptions claspAppOpts_;
	ClaspPtr        clasp_;
	OutPtr          out_;
	LogPtr          logger_;
	LemmaPtr        lemmaIn_;
	unsigned        fpuMode_;
};
/////////////////////////////////////////////////////////////////////////////////////////
// clasp application
/////////////////////////////////////////////////////////////////////////////////////////
// Standalone clasp application.
class ClaspApp : public ClaspAppBase {
public:
	ClaspApp();
	const char* getName()       const { return "clasp"; }
	const char* getVersion()    const { return CLASP_VERSION; }
	const char* getUsage()      const {
		return
			"[number] [options] [file]\n"
			"Compute at most  models (0=all) of the instance given in ";
	}
protected:
	virtual ProblemType getProblemType();
	virtual void        run(ClaspFacade& clasp);
	virtual void        printHelp(const ProgramOptions::OptionContext& root);
private:
	ClaspApp(const ClaspApp&);
	ClaspApp& operator=(const ClaspApp&);
};
}}
#endif
clasp-3.2.2/app/lpconvert/000077500000000000000000000000001304134206100154065ustar00rootroot00000000000000clasp-3.2.2/app/lpconvert/lpconvert.cpp000066400000000000000000000071051304134206100201310ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace ProgramOptions;

class LpConvert : public ProgramOptions::Application {
public:
	virtual const char* getName()       const { return "lpconvert"; }
	virtual const char* getVersion()    const { return "1.0.0"; }
	virtual PosOption   getPositional() const { return &positional; }
	virtual const char* getUsage()      const {
		return
			"[options] []\n"
			"Convert program in  or standard input";
	}
	virtual void initOptions(OptionContext& root);
	virtual void validateOptions(const OptionContext&, const ParsedOptions&, const ParsedValues&) {}
	virtual void setup() {}
	virtual void run();
private:
	static bool positional(const std::string&, std::string& optOut) {
		optOut = "input";
		return true;
	}
	static int error(int line, const char* what) {
		fprintf(stderr, "*** ERROR: In line %d: %s\n", line, what);
		static_cast(Application::getInstance())->exit(EXIT_FAILURE);
		return EXIT_FAILURE;
	}
	std::string input_;
	std::string output_;
	bool potassco_;
	bool filter_;
};

void LpConvert::initOptions(OptionContext& root) {
	OptionGroup convert("Conversion Options");
	convert.addOptions()
		("input,i,@2", storeTo(input_),  "Input file")
		("potassco,p", flag(potassco_ = false), "Enable potassco extensions")
		("filter,f", flag(filter_ = false), "Hide converted potassco predicates")
		("output,o", storeTo(output_)->arg(""), "Write output to  (default: stdout)")
	;
	root.add(convert);
}
void LpConvert::run() {
	std::ifstream iFile;
	std::ofstream oFile;
	if (!input_.empty() && input_ != "-") {
		iFile.open(input_.c_str());
		if (!iFile.is_open()) { throw std::runtime_error("Could not open input file!"); }
	}
	if (!output_.empty() && output_ != "-") {
		if (input_ == output_) { throw std::runtime_error("Input and output must be different!"); }
		oFile.open(output_.c_str());
		if (!oFile.is_open()) { throw std::runtime_error("Could not open output file!"); }
	}
	std::istream& in = iFile.is_open() ? iFile : std::cin;
	std::ostream& os = oFile.is_open() ? oFile : std::cout;
	if (in.peek() == 'a') {
		Potassco::SmodelsOutput writer(os, potassco_, 0);
		Potassco::SmodelsConvert converter(writer, potassco_);
		Potassco::readAspif(in, converter, &error);
	}
	else if (std::isdigit(in.peek())) {
		Potassco::AspifOutput out(os);
		Potassco::SmodelsInput::Options opts;
		if (potassco_) {
			opts.enableClaspExt().convertEdges().convertHeuristic();
			if (filter_) { opts.dropConverted(); }
		}
		Potassco::readSmodels(in, out, &error, opts);
	}
	else {
		throw std::runtime_error("Unrecognized input format!");
	}
	iFile.close();
	oFile.close();
}

int main(int argc, char** argv) {
	LpConvert app;
	return app.main(argc, argv);
}
clasp-3.2.2/app/main.cpp000066400000000000000000000034241304134206100150250ustar00rootroot00000000000000//
// Copyright (c) 2006-2007, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "clasp_app.h"
/////////////////////////////////////////////////////////////////////////////////////////
// main - entry point
/////////////////////////////////////////////////////////////////////////////////////////
// #define CHECK_HEAP
#if defined (_MSC_VER) && defined(CHECK_HEAP) && _MSC_VER >= 1200
#include 
#endif
int main(int argc, char** argv) {
#if defined (_MSC_VER) && defined (CHECK_HEAP) && _MSC_VER >= 1200
	_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) |
	               CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF |
	               _CRTDBG_CHECK_ALWAYS_DF);

	_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR );
	_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
	_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
#endif
	Clasp::Cli::ClaspApp app;
	return app.main(argc, argv);
}
clasp-3.2.2/build_vc/000077500000000000000000000000001304134206100144015ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/000077500000000000000000000000001304134206100151525ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/000077500000000000000000000000001304134206100162545ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/app/000077500000000000000000000000001304134206100170345ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/app/app.vcproj000066400000000000000000000214431304134206100210450ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
		
		
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	

clasp-3.2.2/build_vc/vc10/clasp/app/app.vcxproj000066400000000000000000000574451304134206100212500ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_MT_Static
      Win32
    
    
      Release_MT_Static
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    {EF6CFDA6-F838-40E9-8688-BEE97EE14265}
    app
    Win32Proj
    clasp
  
  
  
    Application
    Static
    Unicode
    true
  
  
    Application
    Static
    Unicode
    true
  
  
    Application
    Static
    Unicode
    true
  
  
    Application
    Static
    Unicode
    true
  
  
    Application
    Unicode
    true
  
  
    Application
    Unicode
    true
  
  
    Application
    Unicode
  
  
    Application
    Unicode
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    true
    true
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\lib\static;C:\Users\kaufmann\lib\cppunit-1.12.1\lib;$(LibraryPath)
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\lib\static;C:\Users\kaufmann\lib\cppunit-1.12.1\lib;$(LibraryPath)
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    clasp
    clasp
    clasp
    clasp
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\lib\intel64\vc10;$(LibraryPath)
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      EditAndContinue
    
    
      $(OutDir)clasp.exe
      true
      Console
      MachineX86
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      ProgramDatabase
    
    
      $(OutDir)clasp.exe
      true
      Console
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      $(OutDir)clasp.exe
      true
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      $(OutDir)clasp.exe
      true
      Console
      true
      true
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level3
      
      
    
    
      $(OutDir)clasp.exe
      false
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level3
      
      
    
    
      $(OutDir)clasp.exe
      false
      Console
      true
      true
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;__TBB_NO_IMPLICIT_LINKAGE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level3
      
      
    
    
      tbb-static.lib;%(AdditionalDependencies)
      $(OutDir)clasp.exe
      false
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;__TBB_NO_IMPLICIT_LINKAGE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level3
      
      
    
    
      tbb-static-x64.lib;%(AdditionalDependencies)
      $(OutDir)clasp.exe
      false
      Console
      true
      true
    
  
  
    
    
  
  
    
  
  
    
      {93e57885-2f74-490f-95be-a124e08fb381}
      true
      false
      false
      true
      false
    
    
      {488b1dcf-d41e-4416-a6d0-336cbc2871fe}
      false
    
    
      {a95999d0-c3a7-423f-84d1-d620674a136e}
      false
    
  
  
  
  
clasp-3.2.2/build_vc/vc10/clasp/clasp.sln000066400000000000000000000235241304134206100201020ustar00rootroot00000000000000
Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libclasp", "lib\lib.vcxproj", "{A95999D0-C3A7-423F-84D1-D620674A136E}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "app", "app\app.vcxproj", "{EF6CFDA6-F838-40E9-8688-BEE97EE14265}"
	ProjectSection(ProjectDependencies) = postProject
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE} = {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test", "test\test.vcxproj", "{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}"
	ProjectSection(ProjectDependencies) = postProject
		{93E57885-2F74-490F-95BE-A124E08FB381} = {93E57885-2F74-490F-95BE-A124E08FB381}
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE} = {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "examples", "examples\examples.vcxproj", "{3D533F47-3043-4EAC-9669-06F01CDB75E2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libprogram_opts", "libprogram_opts\libprogram_opts.vcxproj", "{488B1DCF-D41E-4416-A6D0-336CBC2871FE}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "liblp", "liblp\liblp.vcxproj", "{93E57885-2F74-490F-95BE-A124E08FB381}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Win32 = Debug|Win32
		Debug|x64 = Debug|x64
		Release_MT_Static|Win32 = Release_MT_Static|Win32
		Release_MT_Static|x64 = Release_MT_Static|x64
		Release_Static|Win32 = Release_Static|Win32
		Release_Static|x64 = Release_Static|x64
		Release|Win32 = Release|Win32
		Release|x64 = Release|x64
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|Win32.ActiveCfg = Debug|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|Win32.Build.0 = Debug|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|x64.ActiveCfg = Debug|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|x64.Build.0 = Debug|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|Win32.ActiveCfg = Release_MT_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|Win32.Build.0 = Release_MT_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|x64.ActiveCfg = Release_MT_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|x64.Build.0 = Release_MT_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|x64.Build.0 = Release_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|Win32.ActiveCfg = Release|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|Win32.Build.0 = Release|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|x64.ActiveCfg = Release|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|x64.Build.0 = Release|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|Win32.ActiveCfg = Debug|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|Win32.Build.0 = Debug|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|x64.ActiveCfg = Debug|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|x64.Build.0 = Debug|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|Win32.ActiveCfg = Release_MT_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|Win32.Build.0 = Release_MT_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|x64.ActiveCfg = Release_MT_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|x64.Build.0 = Release_MT_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|x64.Build.0 = Release_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|Win32.ActiveCfg = Release|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|Win32.Build.0 = Release|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|x64.ActiveCfg = Release|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|x64.Build.0 = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|Win32.ActiveCfg = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|Win32.Build.0 = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|x64.ActiveCfg = Debug|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|x64.Build.0 = Debug|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|Win32.ActiveCfg = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|Win32.Build.0 = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|x64.ActiveCfg = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|x64.Build.0 = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|Win32.ActiveCfg = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|Win32.Build.0 = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|x64.ActiveCfg = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|x64.Build.0 = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|Win32.ActiveCfg = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|Win32.Build.0 = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|x64.ActiveCfg = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|x64.Build.0 = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|Win32.ActiveCfg = Debug|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|Win32.Build.0 = Debug|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|x64.ActiveCfg = Debug|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|x64.Build.0 = Debug|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|x64.ActiveCfg = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|x64.Build.0 = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|x64.ActiveCfg = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|x64.Build.0 = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|x64.ActiveCfg = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|x64.Build.0 = Release|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|Win32.ActiveCfg = Debug|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|Win32.Build.0 = Debug|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|x64.ActiveCfg = Debug|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|x64.Build.0 = Debug|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|x64.ActiveCfg = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|x64.Build.0 = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|x64.Build.0 = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|Win32.ActiveCfg = Release|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|Win32.Build.0 = Release|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|x64.ActiveCfg = Release|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|x64.Build.0 = Release|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Debug|Win32.ActiveCfg = Debug|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Debug|Win32.Build.0 = Debug|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Debug|x64.ActiveCfg = Debug|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Debug|x64.Build.0 = Debug|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_MT_Static|x64.ActiveCfg = Release_Static|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_MT_Static|x64.Build.0 = Release_Static|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release_Static|x64.Build.0 = Release_Static|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release|Win32.ActiveCfg = Release|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release|Win32.Build.0 = Release|Win32
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release|x64.ActiveCfg = Release|x64
		{93E57885-2F74-490F-95BE-A124E08FB381}.Release|x64.Build.0 = Release|x64
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal
clasp-3.2.2/build_vc/vc10/clasp/clasp.vcproj000066400000000000000000000070241304134206100206060ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
		
		
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc10/clasp/examples/000077500000000000000000000000001304134206100200725ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/examples/examples.vcproj000066400000000000000000000105721304134206100231420ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
		
		
			
			
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc10/clasp/examples/examples.vcxproj000066400000000000000000000246611304134206100233360ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    {3D533F47-3043-4EAC-9669-06F01CDB75E2}
    examples
    Win32Proj
  
  
  
    Application
    Unicode
    true
  
  
    Application
    Unicode
    true
  
  
    Application
    Unicode
  
  
    Application
    Unicode
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    true
    true
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      EditAndContinue
    
    
      true
      Console
      MachineX86
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
    
  
  
    
    
    
    
  
  
    
  
  
    
      {a95999d0-c3a7-423f-84d1-d620674a136e}
      false
    
  
  
  
  
clasp-3.2.2/build_vc/vc10/clasp/lib/000077500000000000000000000000001304134206100170225ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/lib/lib.vcproj000066400000000000000000000303141304134206100210160ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				
				
				
				
				
				
				
				
				
				
				
				
				
				
			
			
				
				
				
				
				
				
				
				
			
		
	
	
	

clasp-3.2.2/build_vc/vc10/clasp/lib/lib.vcxproj000066400000000000000000000576241304134206100212230ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_MT_Static
      Win32
    
    
      Release_MT_Static
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    libclasp
    {A95999D0-C3A7-423F-84D1-D620674A136E}
    lib
    Win32Proj
  
  
  
    StaticLibrary
    Static
    Unicode
    true
  
  
    StaticLibrary
    Static
    Unicode
    true
  
  
    StaticLibrary
    Static
    Unicode
    true
  
  
    StaticLibrary
    Static
    Unicode
    true
  
  
    StaticLibrary
    Unicode
    true
  
  
    StaticLibrary
    Unicode
    true
  
  
    StaticLibrary
    Unicode
  
  
    StaticLibrary
    Unicode
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;WITH_THREADS=1;CLASP_ENABLE_PRAGMA_TODO=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      EditAndContinue
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;WITH_THREADS=1;CLASP_ENABLE_PRAGMA_TODO=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;__TBB_NO_IMPLICIT_LINKAGE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;__TBB_NO_IMPLICIT_LINKAGE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  
  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  
  
    
    
  
  
  
  
clasp-3.2.2/build_vc/vc10/clasp/liblp/000077500000000000000000000000001304134206100173565ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/liblp/liblp.vcproj000066400000000000000000000146101304134206100217070ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
		
		
			
			
		
	
	
	

clasp-3.2.2/build_vc/vc10/clasp/liblp/liblp.vcxproj000066400000000000000000000346621304134206100221100ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    liblp
    {93E57885-2F74-490F-95BE-A124E08FB381}
    lib
    Win32Proj
  
  
  
    StaticLibrary
    Static
    Unicode
    true
  
  
    StaticLibrary
    Static
    Unicode
    true
  
  
    StaticLibrary
    Unicode
    true
  
  
    StaticLibrary
    Unicode
    true
  
  
    StaticLibrary
    Unicode
  
  
    StaticLibrary
    Unicode
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
  
  
    
      Disabled
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      EditAndContinue
    
  
  
    
      Disabled
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
    
    
    
    
    
    
    
  
  
    
    
  
  
  
  
clasp-3.2.2/build_vc/vc10/clasp/libprogram_opts/000077500000000000000000000000001304134206100214575ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/libprogram_opts/libprogram_opts.vcxproj000066400000000000000000000257251304134206100263120ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    
    
    
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
    Win32Proj
    libprogram_opts
  
  
  
    StaticLibrary
    true
    Unicode
  
  
    StaticLibrary
    true
    Unicode
  
  
    StaticLibrary
    false
    true
    Unicode
  
  
    StaticLibrary
    false
    true
    Unicode
    Static
  
  
    StaticLibrary
    false
    true
    Unicode
  
  
    StaticLibrary
    false
    true
    Unicode
    Static
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
  
    
      
      
      Level4
      Disabled
      WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
    
  
  
    
      
      
      Level4
      Disabled
      WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
  
  
clasp-3.2.2/build_vc/vc10/clasp/test/000077500000000000000000000000001304134206100172335ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc10/clasp/test/test.vcproj000066400000000000000000000130501304134206100214360ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
		
	
	
	

clasp-3.2.2/build_vc/vc10/clasp/test/test.vcxproj000066400000000000000000000301271304134206100216320ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    {73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}
    test
    Win32Proj
    test_clasp
  
  
  
    Application
    Unicode
    true
  
  
    Application
    Unicode
    true
  
  
    Application
    Unicode
  
  
    Application
    Unicode
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    true
    true
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      EditAndContinue
    
    
      cppunitd.lib;%(AdditionalDependencies)
      true
      Console
      MachineX86
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      ProgramDatabase
    
    
      cppunitd.lib;%(AdditionalDependencies)
      true
      Console
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
    
  
  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  
  
    
  
  
    
      {93e57885-2f74-490f-95be-a124e08fb381}
    
    
      {488b1dcf-d41e-4416-a6d0-336cbc2871fe}
    
    
      {a95999d0-c3a7-423f-84d1-d620674a136e}
      false
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/000077500000000000000000000000001304134206100151545ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/000077500000000000000000000000001304134206100162565ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/app/000077500000000000000000000000001304134206100170365ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/app/app.vcproj000066400000000000000000000214431304134206100210470ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
		
		
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	

clasp-3.2.2/build_vc/vc12/clasp/app/app.vcxproj000066400000000000000000000570771304134206100212530ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_MT_Static
      Win32
    
    
      Release_MT_Static
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    {EF6CFDA6-F838-40E9-8688-BEE97EE14265}
    app
    Win32Proj
    clasp
  
  
  
    Application
    Static
    Unicode
    true
    v120
  
  
    Application
    Static
    Unicode
    true
    v120
  
  
    Application
    Static
    Unicode
    true
    v120
  
  
    Application
    Static
    Unicode
    true
    v120
  
  
    Application
    Unicode
    true
    v120
  
  
    Application
    Unicode
    true
    v120
  
  
    Application
    Unicode
    v120
  
  
    Application
    Unicode
    v120
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    true
    true
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\lib\static;C:\Users\kaufmann\lib\cppunit-1.12.1\lib;$(LibraryPath)
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\lib\static;C:\Users\kaufmann\lib\cppunit-1.12.1\lib;$(LibraryPath)
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    clasp
    clasp
    clasp
    clasp
  
  
    $(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);F:\lib\tbb\tbb42_20140416oss\lib\intel64\vc12;
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      EditAndContinue
    
    
      $(OutDir)clasp.exe
      true
      Console
      MachineX86
      
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      ProgramDatabase
    
    
      $(OutDir)clasp.exe
      true
      Console
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      $(OutDir)clasp.exe
      true
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      $(OutDir)clasp.exe
      true
      Console
      true
      true
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level3
      
      
    
    
      $(OutDir)clasp.exe
      false
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level3
      
      
    
    
      $(OutDir)clasp.exe
      false
      Console
      true
      true
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;WITH_THREADS=1;CLASP_USE_STD_THREAD=1%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level4
      
      
    
    
      %(AdditionalDependencies)
      $(OutDir)clasp.exe
      false
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;__TBB_NO_IMPLICIT_LINKAGE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      
      
      Level3
      
      
    
    
      tbb-static-x64.lib;%(AdditionalDependencies)
      $(OutDir)clasp.exe
      false
      Console
      true
      true
    
  
  
    
    
  
  
    
  
  
    
      {e189ec30-18d8-44d6-825e-4be171ba6f55}
    
    
      {488b1dcf-d41e-4416-a6d0-336cbc2871fe}
      false
    
    
      {a95999d0-c3a7-423f-84d1-d620674a136e}
      false
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/clasp/clasp.sln000066400000000000000000000316111304134206100201000ustar00rootroot00000000000000
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.40629.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libclasp", "lib\lib.vcxproj", "{A95999D0-C3A7-423F-84D1-D620674A136E}"
	ProjectSection(ProjectDependencies) = postProject
		{E189EC30-18D8-44D6-825E-4BE171BA6F55} = {E189EC30-18D8-44D6-825E-4BE171BA6F55}
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE} = {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "clasp", "app\app.vcxproj", "{EF6CFDA6-F838-40E9-8688-BEE97EE14265}"
	ProjectSection(ProjectDependencies) = postProject
		{E189EC30-18D8-44D6-825E-4BE171BA6F55} = {E189EC30-18D8-44D6-825E-4BE171BA6F55}
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE} = {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_clasp", "test\test.vcxproj", "{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}"
	ProjectSection(ProjectDependencies) = postProject
		{E189EC30-18D8-44D6-825E-4BE171BA6F55} = {E189EC30-18D8-44D6-825E-4BE171BA6F55}
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE} = {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "examples", "examples\examples.vcxproj", "{3D533F47-3043-4EAC-9669-06F01CDB75E2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libprogram_opts", "libprogram_opts\libprogram_opts.vcxproj", "{488B1DCF-D41E-4416-A6D0-336CBC2871FE}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "liblp", "liblplp\liblp.vcxproj", "{E189EC30-18D8-44D6-825E-4BE171BA6F55}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lpconvert", "lpconvert\lpconvert.vcxproj", "{F3035A68-E2CD-4005-A928-FB2E74849682}"
	ProjectSection(ProjectDependencies) = postProject
		{E189EC30-18D8-44D6-825E-4BE171BA6F55} = {E189EC30-18D8-44D6-825E-4BE171BA6F55}
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE} = {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_lp", "test_lp\test_lp.vcxproj", "{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}"
	ProjectSection(ProjectDependencies) = postProject
		{E189EC30-18D8-44D6-825E-4BE171BA6F55} = {E189EC30-18D8-44D6-825E-4BE171BA6F55}
	EndProjectSection
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Win32 = Debug|Win32
		Debug|x64 = Debug|x64
		Release_MT_Static|Win32 = Release_MT_Static|Win32
		Release_MT_Static|x64 = Release_MT_Static|x64
		Release_Static|Win32 = Release_Static|Win32
		Release_Static|x64 = Release_Static|x64
		Release|Win32 = Release|Win32
		Release|x64 = Release|x64
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|Win32.ActiveCfg = Debug|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|Win32.Build.0 = Debug|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|x64.ActiveCfg = Debug|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|x64.Build.0 = Debug|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|Win32.ActiveCfg = Release_MT_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|Win32.Build.0 = Release_MT_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|x64.ActiveCfg = Release_MT_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|x64.Build.0 = Release_MT_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|x64.Build.0 = Release_Static|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|Win32.ActiveCfg = Release|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|Win32.Build.0 = Release|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|x64.ActiveCfg = Release|x64
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|x64.Build.0 = Release|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|Win32.ActiveCfg = Debug|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|Win32.Build.0 = Debug|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|x64.ActiveCfg = Debug|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|x64.Build.0 = Debug|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|Win32.ActiveCfg = Release_MT_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|Win32.Build.0 = Release_MT_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|x64.ActiveCfg = Release_MT_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|x64.Build.0 = Release_MT_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|x64.Build.0 = Release_Static|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|Win32.ActiveCfg = Release|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|Win32.Build.0 = Release|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|x64.ActiveCfg = Release|x64
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|x64.Build.0 = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|Win32.ActiveCfg = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|Win32.Build.0 = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|x64.ActiveCfg = Debug|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|x64.Build.0 = Debug|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|Win32.ActiveCfg = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|Win32.Build.0 = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|x64.ActiveCfg = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|x64.Build.0 = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|Win32.ActiveCfg = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|Win32.Build.0 = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|x64.ActiveCfg = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|x64.Build.0 = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|Win32.ActiveCfg = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|Win32.Build.0 = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|x64.ActiveCfg = Release|x64
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|x64.Build.0 = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|Win32.ActiveCfg = Debug|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|Win32.Build.0 = Debug|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|x64.ActiveCfg = Debug|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|x64.Build.0 = Debug|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|x64.ActiveCfg = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|x64.Build.0 = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|x64.ActiveCfg = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|x64.Build.0 = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|x64.ActiveCfg = Release|x64
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|x64.Build.0 = Release|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|Win32.ActiveCfg = Debug|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|Win32.Build.0 = Debug|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|x64.ActiveCfg = Debug|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Debug|x64.Build.0 = Debug|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|x64.ActiveCfg = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_MT_Static|x64.Build.0 = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release_Static|x64.Build.0 = Release_Static|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|Win32.ActiveCfg = Release|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|Win32.Build.0 = Release|Win32
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|x64.ActiveCfg = Release|x64
		{488B1DCF-D41E-4416-A6D0-336CBC2871FE}.Release|x64.Build.0 = Release|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Debug|Win32.ActiveCfg = Debug|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Debug|Win32.Build.0 = Debug|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Debug|x64.ActiveCfg = Debug|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Debug|x64.Build.0 = Debug|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_MT_Static|x64.ActiveCfg = Release_Static|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_MT_Static|x64.Build.0 = Release_Static|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_Static|x64.ActiveCfg = Release_Static|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release_Static|x64.Build.0 = Release_Static|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release|Win32.ActiveCfg = Release|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release|Win32.Build.0 = Release|Win32
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release|x64.ActiveCfg = Release|x64
		{E189EC30-18D8-44D6-825E-4BE171BA6F55}.Release|x64.Build.0 = Release|x64
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Debug|Win32.ActiveCfg = Debug|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Debug|Win32.Build.0 = Debug|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Debug|x64.ActiveCfg = Debug|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release_MT_Static|x64.ActiveCfg = Release|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release_Static|x64.ActiveCfg = Release|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release|Win32.ActiveCfg = Release|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release|Win32.Build.0 = Release|Win32
		{F3035A68-E2CD-4005-A928-FB2E74849682}.Release|x64.ActiveCfg = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Debug|Win32.ActiveCfg = Debug|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Debug|Win32.Build.0 = Debug|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Debug|x64.ActiveCfg = Debug|x64
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release_MT_Static|Win32.ActiveCfg = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release_MT_Static|Win32.Build.0 = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release_MT_Static|x64.ActiveCfg = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release_Static|Win32.ActiveCfg = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release_Static|Win32.Build.0 = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release_Static|x64.ActiveCfg = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release|Win32.ActiveCfg = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release|Win32.Build.0 = Release|Win32
		{F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}.Release|x64.ActiveCfg = Release|Win32
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal
clasp-3.2.2/build_vc/vc12/clasp/clasp.vcproj000066400000000000000000000070241304134206100206100ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
		
		
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc12/clasp/examples/000077500000000000000000000000001304134206100200745ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/examples/examples.vcproj000066400000000000000000000105721304134206100231440ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
		
		
			
			
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc12/clasp/examples/examples.vcxproj000066400000000000000000000264551304134206100233430ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    {3D533F47-3043-4EAC-9669-06F01CDB75E2}
    examples
    Win32Proj
  
  
  
    Application
    Unicode
    true
    v120
  
  
    Application
    Unicode
    true
    v120
  
  
    Application
    Unicode
    v120
  
  
    Application
    Unicode
    v120
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    true
    true
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
  
  
    F:\lib\tbb\tbb42_20140416oss\lib\intel64\vc12;$(LibraryPath)
  
  
    F:\lib\tbb\tbb42_20140416oss\lib\intel64\vc12;$(LibraryPath)
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      EditAndContinue
    
    
      true
      Console
      MachineX86
      
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
    
  
  
    
    
    
    
    
  
  
    
  
  
    
      {e189ec30-18d8-44d6-825e-4be171ba6f55}
    
    
      {a95999d0-c3a7-423f-84d1-d620674a136e}
      false
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/clasp/lib/000077500000000000000000000000001304134206100170245ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/lib/lib.vcproj000066400000000000000000000303141304134206100210200ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				
				
				
				
				
				
				
				
				
				
				
				
				
				
			
			
				
				
				
				
				
				
				
				
			
		
	
	
	

clasp-3.2.2/build_vc/vc12/clasp/lib/lib.vcxproj000066400000000000000000000603521304134206100212150ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_MT_Static
      Win32
    
    
      Release_MT_Static
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    libclasp
    {A95999D0-C3A7-423F-84D1-D620674A136E}
    lib
    Win32Proj
  
  
  
    StaticLibrary
    Static
    Unicode
    true
    v120
  
  
    StaticLibrary
    Static
    Unicode
    true
    v120
  
  
    StaticLibrary
    Static
    Unicode
    true
    v120
  
  
    StaticLibrary
    Static
    Unicode
    true
    v120
  
  
    StaticLibrary
    Unicode
    true
    v120
  
  
    StaticLibrary
    Unicode
    true
    v120
  
  
    StaticLibrary
    Unicode
    v120
  
  
    StaticLibrary
    Unicode
    v120
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    F:\lib\tbb\tbb42_20140416oss\include;F:\lib\cppunit-1.12.1\include;$(IncludePath)
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;WITH_THREADS=1;CLASP_ENABLE_PRAGMA_TODO=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      EditAndContinue
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;WITH_THREADS=1;CLASP_ENABLE_PRAGMA_TODO=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;WITH_THREADS=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;WITH_THREADS=1;CLASP_USE_STD_THREAD=1;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;..\..\..\..\libprogram_opts;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;__TBB_NO_IMPLICIT_LINKAGE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  
  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  
  
    
    
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/clasp/liblplp/000077500000000000000000000000001304134206100177145ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/liblplp/liblp.vcxproj000066400000000000000000000362351304134206100224440ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    liblp
    {E189EC30-18D8-44D6-825E-4BE171BA6F55}
    lib
    Win32Proj
  
  
  
    StaticLibrary
    Static
    Unicode
    true
    v120
  
  
    StaticLibrary
    Static
    Unicode
    true
    v120
  
  
    StaticLibrary
    Unicode
    true
    v120
  
  
    StaticLibrary
    Unicode
    true
    v120
  
  
    StaticLibrary
    Unicode
    v120
  
  
    StaticLibrary
    Unicode
    v120
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
    C:\Users\kaufmann\lib\tbb\tbb41_20120718oss\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;
  
  
    
      Disabled
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      EditAndContinue
    
  
  
    
      Disabled
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_LIB;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level4
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_LIB;_SECURE_SCL=0;%(PreprocessorDefinitions)
      MultiThreaded
      false
      true
      NotSet
      
      
      Level3
      
      
    
  
  
    
    
    
    
    
    
    
    
  
  
    
    
    
    
    
    
    
    
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/clasp/libprogram_opts/000077500000000000000000000000001304134206100214615ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/libprogram_opts/libprogram_opts.vcxproj000066400000000000000000000263441304134206100263120ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release_Static
      Win32
    
    
      Release_Static
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    
    
    
    
    
    
    
    
  
  
    
    
    
    
    
  
  
    {488B1DCF-D41E-4416-A6D0-336CBC2871FE}
    Win32Proj
    libprogram_opts
  
  
  
    StaticLibrary
    true
    Unicode
    v120
  
  
    StaticLibrary
    true
    Unicode
    v120
  
  
    StaticLibrary
    false
    true
    Unicode
    v120
  
  
    StaticLibrary
    false
    true
    Unicode
    Static
    v120
  
  
    StaticLibrary
    false
    true
    Unicode
    v120
  
  
    StaticLibrary
    false
    true
    Unicode
    Static
    v120
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
  
    
      
      
      Level4
      Disabled
      WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
    
  
  
    
      
      
      Level4
      Disabled
      WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\libprogram_opts
    
    
      Windows
      true
      true
      true
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/clasp/lpconvert/000077500000000000000000000000001304134206100202725ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/lpconvert/lpconvert.vcxproj000066400000000000000000000126121304134206100237250ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Release_Static
      Win32
    
    
      Release
      Win32
    
  
  
    {F3035A68-E2CD-4005-A928-FB2E74849682}
    Win32Proj
    lpconvert
  
  
  
    Application
    true
    v120
    Unicode
  
  
    Application
    false
    v120
    true
    Unicode
  
  
    v120
    Static
  
  
  
  
  
    
  
  
    
  
  
  
    true
  
  
    false
  
  
    
      
      
      Level4
      Disabled
      WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\liblp;..\..\..\..\libprogram_opts;
    
    
      Console
      true
      
    
  
  
    
      Level4
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\liblp;..\..\..\..\libprogram_opts;
    
    
      Console
      true
      true
      true
    
  
  
    
      ..\..\..\..\liblp;..\..\..\..\libprogram_opts;
    
  
  
    
      Level4
    
  
  
    
  
  
    
      {e189ec30-18d8-44d6-825e-4be171ba6f55}
    
    
      {488b1dcf-d41e-4416-a6d0-336cbc2871fe}
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/clasp/test/000077500000000000000000000000001304134206100172355ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/test/test.vcproj000066400000000000000000000130501304134206100214400ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
		
	
	
	

clasp-3.2.2/build_vc/vc12/clasp/test/test.vcxproj000066400000000000000000000311701304134206100216330ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    {73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}
    test
    Win32Proj
    test_clasp
  
  
  
    Application
    Unicode
    true
    v120
  
  
    Application
    Unicode
    true
    v120
  
  
    Application
    Unicode
    v120
  
  
    Application
    Unicode
    v120
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    <_ProjectFileVersion>10.0.40219.1
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    true
    true
    $(SolutionDir)$(Configuration)\
    $(SolutionDir)$(Configuration)\
    $(Configuration)\
    $(Configuration)\
    false
    false
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
    AllRules.ruleset
    AllRules.ruleset
    
    
    
    
  
  
    $(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);F:\lib\cppunit-1.12.1\lib;F:\lib\tbb\tbb42_20140416oss\lib\intel64\vc12;
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      true
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      EditAndContinue
    
    
      cppunitd.lib;%(AdditionalDependencies)
      true
      Console
      MachineX86
      
    
  
  
    
      Disabled
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;_DEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      EnableFastChecks
      MultiThreadedDebugDLL
      
      
      Level3
      ProgramDatabase
    
    
      cppunitd.lib;%(AdditionalDependencies)
      true
      Console
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
      MachineX86
    
  
  
    
      MaxSpeed
      true
      ..\..\..\..\libclasp;..\..\..\..\liblp;%(AdditionalIncludeDirectories)
      WIN32;NDEBUG;_CONSOLE;WITH_THREADS=1;%(PreprocessorDefinitions)
      MultiThreadedDLL
      true
      
      
      Level3
      ProgramDatabase
    
    
      true
      Console
      true
      true
    
  
  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  
  
    
  
  
    
      {e189ec30-18d8-44d6-825e-4be171ba6f55}
    
    
      {488b1dcf-d41e-4416-a6d0-336cbc2871fe}
    
    
      {a95999d0-c3a7-423f-84d1-d620674a136e}
      false
    
  
  
  
  
clasp-3.2.2/build_vc/vc12/clasp/test_lp/000077500000000000000000000000001304134206100177305ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc12/clasp/test_lp/test_lp.vcxproj000066400000000000000000000174701304134206100230300ustar00rootroot00000000000000

  
    
      Debug
      Win32
    
    
      Debug
      x64
    
    
      Release
      Win32
    
    
      Release
      x64
    
  
  
    {F6C0AF0E-8F6A-46F3-8E84-C707C885C9D7}
    Win32Proj
    test_lp
  
  
  
    Application
    true
    v120
    Unicode
  
  
    Application
    true
    v120
    Unicode
  
  
    Application
    false
    v120
    true
    Unicode
  
  
    Application
    false
    v120
    true
    Unicode
  
  
  
  
  
    
  
  
    
  
  
    
  
  
    
  
  
  
    true
  
  
    true
  
  
    false
  
  
    false
  
  
    
      
      
      Level3
      Disabled
      WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\liblp;
    
    
      Console
      true
    
  
  
    
      
      
      Level3
      Disabled
      WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\liblp;
    
    
      Console
      true
    
  
  
    
      Level3
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\liblp;
    
    
      Console
      true
      true
      true
    
  
  
    
      Level3
      
      
      MaxSpeed
      true
      true
      WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)
      ..\..\..\..\liblp;
    
    
      Console
      true
      true
      true
    
  
  
    
    
    
    
  
  
    
  
  
    
      {e189ec30-18d8-44d6-825e-4be171ba6f55}
    
  
  
  
  
clasp-3.2.2/build_vc/vc9/000077500000000000000000000000001304134206100151025ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/000077500000000000000000000000001304134206100162045ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/app/000077500000000000000000000000001304134206100167645ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/app/app.vcproj000066400000000000000000000172141304134206100207760ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
		
		
			
			
		
	
	
	

clasp-3.2.2/build_vc/vc9/clasp/clasp.sln000066400000000000000000000165441304134206100200360ustar00rootroot00000000000000
Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libclasp", "lib\lib.vcproj", "{A95999D0-C3A7-423F-84D1-D620674A136E}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "clasp", "app\app.vcproj", "{EF6CFDA6-F838-40E9-8688-BEE97EE14265}"
	ProjectSection(ProjectDependencies) = postProject
		{083CA33B-20EE-47EE-AA06-DF8721DE1223} = {083CA33B-20EE-47EE-AA06-DF8721DE1223}
		{8DA30455-95F9-4DB3-8877-1E99920AB72A} = {8DA30455-95F9-4DB3-8877-1E99920AB72A}
		{A95999D0-C3A7-423F-84D1-D620674A136E} = {A95999D0-C3A7-423F-84D1-D620674A136E}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_clasp", "test\test.vcproj", "{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}"
	ProjectSection(ProjectDependencies) = postProject
		{083CA33B-20EE-47EE-AA06-DF8721DE1223} = {083CA33B-20EE-47EE-AA06-DF8721DE1223}
		{8DA30455-95F9-4DB3-8877-1E99920AB72A} = {8DA30455-95F9-4DB3-8877-1E99920AB72A}
		{A95999D0-C3A7-423F-84D1-D620674A136E} = {A95999D0-C3A7-423F-84D1-D620674A136E}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "examples", "examples\examples.vcproj", "{3D533F47-3043-4EAC-9669-06F01CDB75E2}"
	ProjectSection(ProjectDependencies) = postProject
		{083CA33B-20EE-47EE-AA06-DF8721DE1223} = {083CA33B-20EE-47EE-AA06-DF8721DE1223}
		{A95999D0-C3A7-423F-84D1-D620674A136E} = {A95999D0-C3A7-423F-84D1-D620674A136E}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libprogram_opts", "libprogram_opts\libprogram_opts.vcproj", "{8DA30455-95F9-4DB3-8877-1E99920AB72A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "liblp", "liblp\liblp.vcproj", "{083CA33B-20EE-47EE-AA06-DF8721DE1223}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lpconvert", "lpconvert\lpconvert.vcproj", "{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}"
	ProjectSection(ProjectDependencies) = postProject
		{083CA33B-20EE-47EE-AA06-DF8721DE1223} = {083CA33B-20EE-47EE-AA06-DF8721DE1223}
		{8DA30455-95F9-4DB3-8877-1E99920AB72A} = {8DA30455-95F9-4DB3-8877-1E99920AB72A}
	EndProjectSection
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Win32 = Debug|Win32
		Release_MT_Static|Win32 = Release_MT_Static|Win32
		Release_Static|Win32 = Release_Static|Win32
		Release|Win32 = Release|Win32
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|Win32.ActiveCfg = Debug|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Debug|Win32.Build.0 = Debug|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|Win32.ActiveCfg = Release_MT_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_MT_Static|Win32.Build.0 = Release_MT_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|Win32.ActiveCfg = Release|Win32
		{A95999D0-C3A7-423F-84D1-D620674A136E}.Release|Win32.Build.0 = Release|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|Win32.ActiveCfg = Debug|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Debug|Win32.Build.0 = Debug|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|Win32.ActiveCfg = Release_MT_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_MT_Static|Win32.Build.0 = Release_MT_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|Win32.ActiveCfg = Release|Win32
		{EF6CFDA6-F838-40E9-8688-BEE97EE14265}.Release|Win32.Build.0 = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|Win32.ActiveCfg = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Debug|Win32.Build.0 = Debug|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|Win32.ActiveCfg = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_MT_Static|Win32.Build.0 = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|Win32.ActiveCfg = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release_Static|Win32.Build.0 = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|Win32.ActiveCfg = Release|Win32
		{73ACA93A-C49E-4537-BC3A-DCF91E85ED2A}.Release|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|Win32.ActiveCfg = Debug|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Debug|Win32.Build.0 = Debug|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_MT_Static|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release_Static|Win32.Build.0 = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|Win32.ActiveCfg = Release|Win32
		{3D533F47-3043-4EAC-9669-06F01CDB75E2}.Release|Win32.Build.0 = Release|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Debug|Win32.ActiveCfg = Debug|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Debug|Win32.Build.0 = Debug|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Release|Win32.ActiveCfg = Release|Win32
		{8DA30455-95F9-4DB3-8877-1E99920AB72A}.Release|Win32.Build.0 = Release|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Debug|Win32.ActiveCfg = Debug|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Debug|Win32.Build.0 = Debug|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Release|Win32.ActiveCfg = Release|Win32
		{083CA33B-20EE-47EE-AA06-DF8721DE1223}.Release|Win32.Build.0 = Release|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Debug|Win32.ActiveCfg = Debug|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Debug|Win32.Build.0 = Debug|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Release_MT_Static|Win32.ActiveCfg = Release_Static|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Release_MT_Static|Win32.Build.0 = Release_Static|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Release_Static|Win32.Build.0 = Release_Static|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Release|Win32.ActiveCfg = Release|Win32
		{1BB3E2F7-C2D9-454D-BDF5-5F1688A72A1C}.Release|Win32.Build.0 = Release|Win32
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal
clasp-3.2.2/build_vc/vc9/clasp/clasp.vcproj000066400000000000000000000070241304134206100205360ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
		
		
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc9/clasp/examples/000077500000000000000000000000001304134206100200225ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/examples/examples.vcproj000066400000000000000000000107711304134206100230730ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
		
		
			
			
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc9/clasp/lib/000077500000000000000000000000001304134206100167525ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/lib/lib.vcproj000066400000000000000000000312101304134206100207420ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				
				
				
				
				
				
				
				
				
				
				
				
				
				
			
			
				
				
				
				
				
				
				
				
			
		
	
	
	

clasp-3.2.2/build_vc/vc9/clasp/liblp/000077500000000000000000000000001304134206100173065ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/liblp/liblp.vcproj000066400000000000000000000143351304134206100216430ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc9/clasp/libprogram_opts/000077500000000000000000000000001304134206100214075ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/libprogram_opts/libprogram_opts.vcproj000066400000000000000000000136411304134206100260440ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	

clasp-3.2.2/build_vc/vc9/clasp/lpconvert/000077500000000000000000000000001304134206100202205ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/lpconvert/lpconvert.vcproj000066400000000000000000000131501304134206100234610ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
		
		
		
		
		
	
	
	

clasp-3.2.2/build_vc/vc9/clasp/test/000077500000000000000000000000001304134206100171635ustar00rootroot00000000000000clasp-3.2.2/build_vc/vc9/clasp/test/test.vcproj000066400000000000000000000133611304134206100213730ustar00rootroot00000000000000

	
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
		
			
			
			
			
		
	
	
	

clasp-3.2.2/configure.bat000066400000000000000000000163271304134206100152740ustar00rootroot00000000000000@ECHO OFF
SETLOCAL EnableDelayedExpansion
REM  OPTIONS
set static=0
set machine=0
set mt=0
set PREFIX=%HOMEDRIVE%%HOMEPATH%
set BIN_DIR=
set CONFIG=
REM CONFIGURATION
set CXXFLAGS=%CXXFLAGS%
set LIBS=libclasp liblp libprogram_opts
set LDFLAGS=%LDFLAGS%
set LDLIBS=
set BUILDPATH=build\release
set INSTALLPATH=%PREFIX%\bin
SET INCLUDES=
SET LIB_TARGETS=
set CXX=
set POST_BUILD=
SET TBB_LIB=
SET TBB_INCLUDE=

REM Scan arguments.
:ARG_LOOP
IF [%1]==[] (
	GOTO DONE
) ELSE IF [%1]==[/?] ( goto o_help
) ELSE IF [%1]==[--help] (
:o_help
	ECHO.
	ECHO.  %0 [ options ]
	ECHO.
	ECHO.Options:
	ECHO. ?,--help       : print this page
	ECHO. --prefix=PATH  : set install prefix to PATH
	ECHO. --bindir=PATH  : set install path to PATH
	ECHO.
	ECHO. --config=NAME  : set configuration to NAME
	ECHO.    NAME=release: configure for optimized release version 
	ECHO.    NAME=debug  : configure for debug version
	ECHO.    NAME=check  : configure for release version with assertions enabled
	ECHO.    ELSE        : configure for custom configuration
	ECHO.
	ECHO  --with-mt      : enable multi-thread support ^(see below^)
	ECHO  --static       : link statically ^(if supported^)
	ECHO. --m32          : force 32-bit binary ^(if supported^)
	ECHO. --m64          : force 64-bit binary ^(if supported^)
	ECHO. --strip        : discard symbols ^(calls strip after build^)
	ECHO. --clean        : remove all generated files
	ECHO.
	ECHO. Note: Multi-thread support requires Intel Threading Building Blocks 3.x.
	ECHO.       Use option --with-mt and either set TBB30_INSTALL_DIR environment 
	ECHO.       variable or explicitly set include and/or library path via:
	ECHO.   %0 --with-mt TBB_INCLUDE=^ TBB_LIB=^
	ECHO.
	ECHO. Note: To create a custom configuration call %0 like this:
	ECHO.   %0 --config=my_c CXX=my_gcc CXXFLAGS=my_cxxf LDFLAGS=my_ldf
	ECHO.
	GOTO EXIT
) ELSE IF [%1]==[CXX] (
	SET CXX=%2
	SHIFT
) ELSE IF [%1]==[CXXFLAGS]  (
	SET CXXFLAGS=%2
	SHIFT
) ELSE IF [%1]==[LDFLAGS]  (
	SET LDFLAGS=%2
	SHIFT
) ELSE IF [%1]==[TBB_INCLUDE]  (
	SET TBB_INCLUDE=%2
	SHIFT
) ELSE IF [%1]==[TBB_LIB]  (
	SET TBB_LIB=%2
	SHIFT
) ELSE IF [%1]==[--prefix] (
	SET PREFIX=%2
	SHIFT
) ELSE IF [%1]==[--bindir] (
	SET BIN_DIR=%2
	SHIFT
) ELSE IF [%1]==[--config] (
	if not [%CONFIG%]==[] ( 
		ECHO *** Error: multiple values for option '--config'
		goto EXIT
	)
	set CONFIG=%2
	SHIFT
) ELSE IF [%1]==[--static] (
	SET static=1
) ELSE IF [%1]==[--with-mt] (
	SET mt=1
) ELSE IF [%1]==[--m32] (
	SET machine=32
) ELSE IF [%1]==[--m64] (
	SET machine=64
) ELSE IF [%1]==[--strip] (
	SET POST_BUILD=strip
) ELSE IF [%1]==[--clean] (
	IF NOT EXIST build goto EXIT
	RD /S /Q build
	goto EXIT
) ELSE (
	ECHO *** Error: Unknown parameter '%1'.
	ECHO Type '%0 /?' for an overview of supported options.
	GOTO EXIT
)
SHIFT
GOTO ARG_LOOP
:DONE
if [%CONFIG%]==[] (
	set CONFIG=release
)
if [%CONFIG%]==[release] (
	SET CXXFLAGS=-O3 -DNDEBUG
) ELSE IF [%CONFIG%]==[debug] (
	SET CXXFLAGS=-g -D_DEBUG -DDEBUG -O1
) ELSE IF [%CONFIG%]==[check] (
	SET CXXFLAGS=-O2 -DDEBUG
)
IF ["%CXXFLAGS%"]==[""] (
	SET CXXFLAGS=-O3 -DNDEBUG
)
SET BUILDPATH=build\%CONFIG%

IF %mt%==0 (
	SET CXXFLAGS=%CXXFLAGS% -DWITH_THREADS=0
) ELSE (
	if [%TBB_INCLUDE%]==[] (
		set TBB_INCLUDE=%TBB30_INSTALL_DIR%/include
	)
	if [%TBB_LIB%]==[] (
		set TBB_LIB=%TBB30_INSTALL_DIR%/lib
	)
	IF NOT EXIST "%TBB_INCLUDE%/tbb/tbb.h" (
		ECHO *** Error: TBB include path not set!
		ECHO Use 'configure TBB_INCLUDE=^/include'
		GOTO EXIT
	)
	IF NOT EXIST "%TBB_LIB%/tbb.lib" (
		ECHO *** Error: TBB library path not set or '%TBB_LIB%/tbb.lib' not found!
		ECHO Use 'configure TBB_LIB=^'
		GOTO EXIT
	)
	SET CXXFLAGS=%CXXFLAGS% -DWITH_THREADS=1 -I"%TBB_INCLUDE%"
	SET LDFLAGS=%LDFLAGS% -L"%TBB_LIB%" -Xlinker -rpath -Xlinker "%TBB_LIB%"
	SET LDLIBS=-ltbb 
	SET BUILDPATH=%BUILDPATH%_mt
)
SET CXXFLAGS=%CXXFLAGS%
IF %static%==1 (
	SET LDFLAGS=%LDFLAGS% -static
	SET BUILDPATH=%BUILDPATH%_static
)
IF NOT %machine%==0 (
	SET LDFLAGS=%LDFLAGS% -m%machine%
	SET CXXFLAGS=%CXXFLAGS% -m%machine%
	SET BUILDPATH=%BUILDPATH%_m%machine%
)
IF [%BIN_DIR%]==[] (
    SET INSTALLPATH=%PREFIX%\bin
) ELSE (
    SET INSTALLPATH=%BIN_DIR%
)

REM create & prepare build hierarchy
IF NOT EXIST "%BUILDPATH%" goto CREATEDIR
RD /S /Q "%BUILDPATH%"
:CREATEDIR
MKDIR "%BUILDPATH%\app"
MKDIR "%BUILDPATH%\bin"
cd "%BUILDPATH%"

SET ROOTPATH=../..
SET TARGET=bin/clasp.exe
SET INCLUDES=
SET LIB_TARGETS=
SET TOOL_PATH=..\..\tools
SET LIB_MAKES=%TOOL_PATH%\Base.in %TOOL_PATH%\LibRule.in %TOOL_PATH%\BaseRule.in
SET PRO_MAKES=%TOOL_PATH%\Base.in %TOOL_PATH%\ProjRule.in %TOOL_PATH%\BaseRule.in %TOOL_PATH%\clasp-test.in
SET LIBS=liblp libprogram_opts libclasp
rem set up libs
FOR %%A IN (%LIBS%) DO (
	set x=%%A
	MKDIR "%%A\lib"
 	SET INCLUDES=-I$^(PROJECT_ROOT^)/%%A !INCLUDES!
 	SET LIB_TARGETS=%%A/lib/%%A.a !LIB_TARGETS!
 	type %LIB_MAKES% > %%A\Makefile 2>nul
 	echo PROJECT_ROOT := %ROOTPATH%/..#      >> %%A\.CONFIG
 	echo TARGET       := lib/%%A.a#          >> %%A\.CONFIG
 	echo LDLIBS       := %LDLIBS%#           >> %%A\.CONFIG
	echo FLAGS        := ../FLAGS#           >> %%A\.CONFIG
	echo INCLUDES     := !INCLUDES!#         >> %%A\.CONFIG
	echo SOURCE_DIR   := $^(PROJECT_ROOT^)/%%A/src#    >> %%A\.CONFIG
	echo INCLUDE_DIR  := $^(PROJECT_ROOT^)/%%A/!x:~3!# >> %%A\.CONFIG
	echo.# >> %%A\.CONFIG
)
REM write FLAGS
if ["%CXX%"]==[""] (
	echo CXX         ?= g++#         >> FLAGS
) ELSE (
	echo CXX         := %CXX%#       >> FLAGS
)
echo CXXFLAGS    := %CXXFLAGS%# >> FLAGS
echo WARNFLAGS   := -W -Wall#   >> FLAGS
echo LDFLAGS     := %LDFLAGS%#  >> FLAGS
echo.#>> FLAGS

REM set up project
type %PRO_MAKES% > Makefile 2>nul 
REM write project config
echo PROJECT_ROOT := %ROOTPATH%#           >> .CONFIG
echo TARGET       := %TARGET%#             >> .CONFIG
echo FLAGS        := FLAGS#                >> .CONFIG
echo SOURCE_DIR   := $(PROJECT_ROOT)/app#  >> .CONFIG
echo INCLUDE_DIR  := $(PROJECT_ROOT)/app#  >> .CONFIG
echo OUT_DIR      := app#                  >> .CONFIG
echo INCLUDES     := %INCLUDES%#           >> .CONFIG
echo SUBDIRS      := %LIBS%#               >> .CONFIG
echo LIBS         := %LIB_TARGETS%#        >> .CONFIG
echo LDLIBS       := %LDLIBS%#            >> .CONFIG
echo INSTALL_DIR  := "%INSTALLPATH%"#     >> .CONFIG
echo INSTALL      := copy#                >> .CONFIG
if not [%POST_BUILD%]==[] (
	ECHO POST_BUILD   := %POST_BUILD%#   >> .CONFIG
)
echo.#>>.CONFIG


REM DONE

ECHO.
ECHO Configuration successfully written to %BUILDPATH%.
ECHO Make flags written to "%BUILDPATH%\FLAGS".
ECHO.
ECHO To compile clasp type:
ECHO   cd "%BUILDPATH%"
ECHO   make
ECHO.
ECHO To install clasp afterwards type:
ECHO   make install
ECHO or copy "%BUILDPATH%\%TARGET%" to a directory of your choice.
IF EXIST "%INSTALLPATH%" goto skip_warn
ECHO.
ECHO Note: Path "%INSTALLPATH%" does not exist!
ECHO       Installation will fail unless it is first created!
:skip_warn
ECHO.
ECHO Note: 'make' must correspond to GNU Make 3.8 or later.
ECHO.

:EXIT
(set static=)
(set machine=)
(set mt=)
(set PREFIX=)
(set BIN_DIR=)
(set CONFIG=)
(set LDFLAGS=)
(set LDLIBS=)
(set BUILDPATH=)
(set CXXFLAGS=)
(set INSTALLPATH=)
(set CXX=)
(set TARGET=)
(set POST_BUILD=)
(set LIB_MAKES=)
(set PRO_MAKES=)
(set TOOL_PATH=)
(set TBB_LIB=)
(set TBB_INCLUDE=)
(set LIBS=)
(set INCLUDES=)
(set LIB_TARGETS=)clasp-3.2.2/configure.sh000077500000000000000000000211431304134206100151330ustar00rootroot00000000000000#!/bin/bash

# OPTIONS
static=0
machine=0
mt=""
rpath=0
PREFIX="/usr/local"
BIN_DIR=""
CONFIG=""
# CONFIGURATION
CXXFLAGS="${CXXFLAGS}"
LDFLAGS="${LDFLAGS}"
LDLIBS=""
BUILDPATH=""
INSTALLPATH=""
CXX=""
POST_BUILD=""
TBB_INCLUDE=""
TBB_LIB=""
LIB_INCLUDES=""
while [[ $# > 0 ]]; do
	case $1 in
		CXXFLAGS=*) CXXFLAGS=`echo "$1"| sed  's/^[A-Z]*=*//'`
			;;
		LDFLAGS=*) LDFLAGS=`echo "$1"| sed  's/^[A-Z]*=*//'`
			;;
		CXX=*) CXX=`echo "$1"| sed  's/^[A-Z]*=*//'`
			;;
		TBB_INCLUDE=*) TBB_INCLUDE=`echo "$1"| sed  's/^[A-Z_]*=*//'`
			;;
		TBB_LIB=*) TBB_LIB=`echo "$1"| sed  's/^[A-Z_]*=*//'`
			;;
		"--strip")
			POST_BUILD="strip"
			;;
		"--static")
			static=1
			;;
		"--set-rpath")
			rpath=1
			;;
		"--m32")
			machine=32
			;;
		"--m64")
			machine=64
			;;
		--bindir*|--prefix*|--config*|--with-mt*)
			T=`echo "$1"| sed 's/^--[a-z-]*=*//'`
			A=$1
			if [ -z "$T" ]; then
				if [ -z "$2" ]; then
					echo "error: required parameter missing after '$1'"
					exit 1
				fi
				T=$2
				shift
			fi
			case $A in
				--bindir*) BIN_DIR=$T;;
				--prefix*) PREFIX=$T;;
				--config*) CONFIG=$T;;
				--with-mt*) mt=$T;;
			esac
			;;
		"--clean")
			rm -rf build/
			exit 0
			;;
		"--help")
			echo
			echo "$0 [options]"
			echo
			echo "  --help             : show this help"
			echo "  --prefix=PREFIX    : set install prefix to PREFIX"
			echo "    Default: '/usr/local'"
			echo "  --bindir=PATH      : set install path to PATH"
			echo "    Default: '${PREFIX}/bin'"
			echo
			echo "  --config=NAME      : set configuration to NAME"
			echo "    NAME=release     : configure for optimized release version"
			echo "    NAME=debug       : configure for debug version"
			echo "    NAME=check       : configure for release version with assertions enabled"
			echo "               : configure for custom configuration with name "
			echo
			echo "  --with-mt=std|tbb  : enable multi-thread support (see below)"
			echo "    std              : use C++11 threads (requires C++11 compiler)"
			echo "    tbb              : use Intel® Threading Building Blocks library"
			echo
			echo "  --set-rpath        : store path to shared libraries in binary header"
			echo "  --static           : link statically (if supported)"
			echo "  --m32              : force 32-bit binary (if supported)"
			echo "  --m64              : force 64-bit binary (if supported)"
			echo "  --strip            : discard symbols (calls strip after build)"
			echo "  --clean            : remove all generated files"
			echo
			echo "Note: Multi-thread support requires either a C++11 conforming compiler or"
			echo "      the Intel® Threading Building Blocks >= 3.x. library."
			echo
			echo "Note: To create a custom configuration call $0 like this: "
			echo "  $0 --config=my_config CXX=my_gcc CXXFLAGS=my_cxxflags LDFLAGS=my_ldflags"
			echo
			exit 0
			;;
		*)
			echo "*** Error: unknown option $1"
			echo "type '$0 --help' for an overview of supported options"
			exit 1
	esac
	shift
done
if [ -z "$CONFIG" ]; then
	CONFIG="release"
fi
case $CONFIG in
	release) CXXFLAGS="-O3 -DNDEBUG" ;;
	debug)   CXXFLAGS="-g -D_DEBUG -DDEBUG -O0" ;;
	check)   CXXFLAGS="-O2 -DDEBUG" ;;
	*)
		if [ -z "$CXXFLAGS" ]; then
			CXXFLAGS="-O3 -DNDEBUG"
		fi
		;;
esac

BUILDPATH="build/${CONFIG}"

if   [ "$mt" == "std" ]; then
	LDLIBS="-lpthread"
	if [[ $static == 1 ]]; then
		LDFLAGS="${LDFLAGS} -Wl,-u,pthread_cancel,-u,pthread_cond_broadcast,-u,pthread_cond_destroy,-u,pthread_cond_signal,-u,pthread_cond_timedwait,-u,pthread_cond_wait,-u,pthread_create,-u,pthread_detach,-u,pthread_join"
	fi
	CXXFLAGS="${CXXFLAGS} -std=c++11 -DCLASP_USE_STD_THREAD"
elif [ "$mt" == "tbb" ]; then
	# try to find tbb library
	echo -ne "Checking for Intel® Threading Building Blocks (TBB)..."
	for i in "$TBB_INCLUDE" "$TBB30_INSTALL_DIR/include" "/opt/intel/tbb/include" "/usr/local/include" "/usr/include" "/opt/local/include"; do
		TBB_INCLUDE=""
		if [ -f "$i/tbb/tbb.h" ]; then
			TBB_INCLUDE="$i"
			echo "$TBB_INCLUDE"
			break
		fi
	done
	if [ -z "$TBB_INCLUDE" ]; then
		echo "FAIL"
		echo "*** Error: TBB include path not set!"
		echo "use '$0 TBB_INCLUDE='"
		exit 1
	fi
	for i in "$TBB_LIB" "$TBB30_INSTALL_DIR/lib" "/opt/intel/tbb/lib" "/usr/local/lib" "/usr/lib" "/opt/local/lib" ; do
		TBB_LIB=""
		if [ -f "$i/libtbb.so" -o -f "$i/libtbb.dylib" ]; then
			TBB_LIB="$i"
			echo "$TBB_LIB"
			break
		fi
	done
	if [ -z "$TBB_LIB" ]; then
		echo "FAIL"
		echo "*** Error: TBB library path not set or 'libtbb.{so,dylib}' not found!"
		echo "use '$0 TBB_LIB='"
		exit 1
	fi
	LIB_INCLUDES="${LIB_INCLUDES} -I\"${TBB_INCLUDE}\""
	LDFLAGS="${LDFLAGS} -L\"${TBB_LIB}\""	
	LDLIBS="-ltbb"
	if [[ $rpath == 1 ]]; then
		LDFLAGS="${LDFLAGS} -Xlinker -rpath -Xlinker \"${TBB_LIB}\""
	fi
elif [ ! -z "$mt" ]; then
	echo "*** Error: unrecognized value for option '--with-mt'"
	echo "Only 'std' or 'tbb' supported"
	exit 1
fi
if [ -z "$mt" ]; then
	CXXFLAGS="${CXXFLAGS} -DWITH_THREADS=0"
else
	CXXFLAGS="${CXXFLAGS} -DWITH_THREADS=1"
	BUILDPATH="${BUILDPATH}_mt"
fi
CXXFLAGS="${CXXFLAGS}"
if [[ $static == 1 ]]; then
	LDFLAGS="${LDFLAGS} -static"
	BUILDPATH="${BUILDPATH}_static"
fi
if [[ $machine != 0 ]]; then
	LDFLAGS="${LDFLAGS} -m${machine}"
	CXXFLAGS="${CXXFLAGS} -m${machine}"
	BUILDPATH="${BUILDPATH}_m${machine}"
fi
if [ -z "$BIN_DIR" ]; then
	INSTALLPATH="${PREFIX}/bin"
else
	INSTALLPATH=$BIN_DIR
fi

# create & prepare build hierarchy
ROOTPATH="../.."
LIBS="liblp libprogram_opts libclasp"
LIB_INC=("potassco" "program_opts" "clasp")
TEST_FLAGS=("-std=c++11" "" "")
LIB_TARGETS=""
LIB_MAKES="${ROOTPATH}/tools/Base.in ${ROOTPATH}/tools/LibRule.in ${ROOTPATH}/tools/BaseRule.in"
PRO_MAKES="${ROOTPATH}/tools/Base.in ${ROOTPATH}/tools/ProjRule.in ${ROOTPATH}/tools/BaseRule.in"

mkdir -p "$BUILDPATH"
cd "$BUILDPATH"
mkdir -p "app"
mkdir -p "bin"
# set up libs
n=0
for lib in $LIBS; do 
	LIB_TARGETS="${lib}/lib/${lib}.a ${LIB_TARGETS}"
	LIB_INCLUDES="-I\$(PROJECT_ROOT)/${lib} ${LIB_INCLUDES}"
	mkdir -p "$lib/lib" 
	rm -f $lib/.CONFIG $lib/Makefile	
	cat $LIB_MAKES >> $lib/Makefile
	# set up config	
	touch "$lib/.CONFIG"
	echo "PROJECT_ROOT := ${ROOTPATH}/.."      >> $lib/.CONFIG
	echo "TARGET       := lib/${lib}.a"        >> $lib/.CONFIG
	echo "FLAGS        := ../FLAGS"            >> $lib/.CONFIG
	echo "LDLIBS       := ${LDLIBS}"           >> $lib/.CONFIG
	echo "SOURCE_DIR   := \$(PROJECT_ROOT)/${lib}/src" >> $lib/.CONFIG
	echo "INCLUDE_DIR  := \$(PROJECT_ROOT)/${lib}/${LIB_INC[$n]}" >> $lib/.CONFIG
	echo "INCLUDES     := ${LIB_INCLUDES}"     >> $lib/.CONFIG
	if [ -d "$ROOTPATH/${lib}/tests" ]; then
		echo "TEST_DIR     := \$(PROJECT_ROOT)/${lib}/tests" >> $lib/.CONFIG
		echo "TEST_TARGET  := lib/${lib}_test.a" >> $lib/.CONFIG
		echo "TEST_CXXFLAGS:= ${TEST_FLAGS[$n]}" >> $lib/.CONFIG
	fi
	echo "" >> $lib/.CONFIG
	n=$(( $n + 1));
done
# set up project
rm -f .CONFIG Makefile FLAGS
cat $PRO_MAKES >> Makefile
cat ${ROOTPATH}/tools/clasp-test.in >> Makefile

WARNFLAGS="-W -Wall"
if [[ "$OSTYPE" == "darwin"* ]]; then
	WARNFLAGS="${WARNFLAGS} -Wno-unused-local-typedefs"
fi
# write FLAGS
touch FLAGS
if [ ! -z "$CXX" ]; then
echo "CXX         := ${CXX}"      >> FLAGS
else
echo "CXX         ?= g++"         >> FLAGS
fi
echo "CXXFLAGS    := ${CXXFLAGS}" >> FLAGS
echo "WARNFLAGS   := ${WARNFLAGS}">> FLAGS
echo "LDFLAGS     := ${LDFLAGS}"  >> FLAGS
echo ""                           >> FLAGS
# write project config
touch  .CONFIG
echo "PROJECT_ROOT := $ROOTPATH"            >> .CONFIG
echo "TARGET       := bin/clasp"            >> .CONFIG
echo "FLAGS        := FLAGS"                >> .CONFIG
echo "SOURCE_DIR   := \$(PROJECT_ROOT)/app" >> .CONFIG
echo "INCLUDE_DIR  := \$(PROJECT_ROOT)/app" >> .CONFIG
echo "OUT_DIR      := app"                  >> .CONFIG
echo "INCLUDES     := ${LIB_INCLUDES}"      >> .CONFIG
echo "SUBDIRS      := ${LIBS}"              >> .CONFIG
echo "LIBS         := ${LIB_TARGETS}"       >> .CONFIG
echo "LDLIBS       := ${LDLIBS}"            >> .CONFIG
echo "INSTALL_DIR  := \"${INSTALLPATH}\""   >> .CONFIG
if [ ! -z "$POST_BUILD" ]; then
echo "POST_BUILD  := $POST_BUILD"           >> .CONFIG
fi
echo ""                                     >> .CONFIG

# DONE
echo
echo "Configuration successfully written to ${BUILDPATH}."
echo "Make flags written to ${BUILDPATH}/FLAGS."
echo
echo "To compile clasp type:"
echo "  cd ${BUILDPATH}"
echo "  make"
echo
echo "To install clasp afterwards type:"
echo "  make install"
echo "or copy '${BUILDPATH}/clasp' to a directory of your choice."
if [ ! -d "$INSTALLPATH" ]; then
echo
echo "Note: install path '$INSTALLPATH' does not exist"
echo "      'make install' will fail unless it is first created!"
fi
echo
echo "Note: \"make\" must correspond to GNU Make 3.8 or later."
echo

clasp-3.2.2/libclasp/000077500000000000000000000000001304134206100144035ustar00rootroot00000000000000clasp-3.2.2/libclasp/CMakeLists.txt000066400000000000000000000014541304134206100171470ustar00rootroot00000000000000cmake_minimum_required(VERSION 2.8)
file(GLOB LIBCLASP_SRC src/*.cpp)
if (NOT CLASP_INCLUDE_DIRS)
	set(CLASP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../liblp" "${CMAKE_CURRENT_SOURCE_DIR}/../libprogram_opts")
endif()
if (NOT CLASP_COMPILE_DEFS)
	set (CLASP_COMPILE_DEFS "-DWITH_THREADS=0")
endif()
include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CLASP_INCLUDE_DIRS})
add_definitions(${CLASP_COMPILE_DEFS})

SET(LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/lib)
add_library(clasp STATIC ${LIBCLASP_SRC})

# Doc target
find_package(Doxygen)
if(DOXYGEN_FOUND)
	set(doxyfile ${CMAKE_CURRENT_SOURCE_DIR}/doc/api/clasp)
	add_custom_target(doc
		COMMAND ${DOXYGEN_EXECUTABLE} ${doxyfile}
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/api 
		COMMENT "Generating clasp documentation..."
		VERBATIM)
endif()

clasp-3.2.2/libclasp/Makefile000066400000000000000000000022401304134206100160410ustar00rootroot00000000000000SHELL        ?= /bin/sh
AR           ?= ar
CXX          ?= g++
ROOT_DIR     ?= .
TARGET_DIR   ?= $(ROOT_DIR)/lib
BUILD_DIR    ?= $(ROOT_DIR)/lib
CXXFLAGS     ?= -O3 -DNDEBUG
FLAGS        ?=
ifneq ($(FLAGS),)
-include $(FLAGS)
endif
INCLUDE      := -I $(ROOT_DIR) 
ALL_CXXFLAGS := -W -Wall $(INCLUDE) $(CXXFLAGS) 
TARGET       := $(TARGET_DIR)/libclasp.a
SOURCES      := $(patsubst $(ROOT_DIR)/src/%.cpp,%.cpp,$(wildcard $(ROOT_DIR)/src/*.cpp))
DEPS         := $(patsubst %.cpp,$(BUILD_DIR)/%.dep, $(SOURCES))
OBJECTS      := $(patsubst %.cpp,$(BUILD_DIR)/%.o, $(SOURCES))
vpath %.cpp $(ROOT_DIR)/src
vpath %.h   $(ROOT_DIR)/clasp

$(TARGET):	$(FLAGS) $(DEPS) $(OBJECTS)
	$(AR)  cvrs $(TARGET) $(OBJECTS)


ifneq ($(MAKECMDGOALS),clean)
-include $(DEPS)
endif

$(BUILD_DIR)/%.dep: %.cpp $(FLAGS)
	$(CXX) $(ALL_CXXFLAGS) -MT $(BUILD_DIR)/$*.o -MM $< > $@

$(BUILD_DIR)/%.o: %.cpp $(FLAGS)
	$(CXX) $(ALL_CXXFLAGS) -c $< -o $@


.PHONY:	clean 
ifeq ($(findstring Windows,$(OS)),)
clean:
	@$(RM) $(TARGET)
	@$(RM) $(OBJECTS)
	@$(RM) $(DEPS)
else
RM := del /F /Q
clean:
	@$(RM) $(subst /,\,$(TARGET))  2>nul
	@$(RM) $(subst /,\,$(OBJECTS)) 2>nul
	@$(RM) $(subst /,\,$(DEPS))    2>nul
endif
clasp-3.2.2/libclasp/clasp/000077500000000000000000000000001304134206100155055ustar00rootroot00000000000000clasp-3.2.2/libclasp/clasp/asp_preprocessor.h000066400000000000000000000112061304134206100212470ustar00rootroot00000000000000//
// Copyright (c) 2006-2010, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_PREPROCESSOR_H_INCLUDED
#define CLASP_PREPROCESSOR_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
namespace Clasp { namespace Asp {

/**
 * \addtogroup asp
 */
//@{

//! Preprocesses (i.e. simplifies) a logic program.
/*!
 * Preprocesses (i.e. simplifies) a logic program and associates variables with
 * the nodes of the simplified logic program.
 */
class Preprocessor {
public:
	Preprocessor() : prg_(0), dfs_(true) {}
	//! Possible eq-preprocessing types.
	enum EqType {
		no_eq,    //!< No eq-preprocessing, associate a new var with each supported atom and body.
		full_eq   //!< Check for all kinds of equivalences between atoms and bodies.
	};

	const LogicProgram* program() const  { return prg_; }
	      LogicProgram* program()        { return prg_; }

	//! Starts preprocessing of the logic program.
	/*!
	 * Computes the maximum consequences of prg and associates a variable
	 * with each supported atom and body.
	 * \param prg The logic program to preprocess.
	 * \param t   Type of eq-preprocessing.
	 * \param maxIters If t == full_eq, maximal number of iterations during eq preprocessing.
	 * \param dfs If t == full_eq, classify in df-order (true) or bf-order (false).
	 */
	bool preprocess(LogicProgram& prg, EqType t, uint32 maxIters, bool dfs = true) {
		prg_  = &prg;
		dfs_  = dfs;
		type_ = t;
		return t == full_eq
			? preprocessEq(maxIters)
			: preprocessSimple();
	}

	bool eq() const { return type_ == full_eq; }
	Var  getRootAtom(Literal p) const { return p.id() < litToNode_.size() ? litToNode_[p.id()] : varMax; }
	void setRootAtom(Literal p, uint32 atomId) {
		if (p.id() >= litToNode_.size()) litToNode_.resize(p.id()+1, varMax);
		litToNode_[p.id()] = atomId;
	}
private:
	Preprocessor(const Preprocessor&);
	Preprocessor& operator=(const Preprocessor&);
	bool    preprocessEq(uint32 maxIters);
	bool    preprocessSimple();
	// ------------------------------------------------------------------------
	typedef PrgHead* const *             HeadIter;
	typedef std::pair HeadRange;
	// Eq-Preprocessing
	struct BodyExtra {
		BodyExtra() : known(0), mBody(0), bSeen(0) {}
		uint32 known  :30;  // Number of predecessors already classified, only used for bodies
		uint32 mBody  : 1;  // A flag for marking bodies
		uint32 bSeen  : 1;  // First time we see this body?
	};
	bool     classifyProgram(const VarVec& supportedBodies);
	ValueRep simplifyClassifiedProgram(const HeadRange& atoms, bool more, VarVec& supported);
	PrgBody* addBodyVar(uint32 bodyId);
	bool     addHeadsToUpper(PrgBody* body);
	bool     addHeadToUpper(PrgHead* head, PrgEdge support);
	bool     propagateAtomVar(PrgAtom*, PrgEdge source);
	bool     propagateAtomValue(PrgAtom*, ValueRep val, PrgEdge source);
	bool     mergeEqBodies(PrgBody* b, Var rootId, bool equalLits);
	bool     hasRootLiteral(PrgBody* b) const;
	bool     superfluous(PrgBody* b) const;
	ValueRep simplifyHead(PrgHead* h, bool reclassify);
	ValueRep simplifyBody(PrgBody* b, bool reclassify, VarVec& supported);
	uint32   nextBodyId(VarVec::size_type& idx) {
		if (follow_.empty() || idx == follow_.size()) { return varMax; }
		if (dfs_) {
			uint32 id = follow_.back();
			follow_.pop_back();
			return id;
		}
		return follow_[idx++];;
	}
	// ------------------------------------------------------------------------
	typedef PodVector::type BodyData;
	LogicProgram* prg_;      // program to preprocess
	VarVec        follow_;   // bodies yet to classify
	BodyData      bodyInfo_; // information about the program nodes
	VarVec        litToNode_;// the roots of our equivalence classes
	uint32        pass_;     // current iteration number
	uint32        maxPass_;  // force stop after maxPass_ iterations
	EqType        type_;     // type of eq-preprocessing
	bool          dfs_;      // classify bodies in DF or BF order
};
//@}
} }
#endif

clasp-3.2.2/libclasp/clasp/cb_enumerator.h000066400000000000000000000037071304134206100205120ustar00rootroot00000000000000//
// Copyright (c) 2006-2011, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CB_ENUMERATOR_H
#define CLASP_CB_ENUMERATOR_H

#ifdef _MSC_VER
#pragma once
#endif

#include 

namespace Clasp {

//! Enumerator for computing the brave/cautious consequences of a logic program.
/*!
 * \ingroup enumerator
 */
class CBConsequences : public Enumerator {
public:
	enum Type {
		Brave    = Model::Brave,
		Cautious = Model::Cautious,
	};
	enum Algo { Default, Query };
	/*!
	 * \param type Type of consequences to compute.
	 * \param a Type of algorithm to apply if type is Cautious.
	 */
	explicit CBConsequences(Type type, Algo a = Default);
	~CBConsequences();
	int  modelType() const { return type_; }
	bool exhaustive()const { return true; }
	bool supportsSplitting(const SharedContext& problem) const;
	int  unsatType() const;
private:
	class  CBFinder;
	class  QueryFinder;
	class  SharedConstraint;
	ConPtr doInit(SharedContext& ctx, SharedMinimizeData* m, int numModels);
	void   addLit(SharedContext& ctx, Literal p);
	void   addCurrent(Solver& s, LitVec& con, ValueVec& m, uint32 rootL = 0);
	LitVec            cons_;
	SharedConstraint* shared_;
	Type              type_;
	Algo              algo_;
};

}
#endif
clasp-3.2.2/libclasp/clasp/clasp_facade.h000066400000000000000000000450421304134206100202500ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLASP_FACADE_H_INCLUDED
#define CLASP_CLASP_FACADE_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#if !defined(CLASP_VERSION)
#define CLASP_VERSION "3.2.2"
#endif
#if !defined(CLASP_LEGAL)
#define CLASP_LEGAL \
"Copyright (C) Benjamin Kaufmann\n"\
"License GPLv2+: GNU GPL version 2 or later \n"\
"clasp is free software: you are free to change and redistribute it.\n"\
"There is NO WARRANTY, to the extent permitted by law."
#endif

#include 
#include 
#include 
#include 
#include 

#if WITH_THREADS
#include 
namespace Clasp {
	//! Options for controlling enumeration and solving.
	struct SolveOptions : Clasp::mt::ParallelSolveOptions, EnumOptions {};
}
#else
#include 
#include 
namespace Clasp {
	struct SolveOptions : Clasp::BasicSolveOptions, EnumOptions {};
}
#endif

/*!
 * \file
 * \brief High-level API
 *
 * This file provides a facade around the clasp library.
 * I.e. a simplified interface for (multishot) solving a problem using
 * some configuration (set of parameters).
 * \ingroup facade
 */
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// Configuration
/////////////////////////////////////////////////////////////////////////////////////////
/*!
 * \defgroup facade Facade
 * \brief Simplified interface for (multishot) solving.
 *
 * @{
 */
//! Configuration object for configuring solving via the ClaspFacade.
class ClaspConfig : public BasicSatConfig {
public:
	//! Interface for injecting user-provided post propagators.
	class Configurator {
	public:
		virtual ~Configurator();
		virtual void prepare(SharedContext&);
		virtual bool addPost(Solver& s) = 0;
	};
	typedef BasicSatConfig UserConfig;
	typedef Solver**       SolverIt;
	typedef Asp::LogicProgram::AspOptions AspOptions;
	ClaspConfig();
	~ClaspConfig();
	// Base interface
	void           prepare(SharedContext&);
	void           reset();
	Configuration* config(const char*);
	//! Adds an unfounded set checker to the given solver if necessary.
	/*!
	 * If asp.suppMod is false and the problem in s is a non-tight asp-problem,
	 * the function adds an unfounded set checker to s.
	 */
	bool           addPost(Solver& s) const;
	// own interface
	UserConfig*    testerConfig() const { return tester_; }
	UserConfig*    addTesterConfig();
	//! Registers c as additional callback for when addPost() is called.
	/*!
	 * \param c         Additional configuration to apply.
	 * \param ownership If Ownership_t::Acquire, ownership of c is transferred to the configuration object.
	 * \param once      Whether c should be called once in the first step or also in each subsequent step.
	 */
	void           addConfigurator(Configurator* c, Ownership_t::Type ownership = Ownership_t::Retain, bool once = true);
	SolveOptions   solve; /*!< Options for solve algorithm and enumerator. */
	AspOptions     asp;   /*!< Options for asp preprocessing.      */
	ParserOptions  parse; /*!< Options for input parser. */
private:
	struct Impl;
	ClaspConfig(const ClaspConfig&);
	ClaspConfig& operator=(const ClaspConfig&);
	UserConfig* tester_;
	Impl*       impl_;
};
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspFacade
/////////////////////////////////////////////////////////////////////////////////////////
//! Result of a solving step.
struct SolveResult {
	//! Possible solving results.
	enum Base {
		UNKNOWN  = 0, //!< Satisfiability unknown - a given solve limit was hit.
		SAT      = 1, //!< Problem is satisfiable (a model was found).
		UNSAT    = 2, //!< Problem is unsatisfiable.
	};
	//! Additional flags applicable to a solve result.
	enum Ext {
		EXT_EXHAUST  = 4, //!< Search space is exhausted.
		EXT_INTERRUPT= 8, //!< The run was interrupted from outside.
	};
	bool sat()        const { return *this == SAT; }
	bool unsat()      const { return *this == UNSAT; }
	bool unknown()    const { return *this == UNKNOWN; }
	bool exhausted()  const { return (flags & EXT_EXHAUST)   != 0; }
	bool interrupted()const { return (flags & EXT_INTERRUPT) != 0; }
	operator Base()   const { return static_cast(flags & 3u);}
	operator double() const { return (double(signal)*256.0) + flags; }
	uint8 flags;  //!< Set of Base and Ext flags.
	uint8 signal; //!< Term signal or 0.
};

//! Provides a simplified interface to the services of the clasp library.
class ClaspFacade : public ModelHandler {
	struct SolveData;
	struct SolveStrategy;
public:
	typedef SolveResult Result;
	typedef Potassco::AbstractStatistics AbstractStatistics;
	//! Type summarizing one or more solving steps.
	struct Summary {
		typedef const ClaspFacade* FacadePtr;
		void init(ClaspFacade& f);
		//! Logic program elements added in the current step or 0 if not an asp problem.
		const Asp::LpStats*  lpStep()       const;
		//! Logic program stats or 0 if not an asp problem.
		const Asp::LpStats*  lpStats()      const;
		//! Active problem.
		const SharedContext& ctx()          const { return facade->ctx; }
		/*!
		 * \name Result functions
		 * Solve and enumeration result - not accumulated.
		 * @{
		 */
		bool                 sat()          const { return result.sat(); }
		bool                 unsat()        const { return result.unsat(); }
		bool                 complete()     const { return result.exhausted(); }
		bool                 optimum()      const { return costs() && (complete() || model()->opt); }
		const Model*         model()        const;
		const char*          consequences() const; /**< Cautious/brave reasoning active? */
		bool                 optimize()     const; /**< Optimization active? */
		const SumVec*        costs()        const; /**< Models have associated costs? */
		uint64               optimal()      const; /**< Number of optimal models found. */
		bool                 hasLower()     const;
		SumVec               lower()        const;
		//@}
		//! Visits this summary object.
		void accept(StatsVisitor& out) const;
		FacadePtr facade;    //!< Facade object of this run.
		double    totalTime; //!< Total wall clock time.
		double    cpuTime;   //!< Total cpu time.
		double    solveTime; //!< Wall clock time for solving.
		double    unsatTime; //!< Wall clock time to prove unsat.
		double    satTime;   //!< Wall clock time to first model.
		uint64    numEnum;   //!< Total models enumerated.
		uint64    numOptimal;//!< Optimal models enumerated.
		uint32    step;      //!< Step number (multishot solving).
		Result    result;    //!< Result of step.
	};
	ClaspFacade();
	~ClaspFacade();

	/*!
	 * \name Query functions
	 * Functions for checking the state of this object.
	 * @{ */
	//! Returns whether the problem is still valid.
	bool               ok()                  const { return program() ? program()->ok() : ctx.ok(); }
	//! Returns whether the active step is ready for solving.
	bool               prepared()            const;
	//! Returns whether the active step is currently being solved.
	bool               solving()             const;
	//! Returns whether the active step has been solved, i.e., has a result.
	bool               solved()              const;
	//! Returns whether solving of the active step was interrupted.
	bool               interrupted()         const;
	//! Returns the summary of the active step.
	const Summary&     summary()             const { return step_; }
	//! Returns the summary of the active (accu = false) or all steps.
	const Summary&     summary(bool accu)    const;
	//! Returns solving statistics or throws std::logic_error if step is not yet solved.
	AbstractStatistics*getStats()            const;
	//! Returns the active configuration.
	const ClaspConfig* config()              const { return config_;}
	//! Returns the current solving step (starts at 0).
	int                step()                const { return (int)step_.step;}
	//! Returns the result of the active step (unknown if run is not yet completed).
	Result             result()              const { return step_.result; }
	//! Returns the active program or 0 if it was already released.
	ProgramBuilder*    program()             const { return builder_.get(); }
	//! Returns whether program updates are enabled.
	bool               incremental()         const;
	//! Returns the active enumerator or 0 if there is none.
	Enumerator*        enumerator()          const;
	//@}

	//! Event type used to signal that a new step has started.
	struct StepStart : Event_t {
		explicit StepStart(const ClaspFacade& f) : Event_t(subsystem_facade, verbosity_quiet), facade(&f) {}
		const ClaspFacade* facade;
	};
	//! Event type used to signal that a solve step has terminated.
	struct StepReady : Event_t {
		explicit StepReady(const Summary& x) : Event_t(subsystem_facade, verbosity_quiet), summary(&x) {}
		const Summary* summary;
	};

	SharedContext ctx; //!< Context-object used to store problem.

	/*!
	 * \name Start functions
	 * Functions for defining a problem.
	 * Calling one of the start functions discards any previous problem
	 * and emits a StepStart event.
	 * @{ */
	//! Starts definition of an ASP-problem.
	Asp::LogicProgram& startAsp(ClaspConfig& config, bool enableProgramUpdates = false);
	//! Starts definition of a SAT-problem.
	SatBuilder&        startSat(ClaspConfig& config);
	//! Starts definition of a PB-problem.
	PBBuilder&         startPB(ClaspConfig& config);
	//! Starts definition of a problem of type t.
	ProgramBuilder&    start(ClaspConfig& config, ProblemType t);
	//! Starts definition of a problem given in stream.
	ProgramBuilder&    start(ClaspConfig& config, std::istream& stream);
	//! Enables support for program updates if supported by the program.
	/*!
	 * \pre program() != 0 and not prepared().
	 * \return true if program updates are supported. Otherwise, false.
	 */
	bool               enableProgramUpdates();
	//! Enables support for (asynchronous) solve interrupts.
	void               enableSolveInterrupts();
	//! Tries to detect the problem type from the given input stream.
	static ProblemType detectProblemType(std::istream& str);
	//! Tries to read the next program part from the stream passed to start().
	/*!
	 * \return false if nothing was read because the stream is exhausted, solving was interrupted,
	 * or the problem is unconditionally unsat.
	 */
	bool               read();
	//@}


	/*!
	* \name Solve functions
	* Functions for solving a problem.
	* @{ */

	enum EnumMode { enum_volatile, enum_static };
	//! Finishes the definition of a problem and prepares it for solving.
	/*!
	 * \pre !solving()
	 * \post prepared() || !ok()
	 * \param m Mode to be used for handling enumeration-related knowledge.
	 *          If m is enum_volatile, enumeration knowledge is learnt under an
	 *          assumption that is retracted on program update. Otherwise,
	 *          no special assumption is used and enumeration-related knowledge
	 *          might become unretractable.
	 * \note If solved() is true, prepare() first starts a new solving step.
	 */
	void               prepare(EnumMode m = enum_volatile);

	//! Solves the current problem.
	/*!
	 * If prepared() is false, the function first calls prepare() to prepare the problem for solving.
	 * \pre !solving()
	 * \post solved()
	 * \param eh An optional event handler that is notified on each model and
	 *           once the solve operation has completed.
	 * \param a A list of unit-assumptions under which solving should operate.
	 */
	Result             solve(EventHandler* eh = 0, const LitVec& a = LitVec());

	//! A generator for querying models one-by-one.
	class ModelGenerator {
	public:
		explicit ModelGenerator(SolveStrategy& impl);
		ModelGenerator(const ModelGenerator&);
		~ModelGenerator();
		//! Searches for the next model and returns whether one was found.
		bool         next()   const;
		//! Returns the last model found.
		const Model& model()  const;
		//! Stops the generator so that further calls to next() will return false.
		void         stop()   const;
		//! Returns the result of the last call to next().
		Result       result() const;
	private:
		ModelGenerator& operator=(const ModelGenerator&);
		SolveStrategy* impl_;
	};

	//! Starts solving of the current problem signaling models via the returned generator object.
	/*!
	* Instead of signaling results via a callback, the returned generator object
	* can be used to query models one by one.
	* \pre !solving()
	* \note It is the caller's responsibility to finish the solve operation,
	* either by extracting models until ModelGenerator::next() returns false, or
	* by calling ModelGenerator::stop().
	*/
	ModelGenerator     startSolve(const LitVec& a = LitVec());

#if WITH_THREADS
	class  AsyncResult;
	struct AsyncSolve;
	//! Asynchronously solves the current problem.
	/*!
	 * \see solve(EventHandler* eh, const LitVec&);
	 * \note The optional event handler is notified in the context of the
	 *       asynchronous operation.
	 */
	AsyncResult        solveAsync(EventHandler* eh = 0, const LitVec& a = LitVec());

	//! Asynchronously solves the current problem signaling models one by one.
	/*!
	 * The function behaves similar to solveAsync() but allows to get models
	 * one by one via the returned result object.
	 * \pre !solving()
	 *
	 * To iterate over models use a loop like:
	 * \code
	 * for (AsyncResult it = facade.startSolveAsync(); !it.end(); it.next()) {
	 *   printModel(it.model());
	 * }
	 * \endcode
	 *
	 * \note It is the caller's responsibility to finish the solve operation,
	 * either by extracting models until AsyncResult::end() returns true, or
	 * by calling AsyncResult::cancel().
	 */
	AsyncResult        startSolveAsync(const LitVec& a = LitVec());

	//! A type for accessing the result(s) of an asynchronous solve operation.
	class AsyncResult {
	public:
		typedef  StepReady Ready;
		typedef const Model& ModelRef;
		explicit AsyncResult(SolveData& x);
		~AsyncResult();
		AsyncResult(const AsyncResult&);
		AsyncResult& operator=(AsyncResult temp)            { swap(*this, temp); return *this; }
		friend void swap(AsyncResult& lhs, AsyncResult& rhs){ std::swap(lhs.state_, rhs.state_); }
		/*!
		 * \name Blocking operations
		 */
		//@{
		//! Waits until a result is ready and returns it.
		Result   get()              const;
		//! Waits until a result is ready.
		void     wait()             const;
		//! Waits for a result but for at most sec seconds.
		bool     waitFor(double sec)const;
		//! Tries to cancel the active async operation.
		bool     cancel()           const;
		//! Waits for a result and returns whether the operation is exhausted.
		bool     end()              const;
		//@}

		/*!
		* \name Non-blocking operations
		*/
		//@{
		//! Tests whether a result is ready.
		bool     ready()            const;
		//! Returns the active result in r if it is ready.
		bool     ready(Result& r)   const;
		//! Tests whether the asynchronous operation was interrupted and if so returns the interruption signal.
		int      interrupted()      const;
		//! Tests whether a result is ready and has a stored exception.
		bool     error()            const;
		//! Tests whether the asynchronous operation is still active.
		bool     running()          const;
		//! Returns the current model provided that end() is false.
		ModelRef model()            const;
		//! Kicks off search for the next result if not end().
		bool     next()             const;
	private:
		AsyncSolve* state_;
	};
#endif
	//! Tries to interrupt the active solve operation.
	/*!
	 * The function sends the given signal to the active solve operation.
	 * If no solve operation is active (i.e. solving() is false), the signal
	 * is queued and applied to the next solve operation.
	 *
	 * \param sig The signal to raise or 0, to re-raises a previously queued signal.
	 * \return false if no operation was interrupted, because
	 *         there is no active solve operation,
	 *         or the operation does not support interrupts,
	 *         or sig was 0 and there was no queued signal.
	 *
	 * \see enableSolveInterrupts()
	 */
	bool               interrupt(int sig);

	//! Forces termination of the current solving step.
	/*!
	 * \post solved()
	 * \return summary(true)
	 */
	const Summary&     shutdown();

	//! Starts update of the active problem.
	/*!
	 * \pre solving() is false and program updates are enabled (incremental() is true).
	 * \post !solved()
	 * \param updateConfig If true, the function applies any configuration changes.
	 * \param sigQ An action to be performed for any queued signal.
	 *        The default is to apply the signal to the next solve operation, while
	 *        SIGN_IGN can be used to discard queued signals.
	 */
	ProgramBuilder&    update(bool updateConfig, void (*sigQ)(int));
	ProgramBuilder&    update(bool updateConfig = false);
	//@}
private:
	struct Statistics;
	typedef SingleOwnerPtr BuilderPtr;
	typedef SingleOwnerPtr      SolvePtr;
	typedef SingleOwnerPtr        SummaryPtr;
	typedef SingleOwnerPtr     StatsPtr;
	void   init(ClaspConfig& cfg, bool discardProblem);
	void   initBuilder(ProgramBuilder* in);
	bool   isAsp() const { return program() && type_ == Problem_t::Asp; }
	void   discardProblem();
	void   startStep(uint32 num);
	Result stopStep(int signal, bool complete);
	void   updateStats();
	bool   onModel(const Solver& s, const Model& m);
	void   doUpdate(ProgramBuilder* p, bool updateConfig, void (*sig)(int));
	ProblemType  type_;
	Summary      step_;
	LitVec       assume_;
	ClaspConfig* config_;
	BuilderPtr   builder_;
	SummaryPtr   accu_;
	StatsPtr     stats_; // statistics: only if requested
	SolvePtr     solve_; // NOTE: last so that it is destroyed first;
};

/**
 * \example example2.cpp
 * This is an example of how to use the ClaspFacade class for basic solving.
 *
 * \example example3.cpp
 * This is an example of how to use the ClaspFacade class for async solving.
 */

//!@}

}
#endif
clasp-3.2.2/libclasp/clasp/claspfwd.h000066400000000000000000000036701304134206100174670ustar00rootroot00000000000000//
// Copyright (c) 2013-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLASP_FWD_H_INCLUDED
#define CLASP_CLASP_FWD_H_INCLUDED
/*!
 * \file
 * \brief Forward declarations of important clasp and potassco types.
 */

namespace Potassco {
class TheoryAtom;
class TheoryTerm;
class TheoryData;
template  struct Span;
struct Heuristic_t;
class BufferedStream;
class AbstractStatistics;
}
//! Root namespace for all types and functions of libclasp.
namespace Clasp {
class SharedContext;
class MinimizeBuilder;
class SharedMinimizeData;
class Configuration;
class Constraint;
class ConstraintInfo;
class Solver;
struct Model;
//! Supported problem types.
struct Problem_t {
	enum Type {Sat = 0, Pb = 1, Asp = 2};
};
typedef Problem_t::Type ProblemType;
class ProgramBuilder;
class ProgramParser;
class SatBuilder;
class PBBuilder;
class ExtDepGraph;
class ConstString;
typedef Potassco::Span StrView;
typedef Potassco::Heuristic_t DomModType;
//! Namespace for types and functions used to define ASP programs.
namespace Asp {
class LogicProgram;
class Preprocessor;
class LpStats;
class PrgAtom;
class PrgBody;
class PrgDisj;
class PrgHead;
class PrgNode;
class PrgDepGraph;
struct PrgEdge;
}}

#endif
clasp-3.2.2/libclasp/clasp/clause.h000066400000000000000000000542021304134206100171350ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLAUSE_H_INCLUDED
#define CLASP_CLAUSE_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
namespace Clasp {

//! An array of literals that can be shared between threads.
/*!
 * \ingroup shared_con
 */
class SharedLiterals {
public:
	//! Creates a shareable (ref-counted) object containing the literals in lits.
	/*!
	 * \note The reference count is set to numRefs.
	 */
	static SharedLiterals* newShareable(const LitVec& lits, ConstraintType t, uint32 numRefs = 1) {
		return newShareable(!lits.empty() ? &lits[0]:0, static_cast(lits.size()), t, numRefs);
	}
	static SharedLiterals* newShareable(const Literal* lits, uint32 size, ConstraintType t, uint32 numRefs = 1);

	//! Returns a pointer to the beginning of the literal array.
	const Literal* begin() const { return lits_; }
	//! Returns a pointer to the end of the literal array.
	const Literal* end()   const { return lits_+size(); }
	//! Returns the number of literals in the array.
	uint32         size()  const { return size_type_ >> 2; }
	//! Returns the type of constraint from which the literals originated.
	ConstraintType type()  const { return ConstraintType( size_type_ & uint32(3) ); }
	//! Simplifies the literals w.r.t to the assignment in s.
	/*!
	 * Returns the number of non-false literals in this object or 0 if
	 * the array contains a true literal.
	 * \note If the object is currently not shared, simplify() removes
	 * all false literals from the array.
	 */
	uint32 simplify(Solver& s);

	void            release() { release(1); }
	void            release(uint32 numRefs);
  SharedLiterals* share();
	bool            unique()   const { return refCount_ <= 1; }
	uint32          refCount() const { return refCount_; }
private:
	void destroy();
	SharedLiterals(const Literal* lits, uint32 size, ConstraintType t, uint32 numRefs);
	SharedLiterals(const SharedLiterals&);
	SharedLiterals& operator=(const SharedLiterals&);
	typedef Clasp::Atomic_t::type RCType;
	RCType  refCount_;
	uint32  size_type_;
CLASP_WARNING_BEGIN_RELAXED
	Literal lits_[0];
CLASP_WARNING_END_RELAXED
};

//! A helper-class for creating/adding clauses.
/*!
 * \ingroup constraint
 * This class simplifies clause creation. It hides the special handling of
 * short, and shared clauses. It also makes sure that learnt clauses watch
 * the literals from the highest decision levels.
 */
class ClauseCreator {
public:
	typedef ConstraintInfo ClauseInfo;
	//! Creates a new ClauseCreator object.
	/*!
	 * \param s the Solver in which to store created clauses.
	 */
	explicit ClauseCreator(Solver* s = 0);
	//! Sets the solver in which created clauses are stored.
	void setSolver(Solver& s)         { solver_ = &s; }
	//! Adds additional flags to be applied in end().
	void addDefaultFlags(uint32 f)    { flags_ |= f; }
	//! Reserve space for a clause of size s.
	void reserve(LitVec::size_type s) { literals_.reserve(s); }
	//! Discards the current clause.
	void clear()                      { literals_.clear(); }

	//! Status of a clause.
	/*!
	 * For a clause with literals [l1,...,ln], status is one of:
	 */
	enum Status {
		// BASE STATUS
		status_open         = 0,  //!< Clause is neither sat, unsat, or unit.
		status_sat          = 1,  //!< At least one literal is true.
		status_unsat        = 2,  //!< All literals are false.
		status_unit         = 4,  //!< All but one literal false.
		// COMPLEX STATUS
		status_sat_asserting= 5,  //!< Sat but literal is implied on lower dl.
		status_asserting    = 6,  //!< Unsat but literal is implied on second highest dl.
		status_subsumed     = 9,  //!< Sat and one literal is true on level 0.
		status_empty        = 10, //!< Unsat and all literals are false on level 0.
	};
	//! A type for storing the result of a clause insertion operation.
	struct Result {
		explicit Result(ClauseHead* loc = 0, Status st = status_open)
			: local(loc)
			, status(st) {}
		ClauseHead*     local;
		Status          status;
		//! Returns false is clause is conflicting w.r.t current assignment.
		bool     ok()   const { return (status & status_unsat) == 0; }
		//! Returns true if the clause implies a literal (possibly after backtracking).
		bool     unit() const { return (status & status_unit) != 0; }
		operator bool() const { return ok(); }
	};
	//! Starts the creation of a new clause.
	/*!
	 * \pre s.decisionLevel() == 0 || t != Constraint_t::Static
	 */
	ClauseCreator& start(ConstraintType t = Constraint_t::Static);
	//! Sets the initial activity of the clause under construction.
	ClauseCreator& setActivity(uint32 a)      { extra_.setActivity(a);  return *this; }
	//! Sets the initial literal block distance of the clause under construction.
	ClauseCreator& setLbd(uint32 lbd)         { extra_.setLbd(lbd); return *this; }
	//! Adds the literal p to the clause under construction.
	ClauseCreator& add(const Literal& p)      { literals_.push_back(p); return *this; }
	//! Removes subsumed lits and orders first lits w.r.t watch order.
	ClauseRep      prepare(bool fullSimplify);
	//! Returns the current size of the clause under construction.
	uint32         size()    const { return (uint32)literals_.size(); }
	//! Returns the literal at the given idx.
	Literal&       operator[](uint32 i)       { return literals_[i]; }
	Literal        operator[](uint32 i) const { return literals_[i]; }
	//! Returns the literals of the clause under construction.
	const LitVec&  lits()    const { return literals_; }
	LitVec&        lits()          { return literals_; }
	//! Returns the clause's type.
	ConstraintType type()    const { return extra_.type(); }
	//! Returns the aux info of the clause under construction.
	ConstraintInfo info()    const { return extra_; }
	//! Creates a new clause object for the clause under construction.
	/*!
	 * \pre The clause does not contain duplicate/complementary literals or
	 *      flags contains clause_force_simplify.
	 *
	 * \note If the clause to be added is empty, end() fails and s.hasConflict() is set to true.
	 * \see Result ClauseCreator::create(Solver& s, LitVec& lits, uint32 flags, const ClauseInfo& info);
	 */
	Result end(uint32 flags = clause_not_sat | clause_not_conflict);

	/*!
	 * \name Factory functions
	 * Functions for creating and integrating clauses.
	 */
	//@{
	//! Flags controlling clause creation and integration.
	enum CreateFlag {
		// REPRESENTATION
		clause_no_add        = 1,  //!< Do not add clause to solver db.
		clause_explicit      = 2,  //!< Force creation of explicit clause even if size <= 3.
		// STATUS
		clause_not_sat       = 4,  //!< Do not add clause if it is satisfied (but not asserting) w.r.t current assignment.
		clause_not_root_sat  = 8,  //!< Do not add clause if it is satisfied w.r.t the root assignment.
		clause_not_conflict  = 16, //!< Do not add clause if it is conflicting w.r.t the current assignment.
		// INTEGRATE
		clause_no_release    = 32, //!< Do not call release on shared literals.
		clause_int_lbd       = 64, //!< Compute lbd when integrating asserting clauses.
		// PREPARE
		clause_no_prepare    = 128,//!< Assume clause is already ordered w.r.t watches.
		clause_force_simplify= 256,//!< Call simplify() on create.
		clause_no_heuristic  = 512,//!< Do not notify heuristic about new clause.
		// WATCH MODE - only for problem clauses
		clause_watch_first   =1024,//!< Watch first free literals.
		clause_watch_rand    =2048,//!< Watch rand literals.
		clause_watch_least   =4096,//!< Watch least watched literals.
	};
	//! Returns the status of the given clause w.r.t s.
	static Status    status(const Solver& s, const Literal* clause_begin, const Literal* clause_end);
	static Status    status(const Solver& s, const ClauseRep& c);

	//! Returns an abstraction of p's decision level that can be used to order literals.
	/*!
	 * The function returns a value, s.th
	 * order(any true literal) > order(any free literal) > order(any false literal).
	 * Furthermore, for equally assigned literals p and q, order(p) > order(q), iff
	 * level(p) > level(q).
	 */
	static uint32    watchOrder(const Solver& s, Literal p);

	//! Prepares the clause given in lits.
	/*!
	 * A prepared clause [l1...ln] with n >= 2 is a clause that,
	 *  - does not contain any duplicate or complementary literals, and
	 *  - does not contain any subsumed literals (i.e. literals assigned on decision level 0), and
	 *  - is partially ordered w.r.t watchOrder(), i.e., watchOrder(l1) >= watchOrder(l2), and there
	 *    is no lj, j > 2, s.th. watchOrder(lj) > watchOrder(l2)
	 *  .
	 *
	 * Removes subsumed literals from lits and reorders lits s.th.
	 * the first literals are valid watches. Furthermore,
	 * if flags contains clause_force_simplify,
	 * duplicate literals are removed from lits and tautologies are
	 * replaced with the single literal True.
	 */
	static ClauseRep prepare(Solver& s, LitVec& lits, uint32 flags, const ClauseInfo& info = ClauseInfo());

	//! Creates a clause from the literals given in lits.
	/*!
	 * \param s     The solver to which the clause should be added.
	 * \param lits  The literals of the clause.
	 * \param flags Flag set controlling creation (see ClauseCreator::CreateFlag).
	 * \param info  Initial information (e.g. type) for the new clause.
	 *
	 * \pre !s.hasConflict() and s.decisionLevel() == 0 or extra.learnt()
	 * \pre lits is fully prepared or flags contains suitable prepare flags.
	 *
	 * \note
	 *   If the given clause is unit (or asserting), the unit-resulting literal is
	 *   asserted on the (numerical) lowest level possible but the new information
	 *   is not immediately propagated, i.e. on return queueSize() may be greater than 0.
	 *
	 * \note
	 *   The local representation of the clause is always attached to the solver
	 *   but only added to the solver if clause_no_add is not contained in flags.
	 *   Otherwise, the returned clause is owned by the caller
	 *   and it is the caller's responsibility to manage it. Furthermore,
	 *   learnt statistics are *not* updated automatically in that case.
	 *
	 * \see prepare()
	 */
	static Result create(Solver& s, LitVec& lits, uint32 flags, const ClauseInfo& info = ClauseInfo());

	/*!
	 * \overload
	 */
	static Result create(Solver& s, const ClauseRep& rep, uint32 flags);

	//! Integrates the given clause into the current search of s.
	/*!
	 * \pre the assignment in s is not conflicting
	 * \param s      The solver in which the clause should be integrated.
	 * \param clause The clause to be integrated.
	 * \param flags  A set of flags controlling integration (see ClauseCreator::CreateFlag).
	 * \param t      Constraint type to use for the local representation.
	 *
	 * \note
	 *   The function behaves similar to ClauseCreator::create() with the exception that
	 *   it does not add local representations for implicit clauses (i.e. size <= 3)
	 *   unless flags contains clause_explicit.
	 *   In that case, an explicit representation is created.
	 *   Implicit representations can only be created via ClauseCreator::create().
	 *
	 * \note
	 *   The function acts as a sink for the given clause (i.e. it decreases its reference count)
	 *   unless flags contains clause_no_release.
	 *
	 * \note integrate() is intended to be called in a post propagator.
	 *   To integrate a set of clauses F, one would use a loop like this:
	 *   \code
	 *   bool MyPostProp::propagate(Solver& s) {
	 *     bool r = true;
	 *     while (!F.empty() && r) {
	 *       SharedLiterals* C = f.pop();
	 *       r = integrate(s, C, ...).ok;
	 *     }
	 *     return r;
	 *   \endcode
	 */
	static Result integrate(Solver& s, SharedLiterals* clause, uint32 flags, ConstraintType t);

	/*!
	 * \overload
	 */
	static Result integrate(Solver& s, SharedLiterals* clause, uint32 flags);
	//@}
private:
	static ClauseRep   prepare(Solver& s, const Literal* in, uint32 inSize, const ClauseInfo& e, uint32 flags, Literal* out, uint32 outMax = UINT32_MAX);
	static Result      create_prepared(Solver& s, const ClauseRep& pc, uint32 flags);
	static ClauseHead* newProblemClause(Solver& s, const ClauseRep& clause, uint32 flags);
	static ClauseHead* newLearntClause(Solver& s, const ClauseRep& clause, uint32 flags);
	static ClauseHead* newUnshared(Solver& s, SharedLiterals* clause, const Literal* w, const ClauseInfo& e);
	static bool        ignoreClause(const Solver& s, const ClauseRep& cl, Status st, uint32 modeFlags);
	Solver*    solver_;   // solver in which new clauses are stored
	LitVec     literals_; // literals of the new clause
	ClauseInfo extra_;    // extra info
	uint32     flags_;    // default flags to be used in end()
};

//! Class for representing a clause in a solver.
/*!
 * \ingroup constraint
 */
class Clause : public ClauseHead {
public:
	typedef Constraint::PropResult PropResult;
	enum { MAX_SHORT_LEN = 5 };

	//! Allocates memory for storing a (learnt) clause with nLits literals.
	static void* alloc(Solver& s, uint32 mLits, bool learnt);

	//! Creates a new clause from the clause given in rep.
	/*!
	 * \param s   Solver in which the new clause is to be used.
	 * \param rep The raw representation of the clause.
	 *
	 * \pre The clause given in lits is prepared and contains at least two literals.
	 * \note The clause must be destroyed using Clause::destroy.
	 * \see ClauseCreator::prepare()
	 */
	static ClauseHead*  newClause(Solver& s, const ClauseRep& rep) {
		return newClause(alloc(s, rep.size, rep.info.learnt()), s, rep);
	}
	//! Creates a new clause object in mem.
	/*!
	 * \pre mem points to a memory block that was allocated via Clause::alloc().
	 */
	static ClauseHead*  newClause(void* mem, Solver& s, const ClauseRep& rep);

	//! Creates a new contracted clause from the clause given in rep.
	/*!
	 * A contracted clause consists of an active head and a tail of false literals.
	 * Propagation is restricted to the head.
	 * The tail is only needed to compute reasons from assignments.
	 *
	 * \param s       Solver in which the new clause is to be used.
	 * \param rep     The raw representation of the clause.
	 * \param tailPos The starting index of the tail (first literal that should be temporarily removed from the clause).
	 * \param extend  Extend head part of clause as tail literals become free?
	 */
	static ClauseHead*  newContractedClause(Solver& s, const ClauseRep& rep, uint32 tailPos, bool extend);

	//! Creates a new local surrogate for shared_lits to be used in the given solver.
	/*!
	 * \param s      The solver in which this clause will be used.
	 * \param lits   The shared literals of this clause.
	 * \param e      Initial meta data for the new (local) clause.
	 * \param head   Watches and cache literal for the new (local) clause.
	 * \param addRef Increment ref count of lits.
	 */
	static ClauseHead* newShared(Solver& s, SharedLiterals* lits, const InfoType& e, const Literal head[3], bool addRef = true);

	// Constraint-Interface

	Constraint* cloneAttach(Solver& other);

	/*!
	 * For a clause [x y p] the reason for p is ~x and ~y.
	 * \pre *this previously asserted p
	 * \note if the clause is a learnt clause, calling reason increases
	 * the clause's activity.
	 */
	void reason(Solver& s, Literal p, LitVec& lits);

	bool minimize(Solver& m, Literal p, CCMinRecursive* r);

	bool isReverseReason(const Solver& s, Literal p, uint32 maxL, uint32 maxN);

	//! Returns true if clause is SAT.
	/*!
	 * Removes from the clause all literals that are false.
	 */
	bool simplify(Solver& s, bool = false);

	//! Destroys the clause and frees its memory.
	void destroy(Solver* s = 0, bool detach = false);

	// LearntConstraint interface

	//! Returns type() if the clause is currently not satisfied and t.inSet(type()).
	uint32 isOpen(const Solver& s, const TypeSet& t, LitVec& freeLits);

	// clause interface
	BoolPair strengthen(Solver& s, Literal p, bool allowToShort);
	void     detach(Solver&);
	uint32   size()                 const;
	void     toLits(LitVec& out)    const;
	bool     contracted()           const;
	bool     isSmall()              const;
	bool     strengthened()         const;
	uint32   computeAllocSize()     const;
private:
	Clause(Solver& s, const ClauseRep& rep, uint32 tail = UINT32_MAX, bool extend = false);
	Clause(Solver& s, const Clause& other);
	typedef std::pair LitRange;
	void     undoLevel(Solver& s);
	bool     updateWatch(Solver& s, uint32 pos);
	Literal* end() { return head_+local_.size(); }
	Literal* removeFromTail(Solver& s, Literal* it, Literal* end);
	Literal* small();
	LitRange tail();
};

//! Constraint for Loop-Formulas.
/*!
 * \ingroup constraint
 * Special purpose constraint for loop formulas of the form: L v B1 v ... v Bm,
 * where L is an unfounded set represented as a set of atom literals {~a1, ..., ~an}.
 * Representing such a loop formula explicitly as n clauses
 *   - (1) ~a1 v B1 v ... v Bm
 *   - ...
 *   - (n) ~an v B1 v ... v Bm
 *   .
 * is wasteful because each clause contains the same set of bodies.
 *
 * The idea behind LoopFormula is to treat L as a "macro-literal"
 * with the following properties:
 * - isTrue(L), iff for all ai isTrue(~ai)
 * - isFalse(L), iff for some ai isFalse(~ai)
 * - L is watchable, iff not isFalse(L)
 * - Watching L means watching all ai.
 * - setting L to true means setting all ai to false.
 * Using this convention the TWL-algo can be implemented as in a clause.
 *
 * \par Implementation:
 * - The literal-array is divided into two parts, an "active clause" part and an atom part.
 * - The "active clause" contains one atom and all bodies: [~ai B1 ... Bj]
 * - The atom part contains all atoms: [~a1 ... ~an]
 * - Two of the literals of the "active clause" are watched (again: watching an atom means watching all atoms)
 * - If a watched atom becomes true, it is copied into the "active clause" and the TWL-algo starts.
 */
class LoopFormula : public Constraint {
public:
	//! Creates a new loop-constraint for the given atoms.
	/*!
	* \param s      Solver in which the new constraint is to be used.
	* \param c1     First clause of the new constraint.
	* \param atoms  Set of atoms in the loop.
	* \param nAtoms Number of atoms in the loop.
	* \param updateHeuristic Whether to notify heuristic about new constraint.
	*
	* \pre The clause given in c1 is prepared and c1.size > 1 and c1.lits[0] is a literal in atoms.
	* \see ClauseCreator::prepare()
	*/
	static LoopFormula* newLoopFormula(Solver& s, const ClauseRep& c1, const Literal* atoms, uint32 nAtoms, bool updateHeuristic = true);

	//! Returns the number of literals in the loop-formula.
	uint32 size() const;

	// Constraint interface
	Constraint* cloneAttach(Solver&) { return 0; }
	PropResult  propagate(Solver& s, Literal p, uint32& data);
	void reason(Solver&, Literal p, LitVec& lits);
	bool minimize(Solver& s, Literal p, CCMinRecursive* ccMin);
	bool simplify(Solver& s, bool = false);
	void destroy(Solver* = 0, bool = false);

	// LearntConstraint interface
	bool locked(const Solver& s) const;

	uint32 isOpen(const Solver& s, const TypeSet& t, LitVec& freeLits);

	//! Returns the loop-formula's activity.
	/*!
	 * The activity of a loop-formula is increased, whenever reason() is called.
	 */
	ScoreType activity() const { return act_; }

	//! Halves the loop-formula's activity.
	void decreaseActivity() { act_.reduce(); }
	void resetActivity()    { act_.reset(); }

	//! Returns Constraint_t::Loop.
	ConstraintType type() const { return Constraint_t::Loop; }
private:
	LoopFormula(Solver& s, const ClauseRep& c1, const Literal* atoms, uint32 nAtoms, bool heu);
	void detach(Solver& s);
	bool otherIsSat(const Solver& s);
	Literal* begin() { return lits_ + 1; }
	Literal* xBegin(){ return lits_ + end_ + 1; }
	Literal* xEnd()  { return lits_ + size_; }
	ScoreType act_;     // activity of constraint
	uint32    end_;     // position of second sentinel
	uint32    size_:30; // size of lits_
	uint32    str_ : 1; // removed literal(s) during simplify?
	uint32    xPos_: 1; // position of ai in lits_ or 0 if no atom
	uint32    other_;   // stores the position of a literal that was recently true
CLASP_WARNING_BEGIN_RELAXED
	Literal   lits_[0]; // S ai B1...Bm S a1...an
CLASP_WARNING_END_RELAXED
};

namespace mt {

//! Stores the local part of a shared clause.
/*!
 * \ingroup constraint
 * The local part of a shared clause consists of a
 * clause head and and a pointer to the shared literals.
 * Since the local part is owned by a particular solver
 * it can be safely modified. Destroying a SharedLitsClause
 * means destroying the local part and decreasing the
 * shared literals' reference count.
 */
class SharedLitsClause : public ClauseHead {
public:
	//! Creates a new SharedLitsClause to be used in the given solver.
	/*!
	 * \param s The solver in which this clause will be used.
	 * \param shared_lits The shared literals of this clause.
	 * \param e Initial meta data for the new (local) clause.
	 * \param lits Watches and cache literal for the new (local) clause.
	 * \param addRef Increment ref count of shared_lits.
	 */
	static ClauseHead* newClause(Solver& s, SharedLiterals* shared_lits, const InfoType& e, const Literal* lits, bool addRef = true);

	Constraint* cloneAttach(Solver& other);
	void        reason(Solver& s, Literal p, LitVec& out);
	bool        minimize(Solver& s, Literal p, CCMinRecursive* rec);
	bool        isReverseReason(const Solver& s, Literal p, uint32 maxL, uint32 maxN);
	bool        simplify(Solver& s, bool);
	void        destroy(Solver* s, bool detach);
	uint32      isOpen(const Solver& s, const TypeSet& t, LitVec& freeLits);
	uint32      size() const;
	void        toLits(LitVec& out) const;
private:
	SharedLitsClause(Solver& s, SharedLiterals* x, const Literal* lits, const InfoType&,  bool addRef);
	bool     updateWatch(Solver& s, uint32 pos);
	BoolPair strengthen(Solver& s, Literal p, bool allowToShort);
};
}

}
#endif
clasp-3.2.2/libclasp/clasp/cli/000077500000000000000000000000001304134206100162545ustar00rootroot00000000000000clasp-3.2.2/libclasp/clasp/cli/clasp_cli_configs.inl000066400000000000000000000136121304134206100224240ustar00rootroot00000000000000//
// Copyright (c) 2013, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
/*!
 * \file
 * \brief Supermacros for defining clasp's default configurations.
 * \code
 * CONFIG(sId, name, "", "", "")
 * \endcode
 *
 * A configuration consists of a solver id and a name followed by three option strings:
 * - ""     : options that are always part of the configuration
 * - "": options to add if configuration is used as a stand-alone configuration (e.g. global options)
 * - ""  : options to add if configuration is used in a portfolio
 * .
 * \note The solver id is used to identify a configuration in the default portfolio.
 */

#if !defined(CONFIG) || (!defined(CLASP_CLI_DEFAULT_CONFIGS) && !defined(CLASP_CLI_AUX_CONFIGS))
#error Invalid include context
#endif

//! Named default configurations accessible via option "--configuration=".
#if defined(CLASP_CLI_DEFAULT_CONFIGS)
CLASP_CLI_DEFAULT_CONFIGS
CONFIG(0, tweety\
       , "--heuristic=Vsids,92 --restarts=L,60 --deletion=basic,50,0 --del-max=2000000 --del-estimate=1 --del-cfl=+,2000,100,20 --del-grow=0 --del-glue=2,0"\
         " --strengthen=recursive,0 --otfs=2 --init-moms --score-other=2 --update-lbd=1 --save-progress=160 --init-watches=2 --local-restarts --loops=shared"\
       , "--eq=3 --trans-ext=dynamic"\
       , "--opt-strat=bb,1")
CONFIG(1, trendy\
       , "--heuristic=Vsids --restarts=D,100,0.7 --deletion=basic,50,0 --del-init=3.0,500,19500 --del-grow=1.1,20.0,x,100,1.5 --del-cfl=+,10000,2000 --del-glue=2"\
         " --strengthen=recursive --update-lbd --otfs=2 --save-p=75 --counter-restarts=3 --counter-bump=1023 --reverse-arcs=2 --contraction=250 --loops=common"\
       , "--sat-p=2,20,25,240 --trans-ext=dynamic"\
       , "--opt-heu=1 --opt-strat=usc,1")
CONFIG(2, frumpy\
       , "--heuristic=Berkmin --restarts=x,100,1.5 --deletion=basic,75 --del-init=3.0,200,40000 --del-max=400000 --contraction=250 --loops=common --save-p=180"\
         " --del-grow=1.1 --strengthen=local --sign-def-disj=1"\
       , "--eq=5"\
       , "--restart-on-model --opt-heu=2")
CONFIG(3, crafty\
       , "--restarts=x,128,1.5 --deletion=basic,75,0 --del-init=10.0,1000,9000 --del-grow=1.1,20.0 --del-cfl=+,10000,1000 --del-glue=2 --otfs=2"\
         " --reverse-arcs=1 --counter-restarts=3 --contraction=250"\
       , "--sat-p=2,10,25,240 --trans-ext=dynamic --backprop --heuristic=Vsids --save-p=180"\
       , "--heuristic=domain --dom-mod=4,8 --opt-strat=bb,1")
CONFIG(4, jumpy\
       , "--heuristic=Vsids --restarts=L,100 --deletion=basic,75,2 --del-init=3.0,1000,20000 --del-grow=1.1,25,x,100,1.5 --del-cfl=x,10000,1.1 --del-glue=2"\
         " --update-lbd=3 --strengthen=recursive --otfs=2 --save-p=70"\
       , "--sat-p=2,20,25,240 --trans-ext=dynamic"\
       , "--restart-on-model --opt-heu=3 --opt-strat=bb,2")
CONFIG(5, handy\
       , "--heuristic=Vsids --restarts=D,100,0.7 --deletion=sort,50,2 --del-max=200000 --del-init=20.0,1000,14000 --del-cfl=+,4000,600 --del-glue=2 --update-lbd"\
         " --strengthen=recursive --otfs=2 --save-p=20 --contraction=600 --loops=distinct --counter-restarts=7 --counter-bump=1023 --reverse-arcs=2"\
       , "--sat-p=2,10,25,240 --trans-ext=dynamic --backprop"\
       , "")
#undef CLASP_CLI_DEFAULT_CONFIGS
#endif
//! Auxiliary configurations accessible via default portfolio ("--configuration=many").
#if defined(CLASP_CLI_AUX_CONFIGS)
CLASP_CLI_AUX_CONFIGS
CONFIG(6,  s6,  "--heuristic=Berkmin,512 --restarts=x,100,1.5 --deletion=basic,75 --del-init=3.0,200,40000 --del-max=400000 --contraction=250 --loops=common --del-grow=1.1,25 --otfs=2 --reverse-arcs=2 --strengthen=recursive --init-w=2 --lookahead=atom,10", "", "")
CONFIG(7,  s7,  "--heuristic=Vsids --reverse-arcs=1 --otfs=1 --local-restarts --save-progress=0 --contraction=250 --counter-restart=7 --counter-bump=200 --restarts=x,100,1.5 --del-init=3.0,800,-1 --deletion=basic,60,0 --strengthen=local --del-grow=1.0,1.0 --del-glue=4 --del-cfl=+,4000,300,100",  "", "")
CONFIG(8,  s8,  "--heuristic=Vsids --restarts=L,256 --counter-restart=3 --strengthen=recursive --update-lbd --del-glue=2 --otfs=2 --deletion=ipSort,75,2 --del-init=20.0,1000,19000", "", "")
CONFIG(9,  s9,  "--heuristic=Berkmin,512 --restarts=F,16000 --lookahead=atom,50",  "", "")
CONFIG(10, s10, "--heuristic=Vmtf --strengthen=no --contr=0 --restarts=x,100,1.3 --del-init=3.0,800,9200",  "", "")
CONFIG(11, s11, "--heuristic=Vsids --strengthen=recursive --restarts=x,100,1.5,15 --contraction=0",  "", "")
CONFIG(12, s12, "--heuristic=Vsids --restarts=L,128 --save-p --otfs=1 --init-w=2 --contr=0 --opt-heu=3",  "", "")
CONFIG(13, s13, "--heuristic=Berkmin,512 --restarts=x,100,1.5,6 --local-restarts --init-w=2 --contr=0",  "", "")
CONFIG(14, nolearn, "--no-lookback --heuristic=Unit --lookahead=atom --deletion=no --restarts=no",  "", "")
CONFIG(15, tester,  "--heuristic=Vsids --restarts=D,100,0.7 --deletion=sort,50,2 --del-max=200000 --del-init=20.0,1000,14000 --del-cfl=+,4000,600 --del-glue=2 --update-lbd"\
                    " --strengthen=recursive --otfs=2 --save-p=20 --contraction=600 --counter-restarts=7 --counter-bump=1023 --reverse-arcs=2"\
                 ,  "--sat-p=2,10,25,240", "")
#undef CLASP_CLI_AUX_CONFIGS
#endif
#undef CONFIG
clasp-3.2.2/libclasp/clasp/cli/clasp_cli_options.inl000066400000000000000000001117151304134206100224720ustar00rootroot00000000000000//
// Copyright (c) 2013-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
/*!
 * \file
 * \brief Supermacros for describing clasp's options.
 * \code
 * OPTION(key, "ext", ARG(...), "help", set, get)
 * \endcode
 * An option consists of:
 *  - a key  (valid and unique c identifier in 'snake_case')
 *  - a key extension ("[!][,][,@]") as understood by ProgramOptions::OptionInitHelper
 *  - an arg description (ARG macro) as understood by ProgramOptions::Value
 *  - a description (string)
 *  - a set action to be executed when a value (string) for the option is found in a source
 *  - a get action to be executed when the current value for an option is requested
 *  .
 *
 * \note In the implementation of ClaspCliConfig, each key is mapped to an enumeration constant and
 * the stringified version of key (i.e. \#key) is used to identify options.
 * Furthermore, the key is also used for generating command-line option names.
 * As a convention, compound keys using 'snake_case' to separate words
 * are mapped to dash-separated command-line option names.
 * E.g. an \ is mapped to the command-line option "option-like-this".
 *
 * \note ClaspCliConfig assumes a certain option order. In particular, context options shall
 * precede all solver/search options, which in turn shall precede global asp/solving options.
 *
 * \note The following set actions may be used:
 *  - STORE(obj): converts the string value to the type of obj and stores the result in obj.
 *  - STORE_LEQ(n, max): converts the string value to an unsinged int and stores the result in n if it is <= max.
 *  - STORE_FLAG(n): converts the string value to a bool and stores the result in n as either 0 or 1.
 *  - STORE_OR_FILL(n): converts the string value to an unsinged int t and sets n to std::min(t, maxValue(n)).
 *  - FUN(arg): anonymous function of type bool (ArgStream& arg), where arg provides the following interface:
 *    - arg.ok()     : returns whether arg is still valid
 *    - arg.empty()  : returns whether arg is empty (i.e. all tokens were extracted)
 *    - arg.off()    : returns whether arg contains a single token representing a valid off value
 *    - arg >> x     : extracts and converts the current token and stores it in x. Sets failbit if conversion fails.
 *    - arg >> opt(x): extracts an optional argument, shorthand for (!arg.empty() ? arg>>obj : arg)
 *    .
 *
 * \note The following get actions may be used:
 *  - GET_FUN(str)  : anonymous function of type void (OutputStream& str)
 *  - GET(obj...)   : shorthand for GET_FUN(str) { (str << obj)...; }
 *  - GET_IF(C, obj): shorthand for GET_FUN(str) { ITE(C, str << obj, str << off); }
 *  .
 *
 * \note The following primitives may be used in the set/get arguments:
 *  - off                  : singleton object representing a valid off value ("no", "off", "false", "0")
 *  - ITE(C, x, y)         : if-then-else expression, i.e. behaves like (C ? x : y).
 *  - SET(x, y)            : shorthand for (x=y) == y.
 *  - SET_LEQ(x, v, m)     : shorthand for (x <= m && SET(x, v)).
 *  - SET_GEQ(x, v, m)     : shorthand for (x >= m && SET(x, v)).
 *  - SET_OR_FILL(x, v)    : behaves like SET(x, min(v, maxValue(x)))
 *  - SET_OR_ZERO(x,v)     : behaves like ITE(v <= maxValue(x), SET(x, v), SET(x, 0)).
 *  .
 */
#if !defined(OPTION) || defined(SELF)
#error Invalid include context
#endif

#if !defined(GROUP_BEGIN)
#define GROUP_BEGIN(X)
#endif

#if !defined(GROUP_END)
#define GROUP_END(X)
#endif

//! Options for configuring a SharedContext object stored in a Clasp::ContextParams object.
#if defined(CLASP_CONTEXT_OPTIONS)
#define SELF CLASP_CONTEXT_OPTIONS
GROUP_BEGIN(SELF)
OPTION(share, "!,@1", ARG_EXT(defaultsTo("auto")->state(Value::value_defaulted), DEFINE_ENUM_MAPPING(ContextParams::ShareMode, \
       MAP("no"  , ContextParams::share_no)  , MAP("all", ContextParams::share_all),\
       MAP("auto", ContextParams::share_auto), MAP("problem", ContextParams::share_problem),\
       MAP("learnt", ContextParams::share_learnt))),\
       "Configure physical sharing of constraints [%D]\n"\
       "      %A: {auto|problem|learnt|all}", FUN(arg) {ContextParams::ShareMode x; return arg>>x && SET(SELF.shareMode, (uint32)x);}, GET((ContextParams::ShareMode)SELF.shareMode))
OPTION(learn_explicit, ",@1" , ARG(flag()), "Do not use Short Implication Graph for learning\n", STORE_FLAG(SELF.shortMode), GET(SELF.shortMode))
OPTION(sat_prepro    , "!,@1", ARG(implicit("2")), "Run SatELite-like preprocessing (Implicit: %I)\n" \
       "      %A: [,...(0=no limit)]\n"                \
       "        : Run {1=VE|2=VE with BCE|3=BCE followed by VE}\n"\
       "          : Set iteration limit to            [0]\n"\
       "          : Set variable occurrence limit to  [0]\n"\
       "          : Set time limit to  seconds        [0]\n"\
       "          : Set frozen variables limit to %%   [0]\n"\
       "          : Set clause limit to *1000      [4000]", FUN(arg) {\
       SatPreParams& pre = SELF.satPre; uint32 x;\
       return ITE(arg.off(), SET(pre.type, 0u), arg>>x && SET_GEQ(pre.type, x, 1u)\
         && arg >> opt(x = 0)    && SET_OR_ZERO(pre.limIters , x)\
         && arg >> opt(x = 0)    && SET_OR_ZERO(pre.limOcc   , x)\
         && arg >> opt(x = 0)    && SET_OR_ZERO(pre.limTime  , x)\
         && arg >> opt(x = 0)    && SET_OR_ZERO(pre.limFrozen, x)\
         && arg >> opt(x = 4000) && SET_OR_ZERO(pre.limClause, x));},\
       GET_FUN(str) { SatPreParams& pre = SELF.satPre;\
         ITE(pre.type, str<arg("[,]")), "Enable {1=basic|2=full} statistics ( for tester)",\
    FUN(arg) { uint32 s = 0; uint32 t = 0;\
      return (arg.off() || (arg >> s && s > 0)) && arg >> opt(t) && arg.empty()
        && SET(SELF.stats, s) && ((!SELF.testerConfig() && t == 0) || SET(SELF.addTesterConfig()->stats, t));
    },\
    GET_FUN(str) { ITE(!SELF.testerConfig() || !SELF.testerConfig()->stats, str << SELF.stats, str << SELF.stats << SELF.testerConfig()->stats); })
OPTION(parse_ext, "!", ARG(flag()), "Enable extensions in non-aspif input",\
    FUN(arg) { bool b = false; return (arg.off() || arg >> b) && SET(SELF.parse.ext, (b ? unsigned(ParserOptions::parse_full):0u)); }, \
    GET((SELF.parse.ext != 0)))
GROUP_END(SELF)
#undef CLASP_GLOBAL_OPTIONS
#undef SELF
#endif

//! Solver options (see SolverParams).
#if defined(CLASP_SOLVER_OPTIONS)
#define SELF CLASP_SOLVER_OPTIONS
GROUP_BEGIN(SELF)
OPTION(opt_strategy , ""  , ARG_EXT(arg("")->implicit("1"), DEFINE_ENUM_MAPPING(MinimizeMode_t::Strategy,\
       MAP("bb", MinimizeMode_t::opt_bb), MAP("usc", MinimizeMode_t::opt_usc))),  "Configure optimization strategy\n" \
       "      %A: {bb|usc}[,]\n" \
       "        bb : model-guided (branch and bound) optimization ()\n"\
       "          0: default algorithm with minimal steps\n"                      \
       "          1: hierarchical algorithm and constant steps\n"                 \
       "          2: hierarchical algorithm and exponentially increasing steps\n" \
       "          3: hierarchical algorithm and exponentially decreasing steps\n" \
       "        usc: unsatisfiable-core guided optimization (bitmask )\n"\
       "          1: enable disjoint-core preprocessing\n"                        \
       "          2: disable redundant (symmetry) constraints\n"                  \
       "          4: enable PMRES instead of OLL algorithm\n"                     \
       "          8: enable stratification heuristic for handling weights"       ,\
       FUN(arg) { MinimizeMode_t::Strategy sc = MinimizeMode_t::opt_bb; uint32 n;\
         return ((SET_LEQ(n, uint32(arg.peek()-'0'), 9u) && arg >> n && (n < 4u || (SET(sc, MinimizeMode_t::opt_usc) && (n -= 4u) < 16u)))\
           || (arg>>sc>>opt(n = 0))) && SET(SELF.optStrat, (uint32)sc) && SET(SELF.optParam, n) && (n < 4u || sc == MinimizeMode_t::opt_usc);},\
       GET(static_cast(SELF.optStrat), SELF.optParam))
OPTION(opt_heuristic, ""  , ARG(implicit("1")->arg("{0..3}")), "Use opt. in {1=sign|2=model|3=both} heuristics", STORE_LEQ(SELF.optHeu,  3u), GET(SELF.optHeu))
OPTION(restart_on_model, "", ARG(flag()), "Restart after each model\n", STORE_FLAG(SELF.restartOnModel), GET(SELF.restartOnModel))
OPTION(lookahead    , "!", ARG_EXT(implicit("atom"), DEFINE_ENUM_MAPPING(VarType, \
       MAP("atom", Var_t::Atom), MAP("body", Var_t::Body), MAP("hybrid", Var_t::Hybrid))),\
       "Configure failed-literal detection (fld)\n" \
       "      %A: [,] / Implicit: %I\n" \
       "         : Run fld via {atom|body|hybrid} lookahead\n" \
       "        : Disable fld after  applications ([0]=no limit)\n" \
       "      --lookahead=atom is default if --no-lookback is used\n", FUN(arg) { \
       VarType type; uint32 limit = (SELF.lookOps = 0u);\
       return ITE(arg.off(), SET(SELF.lookType, 0u), arg>>type>>opt(limit) && SET(SELF.lookType, (uint32)type)) && SET_OR_ZERO(SELF.lookOps, limit);},\
       GET_IF(SELF.lookType, (VarType)SELF.lookType, SELF.lookOps))
OPTION(heuristic, "", ARG_EXT(arg(""), DEFINE_ENUM_MAPPING(Heuristic_t::Type, \
       MAP("berkmin", Heuristic_t::Berkmin), MAP("vmtf"  , Heuristic_t::Vmtf), \
       MAP("vsids"  , Heuristic_t::Vsids)  , MAP("domain", Heuristic_t::Domain), \
       MAP("unit"   , Heuristic_t::Unit)   , MAP("auto", Heuristic_t::Default), MAP("none"  , Heuristic_t::None))), \
       "Configure decision heuristic\n"  \
       "      %A: {Berkmin|Vmtf|Vsids|Domain|Unit|None}[,]\n" \
       "        Berkmin: Use BerkMin-like heuristic (Check last  nogoods [0]=all)\n" \
       "        Vmtf   : Use Siege-like heuristic (Move  literals to the front [8])\n" \
       "        Vsids  : Use Chaff-like heuristic (Use 1.0/0. as decay factor  [95])\n"\
       "        Domain : Use domain knowledge in Vsids-like heuristic\n"\
       "        Unit   : Use Smodels-like heuristic (Default if --no-lookback)\n" \
       "        None   : Select the first free variable", FUN(arg) { Heuristic_t::Type h; uint32 n = 0u; \
       return arg>>h>>opt(n) && SET(SELF.heuId, (uint32)h) && (Heuristic_t::isLookback(h) || !n) && SET_OR_FILL(SELF.heuristic.param, n);},\
       GET((Heuristic_t::Type)SELF.heuId, SELF.heuristic.param))
OPTION(init_moms  , "!,@2", ARG(flag())    , "Initialize heuristic with MOMS-score", STORE_FLAG(SELF.heuristic.moms), GET(SELF.heuristic.moms))
OPTION(score_res  , ",@2" , ARG(arg("")), "Resolution score {0=default|1=min|2=set|3=multiset}", STORE_LEQ(SELF.heuristic.score,3u), GET(SELF.heuristic.score))
OPTION(score_other, ",@2" , ARG(arg("")), "Score {0=no|1=loop|2=all} other learnt nogoods", STORE_LEQ(SELF.heuristic.other,2u), GET(SELF.heuristic.other))
OPTION(sign_def   , ""    , ARG(arg("")), "Default sign: {0=asp|1=pos|2=neg|3=rnd}", STORE_LEQ(SELF.signDef,3u), GET(SELF.signDef))
OPTION(sign_fix   , "!"   , ARG(flag())    , "Disable sign heuristics and use default signs only", STORE_FLAG(SELF.signFix), GET(SELF.signFix))
OPTION(berk_huang , "!,@2", ARG(flag())    , "Enable/Disable Huang-scoring in Berkmin", STORE_FLAG(SELF.heuristic.huang), GET(SELF.heuristic.huang))
OPTION(vsids_acids, "!,@2", ARG(flag())    , "Enable/Disable acids-scheme in Vsids/Domain", STORE_FLAG(SELF.heuristic.acids), GET(SELF.heuristic.acids))
OPTION(vsids_progress, ",@2", NO_ARG, "Enable dynamic decaying scheme in Vsids/Domain\n"\
       "      %A: [,][,]|(0=disable)\n"\
       "         : Set initial decay factor to 1.0/0.\n"\
       "         : Set decay update to /100.0      [1]\n"\
       "         : Decrease decay every  conflicts [5000]", \
       FUN(arg) { uint32 n = 80; uint32 i = 1; uint32 c = 5000; \
       return ITE(arg.off(), SET(SELF.heuristic.decay.init, 0), (arg >> n >> opt(i) >> opt(c))\
         && SET(SELF.heuristic.decay.init, n) && SET_LEQ(SELF.heuristic.decay.bump, i, 100) && SET(SELF.heuristic.decay.freq, c));}, \
       GET_IF(SELF.heuristic.decay.init, SELF.heuristic.decay.init, SELF.heuristic.decay.bump, SELF.heuristic.decay.freq))
OPTION(nant       , "!,@2", ARG(flag())    , "Prefer negative antecedents of P in heuristic", STORE_FLAG(SELF.heuristic.nant), GET(SELF.heuristic.nant))
OPTION(dom_mod    , ",@2" , NO_ARG         , "Default modification for domain heuristic\n"\
       "      %A: [,]\n"\
       "          : Modifier {1=level|2=pos|3=true|4=neg|5=false|6=init|7=factor}\n"\
       "         : Apply  to {0=all|1=scc|2=hcc|4=disj|8=min|16=show} atoms",\
       FUN(arg) { uint32 n; return arg>>n && SET_LEQ(SELF.heuristic.domMod, n, 7u) && arg>>opt(n = 0) && SET(SELF.heuristic.domPref, n);},\
       GET(SELF.heuristic.domMod, SELF.heuristic.domPref))
OPTION(save_progress, "", ARG(implicit("1")->arg("")), "Use RSat-like progress saving on backjumps > %A", STORE_OR_FILL(SELF.saveProgress), GET(SELF.saveProgress))
OPTION(init_watches , ",@2", ARG(arg("{0..2}")->defaultsTo("1")->state(Value::value_defaulted)),\
       "Configure watched literal initialization [%D]\n" \
       "      Watch {0=first|1=random|2=least watched} literals in nogoods", STORE_LEQ(SELF.initWatches, 2u), GET(SELF.initWatches))
OPTION(update_mode   , ",@2", ARG(arg("")), "Process messages on {0=propagation|1=conflict)", STORE_LEQ(SELF.upMode, 1u), GET(SELF.upMode))
OPTION(acyc_prop, ",@2", ARG(implicit("1")->arg("{0..1}")), "Acyc propagate with {0=inc|1=inc+back}", \
       FUN(arg) { uint32 x; return arg>>x && SET_LEQ(SELF.acycFwd, (1u-x), 1u); }, GET(1u-SELF.acycFwd))
OPTION(seed          , ""   , ARG(arg("")),"Set random number generator's seed to %A", STORE(SELF.seed), GET(SELF.seed))
OPTION(no_lookback   , ""   , ARG(flag()), "Disable all lookback strategies\n", STORE_FLAG(SELF.search),GET(static_cast(SELF.search == SolverStrategies::no_learning)))
OPTION(forget_on_step, ""   , ARG(arg("")), "Configure forgetting on (incremental) step\n"\
       "      Forget {1=heuristic,2=signs,4=nogood activities,8=learnt nogoods}\n", STORE_LEQ(SELF.forgetSet, 15u), GET(SELF.forgetSet))
OPTION(strengthen    , "!"  , ARG_EXT(arg(""), DEFINE_ENUM_MAPPING(SolverStrategies::CCMinType, \
       MAP("local", SolverStrategies::cc_local), MAP("recursive", SolverStrategies::cc_recursive))), \
       "Use MiniSAT-like conflict nogood strengthening\n" \
       "      %A: [,][,]\n" \
       "        : Use {local|recursive} self-subsumption check\n" \
       "        : Follow {0=all|1=short|2=binary} antecedents   [0]\n"\
       "        : {0=Increase|1=Keep} activities of antecedents [0]", FUN(arg) {\
       SolverStrategies::CCMinType m = SolverStrategies::cc_local; uint32 t; uint32 k = 0; \
       return ITE(arg.off(), SET(t, 0u), arg>>m>>opt(t = 0u)>>opt(k) && ++t) && SET(SELF.ccMinAntes, t) && SET(SELF.ccMinRec, (uint32)m) && SET(SELF.ccMinKeepAct, k);},\
       GET_IF(SELF.ccMinAntes, (SolverStrategies::CCMinType)SELF.ccMinRec, SELF.ccMinAntes-uint32(1), SELF.ccMinKeepAct))
OPTION(otfs        , ""   , ARG(implicit("1")->arg("{0..2}")), "Enable {1=partial|2=full} on-the-fly subsumption", STORE_LEQ(SELF.otfs, 2u), GET(SELF.otfs))
OPTION(update_lbd  , ",@2", ARG(implicit("1")->arg("{0..3}")), "Update LBDs of learnt nogoods {1=<|2=strict<|3=+1<}", STORE_LEQ(SELF.updateLbd, 3u),GET(SELF.updateLbd))
OPTION(update_act  , ",@2", ARG(flag()), "Enable LBD-based activity bumping", STORE_FLAG(SELF.bumpVarAct), GET(SELF.bumpVarAct))
OPTION(reverse_arcs, ""   , ARG(implicit("1")->arg("{0..3}")), "Enable ManySAT-like inverse-arc learning", STORE_LEQ(SELF.reverseArcs, 3u), GET(SELF.reverseArcs))
OPTION(contraction , "!"  , NO_ARG, "Configure handling of long learnt nogoods\n"
       "      %A: [,]\n"\
       "          : Contract nogoods if size >  (0=disable)\n"\
       "        : Replace literal blocks with {1=decisions|2=uips} ([0]=disable)\n", FUN(arg) { uint32 n = 0; uint32 r = 0;\
       return (arg.off() || (arg>>n>>opt(r) && n != 0u)) && SET_OR_FILL(SELF.compress, n) && SET_LEQ(SELF.ccRepMode, r,3u);},\
       GET_IF(SELF.compress, SELF.compress, SELF.ccRepMode))
OPTION(loops, "" , ARG_EXT(arg(""), DEFINE_ENUM_MAPPING(DefaultUnfoundedCheck::ReasonStrategy,\
       MAP("common"  , DefaultUnfoundedCheck::common_reason)  , MAP("shared", DefaultUnfoundedCheck::shared_reason), \
       MAP("distinct", DefaultUnfoundedCheck::distinct_reason), MAP("no", DefaultUnfoundedCheck::only_reason))),\
       "Configure learning of loop nogoods\n" \
       "      %A: {common|distinct|shared|no}\n" \
       "        common  : Create loop nogoods for atoms in an unfounded set\n" \
       "        distinct: Create distinct loop nogood for each atom in an unfounded set\n" \
       "        shared  : Create loop formula for a whole unfounded set\n" \
       "        no      : Do not learn loop formulas\n", FUN(arg) {DefaultUnfoundedCheck::ReasonStrategy x; return arg>>x && SET(SELF.loopRep, (uint32)x);},\
       GET(static_cast(SELF.loopRep)))
GROUP_END(SELF)
#undef CLASP_SOLVER_OPTIONS
#undef SELF
#endif

//! Search-related options (see SolveParams).
#if defined(CLASP_SEARCH_OPTIONS)
#define SELF CLASP_SEARCH_OPTIONS
GROUP_BEGIN(SELF)
OPTION(partial_check, "", ARG(implicit("50")), "Configure partial stability tests\n" \
       "      %A: 
[,] / Implicit: %I\n" \
       "        
: Partial check skip percentage\n"    \
       "        : Init/update value for high bound ([0]=umax)", FUN(arg) {\
       uint32 p = 0; uint32 h = 0; \
       return (arg.off() || (arg>>p>>opt(h) && p)) && SET_LEQ(SELF.fwdCheck.highPct, p, 100u) && SET_OR_ZERO(SELF.fwdCheck.highStep, h);},\
       GET_IF(SELF.fwdCheck.highPct, SELF.fwdCheck.highPct, SELF.fwdCheck.highStep))
OPTION(sign_def_disj, "", ARG(arg("")), "Default sign for atoms in disjunctions", STORE_LEQ(SELF.fwdCheck.signDef,3u), GET(SELF.fwdCheck.signDef))
OPTION(rand_freq, "!", ARG(arg("
")), "Make random decisions with probability %A", FUN(arg) {\
       double f = 0.0; \
       return (arg.off() || arg>>f) && SET_R(SELF.randProb, (float)f, 0.0f, 1.0f);}, GET(SELF.randProb))
OPTION(rand_prob, "!", ARG(implicit("10,100")), "Configure random probing (Implicit: %I)\n" \
       "      %A: [,]\n" \
       "        Run  random passes with at most  conflicts each", FUN(arg) {\
       uint32 n1 = 0; uint32 n2 = 100;\
       return (arg.off() || (arg>>n1>>opt(n2) && n1)) && SET_OR_FILL(SELF.randRuns, n1) && SET_OR_FILL(SELF.randConf, n2);},\
       GET_IF(SELF.randRuns, SELF.randRuns,SELF.randConf))
#undef SELF
//! Options for configuring the restart strategy of a solver.
#define SELF CLASP_SEARCH_RESTART_OPTIONS
#if defined(NOTIFY_SUBGROUPS)
GROUP_BEGIN(SELF)
#endif
OPTION(restarts, "!,r", ARG(arg("")), "Configure restart policy\n" \
       "      %A: ,[,][,]\n"                    \
       "        F,    : Run fixed sequence of  conflicts\n"                         \
       "        L,    : Run Luby et al.'s sequence with unit length \n"             \
       "        x,,: Run geometric seq. of *(^i) conflicts  ( >= 1.0)\n"   \
       "        +,,: Run arithmetic seq. of +(*i) conflicts ()\n"\
       "        ...,: Repeat seq. every +j restarts           ( != F)\n"  \
       "        D,,: Restart based on moving LBD average over last  conflicts\n" \
       "                   Mavg(,LBD)* > avg(LBD)\n"                                \
       "                   use conflict level average if  > 0 and avg(LBD) > \n"\
       "      no|0       : Disable restarts", FUN(arg) { return ITE(arg.off(), (SELF.disable(),true), \
       arg>>SELF.sched && SET(SELF.dynRestart, uint32(SELF.sched.type == ScheduleStrategy::User)));}, GET(SELF.sched))
OPTION(reset_restarts  , ""   , ARG(arg("0..2")->implicit("1")), "{0=Keep|1=Reset|2=Disable} restart seq. after model", STORE_LEQ(SELF.upRestart, 2u), GET(SELF.upRestart))
OPTION(local_restarts  , ""   , ARG(flag()), "Use Ryvchin et al.'s local restarts", STORE_FLAG(SELF.cntLocal), GET(SELF.cntLocal))
OPTION(counter_restarts, ""   , ARG(arg("")), "Do a counter implication restart every  restarts", STORE_OR_FILL(SELF.counterRestart),GET(SELF.counterRestart))
OPTION(counter_bump    , ",@2", ARG(arg(""))    , "Set CIR bump factor to %A", STORE_OR_FILL(SELF.counterBump), GET(SELF.counterBump))
OPTION(block_restarts  , ""   , ARG(arg("")), "Use glucose-style blocking restarts\n" \
       "      %A: [,][,]\n" \
       "        : Window size for moving average (0=disable blocking)\n" \
       "        : Block restart if assignment > average *   [1.4]\n"             \
       "        : Disable blocking for the first  conflicts [10000]\n", FUN(arg) { \
       uint32 n = 0; double R = 0.0; uint32 x = 0;\
       return (arg.off() || (arg>>n>>opt(R = 1.4)>>opt(x = 10000) && n && R >= 1.0 && R <= 5.0))\
         && SET(SELF.blockWindow, n) && SET(SELF.blockScale, (float)R) && SET_OR_FILL(SELF.blockFirst, x);},\
       GET_IF(SELF.blockWindow, SELF.blockWindow, SELF.blockScale, SELF.blockFirst))
OPTION(shuffle         , "!"  , ARG(arg(",")), "Shuffle problem after +(*i) restarts\n", FUN(arg) { uint32 n1 = 0; uint32 n2 = 0;\
       return (arg.off() || (arg>>n1>>opt(n2) && n1)) && SET_OR_FILL(SELF.shuffle, n1) && SET_OR_FILL(SELF.shuffleNext, n2);},\
       GET_IF(SELF.shuffle, SELF.shuffle, SELF.shuffleNext))
#if defined(NOTIFY_SUBGROUPS)
GROUP_END(SELF)
#endif
#undef SELF
#undef CLASP_SEARCH_RESTART_OPTIONS
//! Options for configuring the deletion strategy of a solver.
#define SELF CLASP_SEARCH_REDUCE_OPTIONS
#if defined(NOTIFY_SUBGROUPS)
GROUP_BEGIN(SELF)
#endif
OPTION(deletion    , "!,d", ARG_EXT(defaultsTo("basic,75,0")->state(Value::value_defaulted), DEFINE_ENUM_MAPPING(ReduceStrategy::Algorithm,\
       MAP("basic", ReduceStrategy::reduce_linear), MAP("sort", ReduceStrategy::reduce_stable),\
       MAP("ipSort", ReduceStrategy::reduce_sort) , MAP("ipHeap", ReduceStrategy::reduce_heap))),
       "Configure deletion algorithm [%D]\n" \
       "      %A: [,][,]\n"  \
       "        : Use {basic|sort|ipSort|ipHeap} algorithm\n" \
       "           : Delete at most %% of nogoods on reduction    [75]\n" \
       "          : Use {0=activity|1=lbd|2=combined} nogood scores [0]\n" \
       "      no      : Disable nogood deletion", FUN(arg){\
       ReduceStrategy::Algorithm algo; uint32 n; uint32 sc;\
       return ITE(arg.off(), (SELF.disable(), true), arg>>algo>>opt(n = 75)>>opt(sc = 0)\
         && SET(SELF.strategy.algo, (uint32)algo) && SET_R(SELF.strategy.fReduce, n, 1, 100) && SET_LEQ(SELF.strategy.score, sc, 2));},\
       GET_IF(SELF.strategy.fReduce, (ReduceStrategy::Algorithm)SELF.strategy.algo, SELF.strategy.fReduce,SELF.strategy.score))
OPTION(del_grow    , "!", NO_ARG, "Configure size-based deletion policy\n" \
       "      %A: [,][,] ( >= 1.0)\n"          \
       "             : Keep at most T = X*(^i) learnt nogoods with X being the\n"\
       "                  initial limit and i the number of times  fired\n"     \
       "             : Stop growth once T > P* (0=no limit)      [3.0]\n"        \
       "         : Set grow schedule () [grow on restart]", FUN(arg){ double f; double g; ScheduleStrategy sc = ScheduleStrategy::def();\
       return ITE(arg.off(), (SELF.growSched = ScheduleStrategy::none(), SELF.fGrow = 0.0f, true),\
         arg>>f>>opt(g = 3.0)>>opt(sc) && SET_R(SELF.fGrow, (float)f, 1.0f, FLT_MAX) && SET_R(SELF.fMax, (float)g, 0.0f, FLT_MAX)\
           && (sc.defaulted() || sc.type != ScheduleStrategy::User) && (SELF.growSched=sc, true));},\
       GET_FUN(str) { if (SELF.fGrow == 0.0f) str<")), "Configure conflict-based deletion policy\n" \
       "      %A:   ,... (see restarts)", FUN(arg){\
       return ITE(arg.off(), (SELF.cflSched=ScheduleStrategy::none()).disabled(), arg>>SELF.cflSched && SELF.cflSched.type != ScheduleStrategy::User);}, GET(SELF.cflSched))
OPTION(del_init  , ""  , ARG(defaultsTo("3.0")->state(Value::value_defaulted)), "Configure initial deletion limit\n"\
       "      %A: [,,] ( > 0)\n" \
       "            : Set initial limit to P=estimated problem size/ [%D]\n" \
       "        ,: Clamp initial limit to the range [,+]" , FUN(arg) { double f; uint32 lo = 10; uint32 hi = UINT32_MAX;\
       return arg>>f>>opt(lo)>>opt(hi) && f > 0.0 && (SELF.fInit = float(1.0 / f)) > 0 && SET_OR_FILL(SELF.initRange.lo, lo) && SET_OR_FILL(SELF.initRange.hi, (uint64(hi)+SELF.initRange.lo));},\
       GET_IF(SELF.fInit, 1.0/SELF.fInit, SELF.initRange.lo, SELF.initRange.hi - SELF.initRange.lo))
OPTION(del_estimate, "", ARG(arg("0..3")->implicit("1")), "Use estimated problem complexity in limits", STORE_LEQ(SELF.strategy.estimate, 3u), GET(SELF.strategy.estimate))
OPTION(del_max     , "!", ARG(arg(",")), "Keep at most  learnt nogoods taking up to  MB", FUN(arg) { uint32 n = UINT32_MAX; uint32 mb = 0; \
       return (arg.off() || arg>>n>>opt(mb)) && SET_GEQ(SELF.maxRange, n, 1u) && SET(SELF.memMax, mb);}, GET(SELF.maxRange, SELF.memMax))
OPTION(del_glue    , "", NO_ARG, "Configure glue clause handling\n" \
       "      %A: [,]\n"                                    \
       "        : Do not delete nogoods with LBD <= \n"                    \
       "        : Count (0) or ignore (1) glue clauses in size limit [0]", FUN(arg) {uint32 lbd; uint32 m = 0; \
       return arg>>lbd>>opt(m) && SET(SELF.strategy.glue, lbd) && SET(SELF.strategy.noGlue, m);}, GET(SELF.strategy.glue, SELF.strategy.noGlue))
OPTION(del_protect , "", ARG(arg("")), "Protect recently updated nogoods if new LBD <= ", STORE_LEQ(SELF.strategy.protect, uint32(Clasp::LBD_MAX)), GET(SELF.strategy.protect))
OPTION(del_on_restart, "", ARG(arg("")->implicit("33")), "Delete %A%% of learnt nogoods on each restart", STORE_LEQ(SELF.strategy.fRestart, 100u), GET(SELF.strategy.fRestart))
#if defined(NOTIFY_SUBGROUPS)
GROUP_END(SELF)
#endif
#undef SELF
#undef CLASP_SEARCH_REDUCE_OPTIONS
GROUP_END(CLASP_SEARCH_OPTIONS)
#undef CLASP_SEARCH_OPTIONS
#endif

//! ASP-front-end options stored in an Clasp::Asp::LogicProgram::AspOptions object.
#if defined(CLASP_ASP_OPTIONS)
#define SELF CLASP_ASP_OPTIONS
GROUP_BEGIN(SELF)
OPTION(supp_models, ",@1" , ARG(flag())    , "Compute supported models", STORE_FLAG(SELF.suppMod), GET(SELF.suppMod))
OPTION(no_ufs_check, ",@1" , ARG(flag())   , "Disable unfounded set check", STORE_FLAG(SELF.noSCC), GET(SELF.noSCC))
OPTION(eq         , ""    , ARG(arg("")), "Configure equivalence preprocessing\n" \
       "      Run for at most %A iterations (-1=run to fixpoint)", STORE_OR_FILL(SELF.iters), GET(SELF.iters))
OPTION(backprop   , "!,@1", ARG(flag())    , "Use backpropagation in ASP-preprocessing", STORE_FLAG(SELF.backprop), GET(SELF.backprop))
OPTION(no_gamma   , ",@1" , ARG(flag())    , "Do not add gamma rules for non-hcf disjunctions", STORE_FLAG(SELF.noGamma), GET(SELF.noGamma))
OPTION(eq_dfs     , ",@2" , ARG(flag())    , "Enable df-order in eq-preprocessing", STORE_FLAG(SELF.dfOrder), GET(SELF.dfOrder))
OPTION(dlp_old_map, ",@3" , ARG(flag())    , "Enable old mapping for disjunctive LPs", STORE_FLAG(SELF.oldMap), GET(SELF.oldMap))
OPTION(trans_ext  , "!", ARG_EXT(arg(""), DEFINE_ENUM_MAPPING(Asp::LogicProgram::ExtendedRuleMode,\
       MAP("no"    , Asp::LogicProgram::mode_native)          , MAP("all" , Asp::LogicProgram::mode_transform),\
       MAP("choice", Asp::LogicProgram::mode_transform_choice), MAP("card", Asp::LogicProgram::mode_transform_card),\
       MAP("weight", Asp::LogicProgram::mode_transform_weight), MAP("scc" , Asp::LogicProgram::mode_transform_scc),\
       MAP("integ" , Asp::LogicProgram::mode_transform_integ) , MAP("dynamic", Asp::LogicProgram::mode_transform_dynamic))),\
       "Configure handling of extended rules\n"\
       "      %A: {all|choice|card|weight|integ|dynamic}\n"\
       "        all    : Transform all extended rules to basic rules\n"\
       "        choice : Transform choice rules, but keep cardinality and weight rules\n"\
       "        card   : Transform cardinality rules, but keep choice and weight rules\n"\
       "        weight : Transform cardinality and weight rules, but keep choice rules\n"\
       "        scc    : Transform \"recursive\" cardinality and weight rules\n"\
       "        integ  : Transform cardinality integrity constraints\n"\
       "        dynamic: Transform \"simple\" extended rules, but keep more complex ones", STORE(SELF.erMode), GET((Asp::LogicProgram::ExtendedRuleMode)SELF.erMode))
GROUP_END(SELF)
#undef CLASP_ASP_OPTIONS
#undef SELF
#endif

//! Options for the solving algorithm (see Clasp::SolveOptions)
#if defined(CLASP_SOLVE_OPTIONS)
#define SELF CLASP_SOLVE_OPTIONS
GROUP_BEGIN(SELF)
OPTION(solve_limit , "", ARG(arg("[,]")), "Stop search after  conflicts or  restarts\n", FUN(arg) {\
       uint32 n = UINT32_MAX; uint32 m = UINT32_MAX;\
       return ((arg.off() && arg.peek() != '0') || arg>>n>>opt(m)) && (SELF.limit=SolveLimits(n == UINT32_MAX ? UINT64_MAX : n, m == UINT32_MAX ? UINT64_MAX : m), true);},\
       GET((uint32)Range(0u,UINT32_MAX).clamp(SELF.limit.conflicts),(uint32)Range(0u,UINT32_MAX).clamp(SELF.limit.restarts)))
#if defined(WITH_THREADS) && WITH_THREADS == 1
OPTION(parallel_mode, ",t", ARG_EXT(arg(""), DEFINE_ENUM_MAPPING(SolveOptions::Algorithm::SearchMode,\
       MAP("compete", SolveOptions::Algorithm::mode_compete), MAP("split", SolveOptions::Algorithm::mode_split))),\
       "Run parallel search with given number of threads\n" \
       "      %A: [,]\n"   \
       "           : Number of threads to use in search\n"\
       "        : Run competition or splitting based search [compete]\n", FUN(arg){\
       uint32 n; SolveOptions::Algorithm::SearchMode mode;\
       return arg>>n>>opt(mode = SolveOptions::Algorithm::mode_compete) && SET_R(SELF.algorithm.threads, n, 1u, 64u) && SET(SELF.algorithm.mode, mode);},\
       GET(SELF.algorithm.threads, (SolveOptions::Algorithm::SearchMode)SELF.algorithm.mode))
OPTION(global_restarts, ",@1", ARG(implicit("5")->arg("")), "Configure global restart policy\n" \
       "      %A: [,] / Implicit: %I\n"                         \
       "         : Maximal number of global restarts (0=disable)\n"    \
       "     : Restart schedule [x,100,1.5] ()\n", FUN(arg) {\
       return ITE(arg.off(), (SELF.restarts = SolveOptions::GRestarts(), true), arg>>SELF.restarts.maxR>>opt(SELF.restarts.sched = ScheduleStrategy())\
         && SELF.restarts.maxR && SELF.restarts.sched.type != ScheduleStrategy::User);},\
       GET_IF(SELF.restarts.maxR, SELF.restarts.maxR, SELF.restarts.sched))
OPTION(dist_mode  , ",@2" , ARG(defaultsTo("0")->state(Value::value_defaulted)), "Use {0=global|1=thread} distribution", STORE_LEQ(SELF.distribute.mode,1u), GET(SELF.distribute.mode))
OPTION(distribute, "!,@1", ARG_EXT(defaultsTo("conflict,4"), DEFINE_ENUM_MAPPING(Distributor::Policy::Types,\
       MAP("all", Distributor::Policy::all), MAP("short", Distributor::Policy::implicit),\
       MAP("conflict", Distributor::Policy::conflict), MAP("loop" , Distributor::Policy::loop))),\
       "Configure nogood distribution [%D]\n" \
       "      %A: [,][,]\n"                     \
       "         : Distribute {all|short|conflict|loop} nogoods\n"  \
       "          : Distribute only if LBD  <=   [4]\n"         \
       "         : Distribute only if size <=  [-1]", FUN(arg) {\
       Distributor::Policy::Types type; uint32 lbd; uint32 size;
       return ITE(arg.off(), (SELF.distribute.policy()=Distributor::Policy(0,0,0), true),\
         arg>>type>>opt(lbd = 4)>>opt(size = UINT32_MAX) && SET(SELF.distribute.types, (uint32)type) && SET(SELF.distribute.lbd, lbd) && SET_OR_FILL(SELF.distribute.size, size));},\
       GET_IF(SELF.distribute.types, (Distributor::Policy::Types)SELF.distribute.types, SELF.distribute.lbd,SELF.distribute.size))
OPTION(integrate, ",@1", ARG_EXT(defaultsTo("gp")->state(Value::value_defaulted),\
       DEFINE_ENUM_MAPPING(SolveOptions::Integration::Filter, \
       MAP("all", SolveOptions::Integration::filter_no), MAP("gp", SolveOptions::Integration::filter_gp),\
       MAP("unsat", SolveOptions::Integration::filter_sat), MAP("active", SolveOptions::Integration::filter_heuristic))\
       DEFINE_ENUM_MAPPING(SolveOptions::Integration::Topology, \
       MAP("all" , SolveOptions::Integration::topo_all) , MAP("ring" , SolveOptions::Integration::topo_ring),\
       MAP("cube", SolveOptions::Integration::topo_cube), MAP("cubex", SolveOptions::Integration::topo_cubex))),\
       "Configure nogood integration [%D]\n" \
       "      %A: [,][,]\n"                                           \
       "        : Add {all|unsat|gp(unsat wrt guiding path)|active} nogoods\n" \
       "           : Always keep at least last  integrated nogoods   [1024]\n" \
       "        : Accept nogoods from {all|ring|cube|cubex} peers    [all]\n", FUN(arg) {\
       SolveOptions::Integration::Filter pick; uint32 n; SolveOptions::Integration::Topology topo;
       return arg>>pick>>opt(n = 1024)>>opt(topo = SolveOptions::Integration::topo_all) && SET(SELF.integrate.filter, (uint32)pick) && SET_OR_FILL(SELF.integrate.grace, n) && SET(SELF.integrate.topo, (uint32)topo);},\
       GET((SolveOptions::Integration::Filter)SELF.integrate.filter, SELF.integrate.grace, (SolveOptions::Integration::Topology)SELF.integrate.topo))
#endif
OPTION(enum_mode   , ",e", ARG_EXT(defaultsTo("auto")->state(Value::value_defaulted), DEFINE_ENUM_MAPPING(SolveOptions::EnumType,\
       MAP("bt", SolveOptions::enum_bt), MAP("record", SolveOptions::enum_record), MAP("domRec", SolveOptions::enum_dom_record),\
       MAP("brave", SolveOptions::enum_brave), MAP("cautious", SolveOptions::enum_cautious), MAP("query", SolveOptions::enum_query),\
       MAP("auto", SolveOptions::enum_auto), MAP("user", SolveOptions::enum_user))),\
       "Configure enumeration algorithm [%D]\n" \
       "      %A: {bt|record|brave|cautious|auto}\n" \
       "        bt      : Backtrack decision literals from solutions\n" \
       "        record  : Add nogoods for computed solutions\n" \
       "        domRec  : Add nogoods over true domain atoms\n" \
       "        brave   : Compute brave consequences (union of models)\n" \
       "        cautious: Compute cautious consequences (intersection of models)\n" \
       "        auto    : Use bt for enumeration and record for optimization", STORE(SELF.enumMode), GET(SELF.enumMode))
OPTION(project, "", ARG(implicit("6")), "Enable projective solution enumeration", STORE_LEQ(SELF.project, 7u), GET(SELF.project))
OPTION(models, ",n", ARG(arg("")), "Compute at most %A models (0 for all)\n", STORE(SELF.numModels), GET(SELF.numModels))
OPTION(opt_mode   , "", ARG_EXT(arg(""), DEFINE_ENUM_MAPPING(MinimizeMode_t::Mode,\
       MAP("opt" , MinimizeMode_t::optimize), MAP("enum"  , MinimizeMode_t::enumerate),\
       MAP("optN", MinimizeMode_t::enumOpt) , MAP("ignore", MinimizeMode_t::ignore))),\
       "Configure optimization algorithm\n"\
       "      %A: {opt|enum|optN|ignore}\n" \
       "        opt   : Find optimal model\n" \
       "        enum  : Find models with costs <= initial bound\n" \
       "        optN  : Find optimum, then enumerate optimal models\n"\
       "        ignore: Ignore optimize statements", STORE(SELF.optMode), GET((MinimizeMode_t::Mode)SELF.optMode))
OPTION(opt_bound, "!" , ARG(arg("...")), "Initialize objective function(s)", FUN(arg) {\
       SumVec B; \
       return (arg.off() || arg>>B) && (SELF.optBound.swap(B), true);},\
       GET_IF(!SELF.optBound.empty(), SELF.optBound))
OPTION(opt_sat    , ""   , ARG(flag())         , "Treat dimacs input as MaxSAT optimization problem", STORE(SELF.maxSat), GET(SELF.maxSat))
GROUP_END(SELF)
#undef CLASP_SOLVE_OPTIONS
#undef SELF
#endif

#undef GROUP_BEGIN
#undef GROUP_END
#undef OPTION
#undef NOTIFY_SUBGROUPS
#undef ARG
#undef ARG_EXT
#undef NO_ARG
clasp-3.2.2/libclasp/clasp/cli/clasp_options.h000066400000000000000000000266151304134206100213140ustar00rootroot00000000000000//
// Copyright (c) 2006-2013, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLI_CLASP_OPTIONS_H_INCLUDED
#define CLASP_CLI_CLASP_OPTIONS_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
#include 
namespace ProgramOptions {
class OptionContext;
class OptionGroup;
class ParsedOptions;
}
/*!
 * \file
 * \brief Types and functions for processing command-line options.
 */
namespace Clasp {
//! Namespace for types and functions used by the command-line interface.
namespace Cli {

/**
 * \defgroup cli Cli
 * \brief Types mainly relevant to the command-line interface.
 * \ingroup facade
 * @{
 */

class ClaspCliConfig;
//! Class for iterating over a set of configurations.
class ConfigIter {
public:
	const char* name() const;
	const char* base() const;
	const char* args() const;
	bool        valid()const;
	bool        next();
private:
	friend class ClaspCliConfig;
	ConfigIter(const char* x);
	const char* base_;
};
//! Valid configuration keys.
/*!
 * \see clasp_cli_configs.inl
 */
enum ConfigKey {
#define CONFIG(id,k,c,s,p) config_##k,
#define CLASP_CLI_DEFAULT_CONFIGS config_default = 0,
#define CLASP_CLI_AUX_CONFIGS     config_default_max_value,
#include 
	config_aux_max_value,
	config_many, // default portfolio
	config_max_value,
	config_asp_default   = config_tweety,
	config_sat_default   = config_trendy,
	config_tester_default= config_tester,
};
/*!
 * \brief Class for storing/processing command-line options.
 *
 * Caveats (when using incrementally, e.g. from clingo):
 * - supp-models: State Transition (yes<->no) not supported.
 *     - supp-models=yes is irreversible for a step
 *       because it enables possibly destructive simplifications
 *       and skips SCC-checking (i.e. new SCCs are silently discarded).
 *     - Nogoods learnt during supp-models=no are not tagged and
 *       hence can't simply be removed on transition to yes.
 *     .
 * - stats: Stats level can only be increased.
 *     - A stats level once activated stays activated even if
 *       level is subsequently decreased via option.
 *     .
 * - save-progress, sign-fix, opt-heuristic: No unset of previously set values.
 *     - Once set, signs are only unset if forgetOnStep includes sign.
 *     .
 * - no-lookback: State Transition (yes<->no) not supported.
 *     - noLookback=yes is a destructive meta-option that disables lookback-options by changing their value
 *     - noLookback=no does not re-enable those options.
 *     .
 */
class ClaspCliConfig : public ClaspConfig {
public:
	//! Returns defaults for the given problem type.
	static const char* getDefaults(ProblemType f);
	//! Returns the configuration with the given key.
	static ConfigIter  getConfig(ConfigKey key);

	ClaspCliConfig();
	~ClaspCliConfig();
	// Base interface
	virtual void prepare(SharedContext&);
	virtual void reset();
	virtual Configuration* config(const char*);

	/*!
	 * \name Key-based low-level interface
	 *
	 * The functions in this group do not throw exceptions but
	 * signal logic errors via return values < 0.
	 * @{ */

	typedef uint32 KeyType;
	static const KeyType KEY_INVALID; //!< Invalid key used to signal errors.
	static const KeyType KEY_ROOT;    //!< Root key of a configuration, i.e. "."
	static const KeyType KEY_TESTER;  //!< Root key for tester options, i.e. "tester."
	static const KeyType KEY_SOLVER;  //!< Root key for (array of) solver options, i.e. "solver."

	//! Returns true if k is a leaf, i.e. has no subkeys.
	static bool  isLeafKey(KeyType k);

	//! Retrieves a handle to the specified key.
	/*!
	 * \param key A valid handle to a key.
	 * \param name The name of the subkey to retrieve.
	 * \return
	 *   - key, if name is 0 or empty.
	 *   - KEY_INVALID, if name is not a subkey of key.
	 *   - A handle to the subkey.
	 *   .
	 */
	KeyType getKey(KeyType key, const char* name = 0) const;

	//! Retrieves a handle to the specified element of the given array key.
	/*!
	 * \param arr     A valid handle to an array.
	 * \param element The index of the element to retrieve.
	 * \return
	 *   - A handle to the requested element, or
	 *   - KEY_INVALID, if arr does not reference an array or element is out of bounds.
	 *   .
	 */
	KeyType getArrKey(KeyType arr, unsigned element) const;

	//! Retrieves information about the specified key.
	/*!
	 * \param key  A valid handle to a key.
	 * \param[out] nSubkeys The number of subkeys of this key or 0 if key is a leaf.
	 * \param[out] arrLen   If key is an array, the length of the array (can be 0). Otherwise, -1.
	 * \param[out] help     A description of the key.
	 * \param[out] nValues  The number of values the key currently has (0 or 1) or -1 if it can't have values.
	 * \note All out parameters are optional, i.e. can be 0.
	 * \return The number of out values or -1 if key is invalid.
	 */
	int getKeyInfo(KeyType key, int* nSubkeys = 0, int* arrLen = 0, const char** help = 0, int* nValues = 0) const;

	//! Returns the name of the i'th subkey of k or 0 if no such subkey exists.
	const char* getSubkey(KeyType k, uint32 i) const;

	//! Creates and returns a string representation of the value of the given key.
	/*!
	 * \param k  A valid handle to a key.
	 * \param[out] value The current value of the key.
	 * \return The length of value or < 0 if k either has no value (-1) or an error occurred while writing the value (< -1).
	 */
	int getValue(KeyType k, std::string& value) const;

	//! Writes a null-terminated string representation of the value of the given key into the supplied buffer.
	/*!
	 * \param k A valid handle to a key.
	 * \param[out] buffer The current value of the key.
	 * \param bufSize The size of buffer.
	 * \note Although the number returned can be larger than the bufSize, the function
	 *   never writes more than bufSize bytes into the buffer.
	 */
	int getValue(KeyType k, char* buffer, std::size_t bufSize) const;

	//! Sets the option identified by the given key.
	/*!
	 * \param key A valid handle to a key.
	 * \param value The value to set.
	 * \return
	 *   - > 0: if the value was set.
	 *   - = 0: if value is not a valid value for the given key.
	 *   - < 0: f key does not accept a value (-1), or some error occurred (< -1).
	 *   .
	 */
	int setValue(KeyType key, const char* value);

	//@}

	/*!
	 * \name String-based interface
	 *
	 * The functions in this group wrap the key-based functions and
	 * signal logic errors by throwing exceptions.
	 * @{ */
	//! Returns the value of the option identified by the given key.
	std::string getValue(const char* key) const;
	//! Returns true if the given key has an associated value.
	bool        hasValue(const char* key) const;
	//! Sets the option identified by the given key.
	bool        setValue(const char* key, const char* value);
	//@}

	//! Validates this configuration.
	bool        validate();

	/*!
	 * \name App interface
	 *
	 * Functions for connecting a configuration with the ProgramOptions library.
	 * @{ */
	//! Adds all available options to root.
	/*!
	 * Once options are added, root can be used with an option source (e.g. the command-line)
	 * to populate this object.
	 */
	void addOptions(ProgramOptions::OptionContext& root);
	//! Adds options that are disabled by the options contained in parsed to parsed.
	void addDisabled(ProgramOptions::ParsedOptions& parsed);
	//! Applies the options in parsed and finalizes and validates this configuration.
	bool finalize(const ProgramOptions::ParsedOptions& parsed, ProblemType type, bool applyDefaults);
	//! Populates this configuration with the options given in [first, last) and finalizes it.
	/*!
	 * \param [first, last) a range of options in argv format.
	 * \param t Problem type for which this configuration is created. Used to set defaults.
	 */
	template 
	bool setConfig(IT first, IT last, ProblemType t) {
		RawConfig config("setConfig");
		while (first != last) { config.addArg(*first++); }
		return setAppConfig(config, t);
	}
	//! Releases internal option objects needed for command-line style option processing.
	/*!
	 * \note Subsequent calls to certain functions of this object (e.g. addOptions(), setConfig())
	 *       recreate the option objects if necessary.
	 */
	void releaseOptions();
	//@}
private:
	static const uint8 mode_solver = 1u;
	static const uint8 mode_tester = 2u;
	static const uint8 mode_relaxed= 4u;
	struct ParseContext;
	struct OptIndex;
	class  ProgOption;
	typedef ProgramOptions::OptionContext OptionContext;
	typedef ProgramOptions::OptionGroup   Options;
	typedef SingleOwnerPtr       OptionsPtr;
	typedef PodVector::type  ConfigVec;
	typedef ProgramOptions::ParsedOptions ParsedOpts;
	struct ScopedSet {
		ScopedSet(ClaspCliConfig& s, uint8 mode, uint32 sId = 0);
		~ScopedSet();
		ClaspCliConfig* operator->()const { return self; }
		ClaspCliConfig* self;
	};
	struct RawConfig {
		std::string raw;
		explicit RawConfig(const char* name);
		void addArg(const char* arg);
		void addArg(const std::string& arg);
		ConfigIter iterator() const { return ConfigIter(raw.data()); }
	};
	// Operations on active config and solver
	int  setActive(int o, const char* value);
	int  getActive(int o, std::string* value, const char** desc, const char** opt) const;
	int  applyActive(int o, const char* setValue, std::string* getValue, const char** getDesc, const char** name);
	// App interface impl
	bool setAppConfig(const RawConfig& c, ProblemType t);
	int  setAppOpt(int o, const char* value);
	bool setAppDefaults(UserConfig* active, uint32 sId, const ParsedOpts& exclude, ProblemType t);
	bool finalizeAppConfig(UserConfig* active, const ParsedOpts& exclude, ProblemType t, bool defs);
	const ParsedOpts& finalizeParsed(UserConfig* active, const ParsedOpts& parsed, ParsedOpts& exclude) const;
	void              createOptions();
	ProgOption*       createOption(int o);
	bool assignDefaults(const ParsedOpts&);
	// Configurations
	static bool       appendConfig(std::string& to, const std::string& line);
	static bool       loadConfig(std::string& to, const char* fileName);
	ConfigIter        getConfig(uint8 key, std::string& tempMem);
	bool              setConfig(const ConfigIter& it, bool allowAppOpt, const ParsedOpts& exclude, ParsedOpts* out);
	// helpers
	bool             isGenerator() const { return (cliMode & mode_tester) == 0; }
	const UserConfig*active()const       { return isGenerator() ? this : testerConfig(); }
	UserConfig*      active()            { return isGenerator() ? this : testerConfig(); }
	bool             match(const char*& path, const char* what) const;
	static OptIndex  index_g;
	OptionsPtr       opts_;
	std::string      config_[2];
	bool             initTester_;
};
//! Validates the given solver configuration and throws an exception if invalid.
void validate(const char* ctx, const SolverParams& solver, const SolveParams& search);
//@}

}}
#endif
clasp-3.2.2/libclasp/clasp/cli/clasp_output.h000066400000000000000000000257551304134206100211650ustar00rootroot00000000000000//
// Copyright (c) 2009-2013, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLI_OUTPUT_H_INCLUDED
#define CLASP_CLI_OUTPUT_H_INCLUDED
#include 
#include 
#include 
#include 
namespace Clasp { namespace Cli {
void format(const Clasp::BasicSolveEvent& ev, char* out, uint32 outSize);
void format(const Clasp::SolveTestEvent&  ev, char* out, uint32 outSize);
#if WITH_THREADS
void format(const Clasp::mt::MessageEvent& ev, char* out, uint32 outSize);
#endif

/*!
 * \addtogroup cli
 * @{ */
/*!
 * \brief Interface for printing status and input format dependent information,
 * like models, optimization values, and summaries.
 */
class Output : public EventHandler {
public:
	//! Supported levels for printing models, optimize values, and individual calls.
	enum PrintLevel {
		print_all  = 0, //!< Print all models, optimize values, or calls.
		print_best = 1, //!< Only print last model, optimize value, or call.
		print_no   = 2, //!< Do not print any models, optimize values, or calls.
	};
	explicit Output(uint32 verb = 1);
	virtual ~Output();
	//! Active verbosity level.
	uint32 verbosity()               const { return verbose_; }
	//! Do not output any models?
	bool   quiet()                   const { return modelQ() == 2 && optQ() == 2; }
	//! Print level for models.
	int    modelQ()                  const { return static_cast(quiet_[0]); }
	//! Print level for optimization values.
	int    optQ()                    const { return static_cast(quiet_[1]); }
	//! Print level for individual (solve) calls.
	int    callQ()                   const { return static_cast(quiet_[2]); }

	using  EventHandler::setVerbosity;
	void   setVerbosity(uint32 verb);
	void   setModelQuiet(PrintLevel model);
	void   setOptQuiet(PrintLevel opt);
	void   setCallQuiet(PrintLevel call);

	//! Shall be called once on startup.
	virtual void run(const char* solver, const char* version, const std::string* begInput, const std::string* endInput) = 0;
	//! Shall be called once on shutdown.
	virtual void shutdown(const ClaspFacade::Summary& summary);
	virtual void shutdown() = 0;
	//! Handles ClaspFacade events by forwarding calls to startStep() and stopStep().
	virtual void onEvent(const Event& ev);
	//! Checks quiet-levels and forwards to printModel() if appropriate.
	virtual bool onModel(const Solver& s, const Model& m);
	//! Checks quiet-levels and forwards to printLower() if appropriate.
	virtual bool onUnsat(const Solver& s, const Model& m);
	//! Shall print the given model.
	virtual void printModel(const OutputTable& out, const Model& m, PrintLevel x) = 0;
	//! Called on unsat - may print new info.
	virtual void printUnsat(const OutputTable& out, const LowerBound* lower, const Model* prevModel);
	//! A solving step has started.
	virtual void startStep(const ClaspFacade&);
	//! A solving step has stopped.
	virtual void stopStep(const ClaspFacade::Summary& summary);
	//! Shall print the given summary.
	virtual void printSummary(const ClaspFacade::Summary& summary, bool final)    = 0;
	//! Shall print the given statistics.
	virtual void printStatistics(const ClaspFacade::Summary& summary, bool final) = 0;
protected:
	typedef std::pair OutPair;
	typedef uintp UPtr;
	typedef std::pair UPair;
	const Model* getModel() const { return saved_.values ? &saved_ : 0; }
	void         saveModel(const Model& m);
	void         clearModel() { saved_.reset(); }
	void         printWitness(const OutputTable& out, const Model& m, UPtr data);
	virtual UPtr doPrint(const OutPair& out, uintp data);
	UPair        numCons(const OutputTable& out, const Model& m) const;
	bool         stats(const ClaspFacade::Summary& summary) const;
private:
	Output(const Output&);
	Output& operator=(const Output&);
	typedef const ClaspFacade::Summary* SumPtr ;
	SumPtr    summary_ ; // summary of last step
	ValueVec  vals_    ; // saved values from most recent model
	SumVec    costs_   ; // saved costs from most recent model
	Model     saved_   ; // most recent model
	uint32    verbose_ ; // verbosity level
	uint8     quiet_[3]; // quiet levels for models, optimize, calls
};

//! Prints models and solving statistics in Json-format to stdout.
class JsonOutput : public Output, private StatsVisitor {
public:
	explicit JsonOutput(uint32 verb);
	~JsonOutput();
	virtual void run(const char* solver, const char* version, const std::string* begInput, const std::string* endInput);
	virtual void shutdown(const ClaspFacade::Summary& summary);
	virtual void shutdown();
	virtual void printSummary(const ClaspFacade::Summary&    summary, bool final);
	virtual void printStatistics(const ClaspFacade::Summary& summary, bool final);
private:
	virtual void startStep(const ClaspFacade&);
	virtual void stopStep(const ClaspFacade::Summary& summary);
	virtual bool visitThreads(Operation op);
	virtual bool visitTester(Operation op);
	virtual bool visitHccs(Operation op);

	virtual void visitThread(uint32, const SolverStats& stats);
	virtual void visitHcc(uint32, const ProblemStats& p, const SolverStats& s);
	virtual void visitLogicProgramStats(const Asp::LpStats& stats);
	virtual void visitProblemStats(const ProblemStats& stats);
	virtual void visitSolverStats(const SolverStats& stats);
	virtual UPtr doPrint(const OutPair& out, UPtr data);
	enum ObjType { type_object, type_array };
	void pushObject(const char* k = 0, ObjType t = type_object);
	char popObject();
	void printKeyValue(const char* k, const char* v) ;
	void printKeyValue(const char* k, uint64 v);
	void printKeyValue(const char* k, uint32 v);
	void printKeyValue(const char* k, double d);
	void printString(const char* s, const char* sep);
	void printKey(const char* k);
	void printModel(const OutputTable& out, const Model& m, PrintLevel x);
	void printCosts(const SumVec& costs, const char* name = "Costs");
	void printCons(const UPair& cons);
	void printCoreStats(const CoreStats&);
	void printExtStats(const ExtendedStats&, bool generator);
	void printJumpStats(const JumpStats&);
	void startModel();
	bool hasWitness() const { return !objStack_.empty() && *objStack_.rbegin() == '['; }
	uint32 indent()   const { return static_cast(objStack_.size() * 2); }
	const char* open_;
	std::string objStack_;
};

//! Default clasp format printer.
/*!
 * Prints all output to stdout in given format:
 * - format_asp prints in clasp's default asp format
 * - format_aspcomp prints in in ASP competition format
 * - format_sat09 prints in SAT-competition format
 * - format_pb09 in PB-competition format
 * .
 * \see https://www.mat.unical.it/aspcomp2013/
 * \see http://www.satcompetition.org/2009/format-solvers2009.html
 * \see http://www.cril.univ-artois.fr/PB09/solver_req.html
 *
 */
class TextOutput : public Output, private StatsVisitor {
public:
	//! Supported text formats.
	enum Format      { format_asp, format_aspcomp, format_sat09, format_pb09 };
	enum ResultStr   { res_unknonw = 0, res_sat = 1, res_unsat = 2, res_opt = 3, num_str };
	enum CategoryKey { cat_comment, cat_value, cat_objective, cat_result, cat_value_term, cat_atom_name, cat_atom_var, num_cat };

	const char* result[num_str]; //!< Default result strings.
	const char* format[num_cat]; //!< Format strings.

	TextOutput(uint32 verbosity, Format f, const char* catAtom = 0, char ifs = ' ');
	~TextOutput();

	//! Prints a (comment) message containing the given solver and input.
	virtual void run(const char* solver, const char* version, const std::string* begInput, const std::string* endInput);
	virtual void shutdown();
	//! Prints the given model.
	/*!
	 * Prints format[cat_value] followed by the elements of the model. Individual
	 * elements e are printed as format[cat_atom] and separated by the internal field separator.
	 */
	virtual void printModel(const OutputTable& out, const Model& m, PrintLevel x);
	//! Prints the given lower bound and upper bounds that are known to be optimal.
	virtual void printUnsat(const OutputTable& out, const LowerBound* lower, const Model* prevModel);
	//! Called once a solving step has completed.
	/*!
	 * Always prints "format[cat_result] result[s.result()]".
	 * Furthermore, if verbosity() > 0, prints a summary consisting of
	 *   - the number of computed models m and whether the search space was exhausted
	 *   - the number of enumerated models e if e != m
	 *   - the state of any optimization and whether the last model was optimal
	 *   - the state of consequence computation and whether the last model corresponded to the consequences
	 *   - timing information
	 *   .
	 */
	virtual void printSummary(const ClaspFacade::Summary& s   , bool final);
	virtual void printStatistics(const ClaspFacade::Summary& s, bool final);
	//! Prints progress events (preprocessing/solving) if verbosity() > 1.
	virtual void onEvent(const Event& ev);
	//! A solving step has started.
	virtual void startStep(const ClaspFacade&);
	//! Prints a comment message.
	void comment(uint32 v, const char* fmt, ...) const;
protected:
	virtual bool visitThreads(Operation op);
	virtual bool visitTester(Operation op);

	virtual void visitThread(uint32, const SolverStats& stats);
	virtual void visitHcc(uint32, const ProblemStats& p, const SolverStats& s);
	virtual void visitLogicProgramStats(const Asp::LpStats& stats);
	virtual void visitProblemStats(const ProblemStats& stats);
	virtual void visitSolverStats(const SolverStats& stats);

	virtual UPtr doPrint(const OutPair& out, UPtr data);
	const char* fieldSeparator() const;
	int         printSep(CategoryKey c) const;
	void        printCosts(const SumVec&) const;
	void        printBounds(const SumVec& upper, const SumVec& lower) const;
	void        printStats(const SolverStats& stats) const;
	void        printJumps(const JumpStats&) const;
	bool        startSection(const char* n)  const;
	void        startObject(const char* n, uint32 i) const;
	void        setState(uint32 state, uint32 verb, const char* st);
	void        printSolveProgress(const Event& ev);
	void        printValues(const OutputTable& out, const Model& m);
	void        printMeta(const OutputTable& out, const Model& m);
private:
	typedef Clasp::Atomic_t::type EvType;
	std::string fmt_;
	double stTime_;// time on state enter
	EvType ev_;    // last event type
	int    width_; // output width
	int    line_;  // lines to print until next separator
	uint32 state_; // active state
	char   ifs_[2];// field separator
	bool   accu_;
};
//@}

}}
#endif
clasp-3.2.2/libclasp/clasp/clingo.h000066400000000000000000000124451304134206100171370ustar00rootroot00000000000000//
// Copyright (c) 2015-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLINGO_H_INCLUDED
#define CLASP_CLINGO_H_INCLUDED
/*!
 * \file
 * \brief Types for implementing theory propagation from clingo.
 */
#include 
#include 
namespace Clasp {

/*!
 * \defgroup clingo Clingo
 * \brief Additional classes mainly used by clingo.
 * \ingroup facade
 * @{ */

//! Lock interface called by libclasp during (multi-threaded) theory propagation.
/*!
 * The interface may be implemented by the application to lock
 * certain global data structures. For example, in clingo,
 * this interface wraps python's global interpreter lock.
 */
class ClingoPropagatorLock {
public:
	virtual ~ClingoPropagatorLock();
	virtual void lock()   = 0;
	virtual void unlock() = 0;
};

//! Adaptor for a Potassco::AbstractPropagator.
/*!
 * The class adapts a given Potassco::AbstractPropagator so that
 * it is usable as a PostPropagator within libclasp.
 * \note This class is meant to be a final class.
 */
class ClingoPropagator : public Clasp::PostPropagator {
public:
	typedef Potassco::AbstractPropagator::ChangeList ChangeList;
	typedef Clasp::PostPropagator::PropResult PPair;

	/*!
	 * If lock is not null, calls to cb are wrapped in a lock->lock()/lock->unlock() pair
	 */
	ClingoPropagator(const LitVec& watches, Potassco::AbstractPropagator& cb, ClingoPropagatorLock* lock = 0);

	// PostPropagator
	virtual uint32 priority() const;
	virtual bool   init(Solver& s);
	virtual bool   propagateFixpoint(Clasp::Solver& s, Clasp::PostPropagator* ctx);
	virtual PPair  propagate(Solver&, Literal, uint32&);
	virtual bool   isModel(Solver& s);
	virtual void   reason(Solver&, Literal, LitVec&);
	virtual void   undoLevel(Solver& s);
	virtual bool   simplify(Solver& s, bool reinit);
	virtual void   destroy(Solver* s, bool detach);
private:
	typedef LitVec::size_type size_t;
	typedef Potassco::Lit_t Lit_t;
	class Control;
	enum State { state_ctrl = 1u, state_prop = 2u };
	struct ClauseTodo {
		bool empty() const { return mem.empty(); }
		void clear()       { mem.clear(); }
		LitVec    mem;
		ClauseRep clause;
		uint32    flags;
	};
	typedef PodVector::type        TrailVec;
	typedef PodVector::type  ClauseDB;
	typedef Potassco::AbstractPropagator* Callback;
	typedef ClingoPropagatorLock*         ClingoLock;
	typedef const LitVec&                 Watches;
	bool addClause(Solver& s, uint32 state);
	void toClause(Solver& s, const Potassco::LitSpan& clause, Potassco::Clause_t prop);
	Watches    watches_; // set of watched literals
	Callback   call_;    // actual theory propagator
	ClingoLock lock_;    // optional lock for protecting calls to theory propagator
	TrailVec   trail_;   // assignment trail: watched literals that are true
	VarVec     undo_;    // offsets into trail marking beginnings of decision levels
	ClauseDB   db_;      // clauses added with flag static
	ClauseTodo todo_;    // active clause to be added (received from theory propagator)
	size_t     init_;    // offset into watches separating old and newly added ones
	size_t     prop_;    // offset into trail: literals [0, prop_) were propagated
	size_t     epoch_;   // number of calls into callback
	uint32     level_;   // highest decision level in trail
	Literal    aux_;     // max active literal
};

//! Initialization adaptor for a Potassco::AbstractPropagator.
/*!
 * The class provides a function for registering watches for the propagator.
 * Furthermore, it can be added to a clasp configuration so that
 * a (suitably adapted) propagator is added to solvers that are attached to the configuration.
 */
class ClingoPropagatorInit : public ClaspConfig::Configurator {
public:
	//! Creates a new adaptor.
	/*!
	 * \param cb The (theory) propagator that should be added to solvers.
	 * \param lock An optional lock that should be applied during theory propagation.
	 */
	ClingoPropagatorInit(Potassco::AbstractPropagator& cb, ClingoPropagatorLock* lock = 0);
	~ClingoPropagatorInit();
	// base class
	virtual void prepare(SharedContext&);
	//! Adds a ClingoPropagator adapting the propagator() to s.
	virtual bool addPost(Solver& s);

	// for clingo
	//! Registers a watch for lit and returns encodeLit(lit).
	Potassco::Lit_t addWatch(Literal lit);

	//! Returns the propagator that was given on construction.
	Potassco::AbstractPropagator* propagator() const { return prop_; }
private:
	ClingoPropagatorInit(const ClingoPropagatorInit&);
	ClingoPropagatorInit& operator=(const ClingoPropagatorInit&);
	Potassco::AbstractPropagator* prop_;
	ClingoPropagatorLock* lock_;
	LitVec watches_;
	VarVec seen_;
};
///@}
}
#endif
clasp-3.2.2/libclasp/clasp/constraint.h000066400000000000000000000522301304134206100200440ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CONSTRAINT_H_INCLUDED
#define CLASP_CONSTRAINT_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include  // bits stuff
#include 

/*!
 * \file
 * \brief Defines the base classes for boolean constraints.
 */
namespace Clasp {

class  SharedContext;
class  Solver;
class  ClauseHead;
struct CCMinRecursive;

/**
 * \defgroup constraint Constraints
 * \brief Boolean Constraints, post propagators, and related types.
 * @{ */

//! Constraint types distinguished by a Solver.
struct Constraint_t {
	enum Type {
		Static     = 0, //!< An unremovable constraint (e.g. a problem constraint).
		Conflict   = 1, //!< A removable constraint derived from conflict analysis.
		Loop       = 2, //!< A removable constraint derived from unfounded set checking.
		Other      = 3, //!< A removable constraint learnt by some other means.
		Type__max  = Other
	};
	struct Set {
		Set() : m(0) {}
		bool inSet(Type t) const { return (m & (uint32(1)<[priority_class_simple, priority_class_general)
 *       - class_general: post propagators that are non-deterministic or those that are not limited to extending
 *         the current decision level shall have a priority of priority_class_general. They are called in FIFO order
 *         after \b all simple post propagators have reached a fixpoint.
 *
 * \note There are currently three reserved priority values, namely
 *  - priority_reserved_msg for message and termination handler (if any),
 *  - priority_reserved_ufs for the default unfounded set checker (if any),
 *  - and priority_reserved_look for the default lookahead operator (if any).
 *  .
 */
class PostPropagator : public Constraint {
public:
	PostPropagator();
	virtual ~PostPropagator();
	using Constraint::propagate;  // Enable overloading!

	PostPropagator* next; // main propagation lists of post propagators
	//! Default priorities for post propagators.
	enum Priority {
		priority_class_simple    = 0,    //!< Starting priority of simple post propagators.
		priority_reserved_msg    = 0,    //!< Reserved priority for message/termination handlers (if any).
		priority_reserved_ufs    = 10,   //!< Reserved priority for the default unfounded set checker (if any).
		priority_reserved_look   = 1023, //!< Reserved priority for the default lookahead operator (if any).
		priority_class_general   = 1024, //!< Priortiy of extended post propagators.
	};

	//! Shall return a value representing the priority of this propagator.
	/*!
	 * The priority is used to order sequences of post propagators and to
	 * classify post propagators w.r.t the classes: class_simple and class_general.
	 * \note See class description for an overview of the two priority classes.
	 */
	virtual uint32 priority() const = 0;

	//! Called during initialization of s.
	/*!
	 * \note During initialization a post propagator may assign variables
	 *       but it must not yet propagate them.
	 */
	virtual bool   init(Solver& s);

	//! Shall enqueue and propagate new assignments implied by this propagator.
	/*!
	 * This function shall enqueue and propagate all assignments currently implied by
	 * this propagator until a fixpoint is reached w.r.t this post propagator or
	 * a conflict is detected.
	 *
	 * \pre   The assignment is fully propagated w.r.t any previous post propagator.
	 * \param s    The solver in which this post propagator is used.
	 * \param ctx  The post propagator from which this post propagator is called or
	 *             0 if no other post propagator is currently active.
	 * \post  s.queueSize() == 0 || s.hasConflict()
	 * \return false if propagation led to conflict, true otherwise
	 *
	 * \note
	 *   The function shall not call Solver::propagate()
	 *   or any other function that would result in a recursive chain
	 *   of propagate() calls. On the other hand, it shall call
	 *   Solver::propagateUntil(this) after enqueuing any new assignments
	 *   to initiate propagation up to this propagator.
	 *
	 * Typically, propagateFixpoint() should implemet a loop like this:
	 * \code
	 * for (;;) {
	 *   if (!assign_newly_implied_literals(s)){ return false; }
	 *   if (s.queueSize() == 0)               { return true;  }
	 *   if (!s.propagateUntil(this))          { return false; }
	 * }
	 * \endcode
	 */
	virtual bool   propagateFixpoint(Solver& s, PostPropagator* ctx) = 0;

	//! Aborts an active propagation operation.
	/*!
	 * The function reset() is called whenever propagation on the
	 * current decision level is stopped before a fixpoint is reached.
	 * In particular, a solver calls reset() when a conflict is detected
	 * during propagation.
	 *
	 * \note The default implementation is a noop.
	 */
	virtual void   reset();

	//! Is the current total assignment a model?
	/*!
	 * \pre The assignment is total and not conflicting.
	 * \return
	 *  - true if the assignment is a model w.r.t this post propagator
	 *  - false otherwise
	 * \post If the function returned true:  s.numFreeVars() == 0 && !s.hasConflict().
	 *       If the function returned false: s.numFreeVars() > 0 || s.hasConflict().
	 * \note The default implementation returns Constraint::valid(s);
	 */
	virtual bool   isModel(Solver& s);
protected:
	//! Calls reset on post propagators following this.
	void cancelPropagation();

	//! PostPropagators are not clonable by default.
	Constraint* cloneAttach(Solver&) { return 0; }
	// Constraint interface - noops
	PropResult  propagate(Solver&, Literal, uint32&);
	void        reason(Solver&, Literal, LitVec& );
private:
	PostPropagator(const PostPropagator&);
	PostPropagator& operator=(const PostPropagator&);
};

//! A special post propagator used to handle messages and signals.
class MessageHandler : public PostPropagator {
public:
	MessageHandler();
	virtual bool   handleMessages() = 0;
	virtual uint32 priority()const { return PostPropagator::priority_reserved_msg; }
	virtual bool   propagateFixpoint(Solver&, PostPropagator*) { return handleMessages(); }
};

//! An intrusive list of post propagators ordered by priority.
/*!
 * Propagators in the list are owned by the list.
 */
class PropagatorList {
public:
	PropagatorList();
	~PropagatorList();
	void add(PostPropagator* p);
	void remove(PostPropagator* p);
	void clear();
	PostPropagator* find(uint32 prio) const;
	PostPropagator*const* head() const { return &head_; }
	PostPropagator**      head() { return &head_; }
private:
	PropagatorList(const PropagatorList&);
	PropagatorList& operator=(const PropagatorList&);
	PostPropagator* head_;// head of pp-list
};
//@}

/**
* \addtogroup constraint
* @{ */

//! Stores a reference to the constraint that implied a literal.
/*!
 * Stores a reference to the constraint that implied a certain literal or
 * null if the literal has no antecedent (i.e. is a decision literal or a top-level fact).
 *
 * \note
 * The constraint that implied a literal can have three different representations:
 * - it can be a single literal (binary clause constraint)
 * - it can be two literals (ternary clause constraint)
 * - it can be a pointer to a constraint (generic constraint)
 * .
 *
 * \par Implementation:
 *
 * The class stores all three representations in one tagged 64-bit integer, i.e.
 * from the 64-bits the 2 LSBs encode the type stored:
 *  - 00: Pointer to constraint
 *  - 01: ternary constraint (i.e. two literals stored in the remaining 62 bits).
 *  - 10: binary constraint (i.e. one literal stored in the highest 31 bits)
 *  .
 */
class Antecedent {
public:
	enum Type { Generic = 0, Ternary = 1, Binary = 2};
	//! Creates a null Antecedent.
	/*!
	 * \post: isNull() == true && type == Generic
	 */
	Antecedent() : data_(0) {}

	//! Creates an Antecedent from the literal p.
	/*!
	 * \post: type() == Binary && firstLiteral() == p
	 */
	Antecedent(const Literal& p) {
		// first lit is stored in high dword
		data_ = (((uint64)p.id()) << 33) + Binary;
		assert(type() == Binary && firstLiteral() == p);
	}

	//! Creates an Antecedent from the literals p and q.
	/*!
	 * \post type() == Ternary && firstLiteral() == p && secondLiteral() == q
	 */
	Antecedent(const Literal& p, const Literal& q) {
		// first lit is stored in high dword
		// second lit is stored in low dword
		data_ = (((uint64)p.id()) << 33) + (((uint64)q.id()) << 2) + Ternary;
		assert(type() == Ternary && firstLiteral() == p && secondLiteral() == q);
	}

	//! Creates an Antecedent from the Constraint con.
	/*!
	 * \post type() == Generic && constraint() == con
	 */
	Antecedent(Constraint* con) : data_((uintp)con) {
		static_assert(sizeof(Constraint*) <= sizeof(uint64), "unsupported pointer size");
		assert(type() == Generic && constraint() == con);
	}

	//! Returns true if this antecedent does not refer to any constraint.
	bool isNull() const { return data_ == 0; }
	//! Returns the antecedent's type.
	Type type()   const { return Type( data_ & 3 ); }
	//! Returns true if the antecedent is a learnt nogood.
	bool learnt() const { return data_ && (data_ & 3u) == 0 && constraint()->type() != Constraint_t::Static; }

	//! Extracts the constraint-pointer stored in this object.
	/*!
	 * \pre type() == Generic
	 */
	Constraint* constraint() const {
		assert(type() == Generic);
		return (Constraint*)(uintp)data_;
	}

	//! Extracts the first literal stored in this object.
	/*!
	 * \pre type() != Generic
	 */
	Literal firstLiteral() const {
		assert(type() != Generic);
		return Literal::fromId(static_cast(data_ >> 33));
	}

	//! Extracts the second literal stored in this object.
	/*!
	 * \pre type() == Ternary
	 */
	Literal secondLiteral() const {
		assert(type() == Ternary);
		return Literal::fromId( static_cast(data_>>1) >> 1 );
	}

	//! Returns the reason for p.
	/*!
	 * \pre !isNull()
	 */
	void reason(Solver& s, Literal p, LitVec& lits) const {
		assert(!isNull());
		Type t = type();
		if (t == Generic) {
			constraint()->reason(s, p, lits);
			return;
		}
		lits.push_back(firstLiteral());
		if (t == Ternary) { lits.push_back(secondLiteral()); }
	}
	template 
	bool minimize(S& s, Literal p, CCMinRecursive* rec) const {
		assert(!isNull());
		Type t = type();
		if (t == Generic) {
			return constraint()->minimize(s, p, rec);
		}
		return s.ccMinimize(firstLiteral(), rec) && (t != Ternary || s.ccMinimize(secondLiteral(), rec));
	}

	//! Returns true iff the antecedent refers to the constraint con.
	bool operator==(const Constraint* con) const {
		return static_cast(data_) == reinterpret_cast(con);
	}
	uint64  asUint() const { return data_; }
	uint64& asUint()       { return data_; }
private:
	uint64 data_;
};

enum { LBD_MAX = 127u, ACT_MAX = (1u << 20) - 1 };
//! Type storing a constraint's activity.
struct ConstraintScore {
	typedef ConstraintScore Score;
	enum { LBD_SHIFT = 20, BMP_BIT = 27, BITS_USED = 28, LBD_MASK = LBD_MAX<> LBD_SHIFT) : uint32(LBD_MAX); }
	bool   hasLbd()   const  { return (rep & LBD_MASK) != 0; }
	bool   bumped()   const  { return test_bit(rep, BMP_BIT); }
	void   bumpActivity()    { if (activity() < uint32(ACT_MAX)) ++rep; }
	void   bumpLbd(uint32 x) { if (x < lbd()) { rep &= ~uint32(LBD_MASK); rep |= (x << LBD_SHIFT) | bit_mask(BMP_BIT); } }
	void   clearBumped()     { store_clear_bit(rep, BMP_BIT); }
	void   reduce()          { clearBumped(); if (uint32 a = activity()) { rep &= ~uint32(ACT_MAX); rep |= (a>>1); } }
	void   assign(Score o)   { rep &= ~uint32(BITS_MASK); rep |= (o.rep & BITS_MASK); }
	uint32 rep;
};
inline ConstraintScore makeScore(uint32 act = 0, uint32 lbd = 0) {
	ConstraintScore sc = {0}; sc.reset(act, lbd);
	return sc;
}
//! Type storing meta information about a constraint.
class ConstraintInfo : private ConstraintScore {
public:
	typedef ConstraintInfo  Info;
	typedef ConstraintScore Score;
	ConstraintInfo(ConstraintType t = Constraint_t::Static) {
		static_assert(ConstraintScore::BITS_USED <= 28, "invalid score");
		rep = uint32(t) << TYPE_SHIFT;
	}
	using ConstraintScore::lbd;
	using ConstraintScore::activity;
	ConstraintType type()     const { return static_cast( (rep & uint32(TYPE_MASK)) >> TYPE_SHIFT ); }
	bool           tagged()   const { return test_bit(rep, TAG_BIT); }
	bool           aux()      const { return tagged() || test_bit(rep, AUX_BIT); }
	bool           learnt()   const { return type() != Constraint_t::Static; }
	const Score&   score()    const { return *this; }
	Score&         score()          { return *this; }

	Info& setType(ConstraintType t) { rep &= ~uint32(TYPE_MASK); rep |= (uint32(t) << TYPE_SHIFT); return *this; }
	Info& setScore(Score sc)        { assign(sc); return *this; }
	Info& setActivity(uint32 a)     { assign(makeScore(a, lbd())); return *this; }
	Info& setLbd(uint32 lbd)        { assign(makeScore(activity(), lbd)); return *this; }
	Info& setTagged(bool b)         { if (test_bit(rep, TAG_BIT) != b) store_toggle_bit(rep, TAG_BIT); return *this; }
	Info& setAux(bool b)            { if (test_bit(rep, AUX_BIT) != b) store_toggle_bit(rep, AUX_BIT); return *this; }
private:
	enum { TYPE_SHIFT = 28, AUX_BIT = 30, TAG_BIT = 31, TYPE_MASK = (3u << TYPE_SHIFT) };
};
//@}

/**
* \defgroup shared_con Shared
* \brief %Constraint data that can safely be shared between solvers.
* \ingroup constraint
*/

}
#endif
clasp-3.2.2/libclasp/clasp/dependency_graph.h000066400000000000000000000445371304134206100211720ustar00rootroot00000000000000//
// Copyright (c) 2010-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_DEPENDENCY_GRAPH_H_INCLUDED
#define CLASP_DEPENDENCY_GRAPH_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
#include 
namespace Clasp {
class Solver;
class SharedContext;
struct SolverStats;
//! Event type used to signal a (partial) check in disjunctive solving.
struct SolveTestEvent : SolveEvent {
	SolveTestEvent(const Solver& s, uint32 hcc, bool partial);
	int    result;     //!< -1: before test, 0: unstable, 1: stable
	uint32 hcc     :31;//!< hcc under test
	uint32 partial : 1;//!< partial test?
	uint64 confDelta;  //!< conflicts before test
	uint64 choiceDelta;//!< choices before test
	double time;       //!< time for test

	uint64 conflicts() const;
	uint64 choices()   const;
};
struct LoopReason_t {
	enum Type { Explicit = 0u, Implicit = 1u, };
};
typedef LoopReason_t::Type LoopType;

namespace Asp {
//! (Positive) Body-Atom-Dependency Graph.
/*!
 * \ingroup shared_con
 *
 * Represents the PBADG of a logic program. Once initialized, the
 * PBDAG is static and read-only and thus can be shared between multiple solvers.
 *
 * \note Initialization is *not* thread-safe, i.e. must be done only once by one thread.
 */
class PrgDepGraph {
public:
	enum NonHcfMapType {
		map_old = 0,
		map_new = 1
	};
	explicit PrgDepGraph(NonHcfMapType m = map_old);
	~PrgDepGraph();
	typedef uint32 NodeId;
	//! Type for storing a non head-cycle-free component of a disjunctive program.
	class NonHcfComponent {
	public:
		explicit NonHcfComponent(uint32 id, const PrgDepGraph& dep, SharedContext& generator, Configuration* c, uint32 scc, const VarVec& atoms, const VarVec& bodies);
		~NonHcfComponent();
		void assumptionsFromAssignment(const Solver& generator, LitVec& assumptionsOut) const;
		bool test(const Solver& generator, const LitVec& assumptions, VarVec& unfoundedOut)  const;
		bool simplify(const Solver& generator) const;
		const SharedContext& ctx() const { return *prg_; }
		void update(const SharedContext& generator);
		uint32 id()  const { return id_; }
		uint32 scc() const { return scc_; }
	private:
		friend class PrgDepGraph;
		NonHcfComponent(const NonHcfComponent&);
		NonHcfComponent& operator=(const NonHcfComponent&);
		class ComponentMap;
		const PrgDepGraph* dep_;
		SharedContext*     prg_;
		ComponentMap*      comp_;
		uint32             id_;
		uint32             scc_;
	};
	//! A class for storing statistics on checking of non head-cycle-free components.
	class NonHcfStats {
	public:
		NonHcfStats(PrgDepGraph& g, uint32 level, bool inc);
		~NonHcfStats();
		void accept(StatsVisitor& out, bool final) const;
		void startStep(uint32 statsLevel);
		void endStep();
		void addTo(StatsMap& problem, StatsMap& solving, StatsMap* accu) const;
	private:
		friend class PrgDepGraph;
		void addHcc(const NonHcfComponent&);
		void removeHcc(const NonHcfComponent&);
		NonHcfStats(const NonHcfStats&);
		NonHcfStats& operator=(const NonHcfStats&);
		struct Data;
		PrgDepGraph* graph_;
		Data*        data_;
	};
	typedef PodVector::type ComponentVec;
	typedef ComponentVec::const_iterator NonHcfIter;
	//! Base type for nodes.
	struct Node {
		Node(Literal l = Literal(0, false), uint32 sc = PrgNode::noScc)
			: lit(l), scc(sc), data(0), adj_(0), sep_(0) {}
		Literal lit;       // literal of this node
		uint32  scc   : 28;// scc of this node
		uint32  data  :  4;// additional atom/body data
		NodeId* adj_;      // list of adjacent nodes
		NodeId* sep_;      // separates successor/predecessor nodes
	};
	//! An atom node.
	/*!
	 * The PBDAG stores a node of type AtomNode for each non-trivially connected atom.
	 * The predecessors of an AtomNode are the bodies that define the atom. Its successors
	 * are those bodies from the same SCC that contain the atom positively.
	 */
	struct AtomNode : public Node {
		enum Property { property_in_choice = 1u, property_in_disj = 2u, property_in_ext = 4u, property_in_non_hcf = 8u };
		AtomNode() {}
		void  set(Property p)         { data |= (uint32)p; }
		void  setProperties(uint32 f) { assert(f < 8); data |= f; }
		//! Contained in the head of a choice rule?
		bool          inChoice()     const { return (data & property_in_choice) != 0; }
		//! Contained in the head of a non-hcf disjunctive rule?
		bool          inDisjunctive()const { return (data & property_in_disj) != 0; }
		//! Contained in an extended body?
		bool          inExtended()   const { return (data& property_in_ext) != 0; }
		//! Contained in a non-hcf SCC?
		bool          inNonHcf()     const { return (data & property_in_non_hcf) != 0; }
		//! Bodies (i.e. predecessors): bodies from other SCCs precede those from same SCC.
		const NodeId* bodies_begin() const { return adj_; }
		const NodeId* bodies_end()   const { return sep_; }
		NodeId        body(uint32 i) const { return bodies_begin()[i]; }
		//! Successors from same SCC [B1,...Bn, idMax].
		/*!
		 * \note If extended() is true, the atom is adjacent to some extended body.
		 * In that case, the returned list looks like this:
		 * [Bn1, ..., Bnj, idMax, Bext1, pos1, ..., Bextn, posn, idMax], where
		 * each Bni is a normal body, each Bexti is an extended body and posi is the
		 * position of this atom in Bexti.
		 */
		const NodeId* succs()        const { return sep_; }
		//! Calls the given function object p once for each body containing this atom.
		template 
		void visitSuccessors(const P& p) const {
			const NodeId* s = succs();
			for (; *s != idMax; ++s) { p(*s); }
			if (inExtended()) {
				for (++s; *s != idMax; s += 2) { p(*s, *(s+1)); }
			}
		}
	};
	enum { sentinel_atom = 0u };

	//! A body node.
	/*!
	 * The PBDAG stores a node of type BodyNode for each body that defines
	 * a non-trivially connected atom.
	 * The predecessors of a BodyNode are the body's subgoals.
	 * Its successors are the heads that are defined by the body.
	 * \note Normal bodies only store the positive subgoals from the same SCC, while
	 * extended rule bodies store all subgoals. In the latter case, the positive subgoals from
	 * the same SCC are stored as AtomNodes. All other subgoals are stored as literals.
	 */
	struct BodyNode : public Node {
		enum Flag { flag_has_bound = 1u, flag_has_weights = 2u, flag_has_delta = 4u, flag_seen = 8u };
		explicit BodyNode(PrgBody* b, uint32 scc) : Node(b->literal(), scc) {
			if (scc == PrgNode::noScc || b->type() == Body_t::Normal) {
				data = 0;
			}
			else if (b->type() == Body_t::Count){ data = flag_has_bound; }
			else if (b->type() == Body_t::Sum)  { data = flag_has_bound | flag_has_weights;   }
			else                                { assert("UNKNOWN BODY TYPE!\n"); }
		}
		bool seen() const { return (data & flag_seen) != 0; }
		void seen(bool b) { if (b) data |= flag_seen; else data &= ~uint32(flag_seen); }

		//! Heads (i.e. successors): atoms from same SCC precede those from other SCCs.
		/*!
		 * \note Disjunctive heads are stored in flattened atom-lists, where the
		 *       lists are terminated on both ends with the special sentinal atom 0.
		 *       E.g. given
		 *        x :- B.
		 *        y :- B.
		 *       a|b:- B.
		 *       a|c:- B.
		 *       would result in: [x,y,0,a,b,0,0,a,c,0]
		 */
		const NodeId* heads_begin() const { return adj_; }
		const NodeId* heads_end()   const { return sep_ - extended(); }
		//! Any disjunctive heads?
		bool          delta()       const { return (data & flag_has_delta) != 0; }
		//! Predecessors from same SCC [a1,...an, idMax].
		/*!
		 * \note If extended() is true, the body stores all its subgoals and preds looks
		 * like this: [a1, [w1], ..., aj, [wj], idMax, l1, [w1], ..., lk, [wk], idMax], where
		 * each ai is an atom from the same SCC, each li is a literal of a subgoal from
		 * other SCCs and wi is an optional weight (only for weight rules).
		 */
		const NodeId* preds()       const { assert(scc != PrgNode::noScc); return sep_; }
		//! Returns idx of atomId in preds.
		uint32        get_pred_idx(NodeId atomId) const {
			const uint32 inc = pred_inc();
			uint32 idx = 0;
			for (const NodeId* x = preds(); *x != idMax; x += inc, ++idx) {
				if (*x == atomId) return idx;
			}
			return idMax;
		}
		NodeId        get_pred(uint32 idx) const { return *(preds() + (idx*pred_inc())); }
		//! Increment to jump from one pred to the next.
		uint32        pred_inc()           const { return 1 + sum(); }
		//! Weight of ith subgoal.
		/*!
		 * \pre i in [0, num_preds())
		 */
		uint32        pred_weight(uint32 i, bool ext) const {
			return !sum()
				? 1
				: *(preds() + (i*pred_inc()) + (1+uint32(ext)));
		}
		//! Number of predecessors (counting external subgoals).
		uint32        num_preds() const {
			if (scc == PrgNode::noScc) return 0;
			uint32 p = 0;
			const NodeId*  x = preds();
			const uint32 inc = pred_inc();
			for (; *x != idMax; x += inc) { ++p; }
			x += extended();
			for (; *x != idMax; x += inc) { ++p; }
			return p;
		}
		//! Is the body an extended body?
		bool          extended()const { return (data & flag_has_bound) != 0u; }
		//! Is the body a sum body?
		bool          sum()     const { return (data & flag_has_weights) != 0u; }
		//! Bound of extended body.
		weight_t      ext_bound() const { return sep_[-1]; }
	};
	//! Adds SCCs to the graph.
	/*!
	 * \param prg       The logic program for which the dependency graph is to be created.
	 * \param sccAtoms  Atoms of the logic program that are strongly connected.
	 * \param nonHcfs   Sorted list of non-hcf sccs
	 */
	void addSccs(LogicProgram& prg, const AtomList& sccAtoms, const NonHcfSet& nonHcfs);

	//! Removes inactive non-hcfs.
	void simplify(const Solver& s);
	//! Number of atoms in graph.
	uint32 numAtoms() const { return (uint32)atoms_.size(); }
	//! Number of bodies in graph.
	uint32 numBodies()const { return (uint32)bodies_.size(); }
	//! Sum of atoms and bodies.
	uint32 nodes()    const { return numAtoms()+numBodies(); }

	//! Returns AtomNode of atom with given id.
	const AtomNode& getAtom(NodeId atomId) const {
		assert(atomId < atoms_.size());
		return atoms_[atomId];
	}
	NodeId id(const AtomNode& n) const { return static_cast(&n - &atoms_[0]); }
	//! Returns BodyNode of body with given id.
	const BodyNode& getBody(NodeId bodyId) const {
		assert(bodyId < bodies_.size());
		return bodies_[bodyId];
	}
	//! Calls the given function object p once for each body-literal.
	template 
	void visitBodyLiterals(const BodyNode& n, const P& p) const {
		const NodeId*  x = n.preds();
		const uint32 inc = n.pred_inc();
		uint32         i = 0;
		for (; *x != idMax; x += inc, ++i) { p(getAtom(*x).lit, i, false); }
		x += n.extended();
		for (; *x != idMax; x += inc, ++i) { p(Literal::fromRep(*x), i, true); }
	}
	NonHcfIter   nonHcfBegin() const { return components_.begin(); }
	NonHcfIter   nonHcfEnd()   const { return components_.end(); }
	uint32       numNonHcfs()  const { return (uint32)components_.size(); }
	NonHcfStats* nonHcfStats() const { return stats_; }
	NonHcfStats* enableNonHcfStats(uint32 level, bool incremental);
private:
	typedef PodVector::type AtomVec;
	typedef PodVector::type BodyVec;
	PrgDepGraph(const PrgDepGraph&);
	PrgDepGraph& operator=(const PrgDepGraph&);
	inline bool    relevantPrgAtom(const Solver& s, PrgAtom* a) const;
	inline bool    relevantPrgBody(const Solver& s, PrgBody* b) const;
	NonHcfMapType  nonHcfMapType() const { return static_cast(mapType_); }
	NodeId         createBody(PrgBody* b, uint32 bScc);
	NodeId         createAtom(Literal lit, uint32 aScc);
	NodeId         addBody(const LogicProgram& prg, PrgBody*);
	NodeId         addDisj(const LogicProgram& prg, PrgDisj*);
	uint32         addHeads(const LogicProgram& prg, PrgBody*, VarVec& atoms) const;
	uint32         getAtoms(const LogicProgram& prg, PrgDisj*, VarVec& atoms) const;
	void           addPreds(const LogicProgram& prg, PrgBody*, uint32 bScc, VarVec& preds) const;
	void           initBody(uint32 id, const VarVec& preds, const VarVec& atHeads);
	void           initAtom(uint32 id, uint32 prop, const VarVec& adj, uint32 preds);
	void           addNonHcf(uint32 id, SharedContext& ctx, Configuration* c, uint32 scc);
	AtomVec        atoms_;
	BodyVec        bodies_;
	ComponentVec   components_;
	NonHcfStats*   stats_;
	uint32         seenComponents_ : 31;
	uint32         mapType_        :  1;
};
} // namespace Asp

//! External dependency graph.
/*!
 * \ingroup shared_con
 *
 * Represents external dependencies explicitly given by the user.
 * For example, via aspif edge directives or the graph block in extended dimacs format.
 * \note Initialization is *not* thread-safe, i.e. must be done only once by one thread.
 */
class ExtDepGraph {
public:
	struct Arc {
		Literal lit;
		uint32  node[2];
		uint32 tail() const { return node[0]; }
		uint32 head() const { return node[1]; }
		static Arc create(Literal x, uint32 nodeX, uint32 nodeY) { Arc a = {x, {nodeX, nodeY}}; return a; }
	};
	struct Inv {
		uint32  tail() const { return rep >> 1; }
		Literal lit;
		uint32  rep;
	};
	template 
	struct CmpArc {
		bool operator()(const Arc& lhs, uint32 n) const { return lhs.node[x] < n; }
		bool operator()(uint32 n, const Arc& rhs) const { return n < rhs.node[x]; }
		bool operator()(const Arc& lhs, const Arc& rhs) const {
			return lhs.node[x] < rhs.node[x]
			|| (lhs.node[x] == rhs.node[x]  && lhs.node[1-x] < rhs.node[1-x]);
		}
	};
	explicit ExtDepGraph(uint32 numNodeGuess = 0);
	~ExtDepGraph();
	void   addEdge(Literal lit, uint32 startNode, uint32 endNode);
	void   update();
	uint32 finalize(SharedContext& ctx);
	bool   frozen() const;
	uint64 attach(Solver& s, Constraint& p, uint64 genId);
	void   detach(Solver* s, Constraint& p);

	const Arc& arc(uint32 id)       const { return fwdArcs_[id]; }
	const Arc* fwdBegin(uint32 n)   const {
		uint32 X = nodes_[n].fwdOff;
		return validOff(X) ? &fwdArcs_[X] : 0;
	}
	const Arc* fwdNext(const Arc* a)const { assert(a); return a[0].node[0] == a[1].node[0] ? ++a : 0; }
	const Inv* invBegin(uint32 n)   const {
		uint32 X = nodes_[n].invOff;
		return validOff(X) ? &invArcs_[X] : 0;
	}
	const Inv* invNext(const Inv* a)const { assert(a); return (a->rep & 1u) == 1u ? ++a : 0; }
	uint32     nodes()              const { return maxNode_; }
	uint32     edges()              const { return comEdge_; }
	bool       validNode(uint32 n)  const { return n < maxNode_; }
private:
	ExtDepGraph(const ExtDepGraph&);
	ExtDepGraph& operator=(const ExtDepGraph&);
	struct Node {
		uint32 fwdOff;
		uint32 invOff;
	};
	typedef PodVector::type  ArcVec;
	typedef PodVector::type  InvVec;
	typedef PodVector::type NodeVec;
	bool validOff(uint32 n) const {
		return n != UINT32_MAX;
	}
	ArcVec  fwdArcs_; // arcs ordered by node id
	InvVec  invArcs_; // inverse arcs ordered by node id
	NodeVec nodes_;   // data for the nodes of this graph
	uint32  maxNode_; // nodes have ids in the range [0, maxNode_)
	uint32  comEdge_; // number of edges committed
	uint32  genCnt_;  // generation count (for incremental updates)
};

//! Acyclicity checker that operates on a ExtDepGraph.
/*!
 * \ingroup propagator
 * \see M. Gebser, T. Janhunen, and J. Rintanen: "SAT Modulo Graphs: Acyclicity"
 */
class AcyclicityCheck : public PostPropagator {
public:
	enum Strategy {
		prop_full     = 0, // forward and backward check with clause generation
		prop_full_imp = 1, // forward and backward check without clause generation
		prop_fwd      = 2, // only forward check
	};
	enum { PRIO = PostPropagator::priority_reserved_ufs + 1 };
	typedef ExtDepGraph DependencyGraph;
	explicit AcyclicityCheck(DependencyGraph* graph);
	~AcyclicityCheck();
	void   setStrategy(Strategy p);
	void   setStrategy(const SolverParams& opts);
	// base interface
	uint32 priority() const { return uint32(PRIO); }
	bool   init(Solver&);
	void   reset();
	bool   propagateFixpoint(Solver& s, PostPropagator* ctx);
	bool   isModel(Solver& s);
	bool   valid(Solver& s);
	void   destroy(Solver* s, bool detach);
private:
	AcyclicityCheck(const AcyclicityCheck&);
	AcyclicityCheck& operator=(const AcyclicityCheck&);
	struct Parent {
		static Parent create(Literal x, uint32 n) { Parent p = {x, n}; return p; }
		Literal lit;
		uint32  node;
	};
	enum { config_bit = 2 };
	struct ReasonStore;
	typedef DependencyGraph::Arc    Arc;
	typedef DependencyGraph::Inv     Inv;
	typedef PodQueue            EdgeQueue;
	typedef PodVector::type  TagVec;
	typedef PodVector::type  ParentVec;
	bool   dfsForward(Solver& s,  const Arc& e);
	bool   dfsBackward(Solver& s, const Arc& e);
	void   setParent(Var node, const Parent& p){ parent_[node] = p; }
	void   pushVisit(Var node, uint32 tv)      { nStack_.push_back(node); tags_[node] = tv; }
	bool   visited(Var node, uint32 tv) const  { return tags_[node] == tv; }
	uint32 startSearch();
	void   addClauseLit(Solver& s, Literal p);
	void   setReason(Literal p, LitVec::const_iterator first, LitVec::const_iterator end);
	// -------------------------------------------------------------------------------------------
	// constraint interface
	PropResult propagate(Solver&, Literal, uint32& eId) {
		todo_.push(graph_->arc(eId));
		return PropResult(true, true);
	}
	void reason(Solver& s, Literal, LitVec&);
	Strategy strategy() const { return static_cast(strat_ & 3u); }
	DependencyGraph* graph_;  // my graph
	Solver*          solver_; // my solver
	ReasonStore*     nogoods_;// stores at most one reason per literal
	uint32           strat_;  // active propagation strategy
	uint32           tagCnt_; // generation counter for searches
	EdgeQueue        todo_;   // edges that recently became enabled
	TagVec           tags_;   // tag for each node
	ParentVec        parent_; // parents for each node
	VarVec           nStack_; // node stack for df-search
	LitVec           reason_; // reason for conflict/implication
	uint64           genId_;  // generation identifier
};

}
#endif

clasp-3.2.2/libclasp/clasp/enumerator.h000066400000000000000000000335331304134206100200460ustar00rootroot00000000000000//
// Copyright (c) 2006-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_ENUMERATOR_H_INCLUDED
#define CLASP_ENUMERATOR_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
#include 
#include 

namespace Clasp {
class Solver;
class SharedContext;
class Enumerator;
class EnumerationConstraint;

//! Type for storing a model.
struct Model {
	enum Type { Sat = 0u, Brave = 1u, Cautious = 2u, User = 4u };
	enum      { cons_mask = 3u, est_pos_mask= 4u, est_neg_mask   = 8u };
	static uint8 estMask(Literal p)  { return est_pos_mask << ((int)p.sign()); }
	bool     hasVar(Var v)     const { return values && v < values->size(); }
	//! True if this model stores current (cautious/brave) consequences.
	bool     consequences()    const { return (type & cons_mask) != 0; }
	//! For sat models, value of v in model. Otherwise, undefined.
	ValueRep value(Var v)      const { assert(hasVar(v)); return (*values)[v] & 3u; }
	//! True if p is true in model or part of current consequences.
	bool     isTrue(Literal p) const { return (value(p.var()) & trueValue(p)) != 0; }
	//! True if p is part of a definite answer.
	bool     isDef(Literal p) const  { return isTrue(p) && (def || ((type & Cautious) == 0u) || !isEst(p));  }
	//! True if p is part of the current estimate of consequences.
	bool     isEst(Literal p) const  { assert(hasVar(p.var())); return ((*values)[p.var()] & estMask(p)) != 0; }
	void reset();
	uint64            num;    // running number of this model
	const Enumerator* ctx;    // ctx in which model was found
	const ValueVec*   values; // variable assignment or consequences
	const SumVec*     costs;  // associated costs (or 0)
	uint32            sId :16;// id of solver that found the model
	uint32            type:12;// type of model
	uint32            opt : 1;// whether the model is optimal w.r.t costs (0: unknown)
	uint32            def : 1;// whether the model is definite w.r.t consequences (0: unknown)
	uint32            sym : 1;// whether symmetric models are possible
	uint32            up  : 1;// whether the model was updated on last unsat
};

/**
 * \defgroup enumerator Solving
 * \brief Enumerators and solve algorithms.
 */
//@{

//! Options for configuring enumeration.
struct EnumOptions {
	typedef MinimizeMode OptMode;
	enum EnumType { enum_auto = 0, enum_bt  = 1, enum_record  = 2, enum_dom_record = 3, enum_consequences = 4, enum_brave = 5, enum_cautious = 6, enum_query = 7, enum_user = 8 };
	EnumOptions() : numModels(-1), enumMode(enum_auto), optMode(MinimizeMode_t::optimize), project(0), maxSat(false) {}
	static Enumerator* createModelEnumerator(const EnumOptions& opts);
	static Enumerator* createConsEnumerator(const EnumOptions& opts);
	static Enumerator* nullEnumerator();
	static Enumerator* createEnumerator(const EnumOptions& opts);
	bool     consequences() const { return (enumMode & enum_consequences) != 0; }
	bool     models()       const { return (enumMode < enum_consequences); }
	bool     optimize()     const { return ((optMode  & MinimizeMode_t::optimize) != 0); }
	int64    numModels; /*!< Number of models to compute. */
	EnumType enumMode;  /*!< Enumeration type to use.     */
	OptMode  optMode;   /*!< Optimization mode to use.    */
	uint32   project;   /*!< Options for projection.      */
	SumVec   optBound;  /*!< Initial bound for optimize statements. */
	bool     maxSat;    /*!< Treat DIMACS input as MaxSat. */
};
const char* modelType(const Model& m);


//! Interface for supporting enumeration of models.
/*!
 * Enumerators are global w.r.t a solve algorithm. That is,
 * even if the solve algorithm itself uses a parallel search, there
 * shall be only one enumerator and it is the user's responsibility
 * to protect the enumerator with appropriate locking.
 *
 * Concrete enumerators must implement a function for preparing a problem for enumeration
 * and an EnumerationConstraint to be added to each solver attached to the problem.
 * It is then the job of the actual solve algorithm to commit models to the enumerator
 * and to integrate new information into attached solvers via appropriate calls to
 * Enumerator::update().
 */
class Enumerator {
public:
	typedef EnumerationConstraint*       ConPtr;
	typedef const EnumerationConstraint* ConPtrConst;
	typedef const SharedMinimizeData*    Minimizer;
	typedef EnumOptions::OptMode         OptMode;
	class   ThreadQueue;
	explicit Enumerator();
	virtual ~Enumerator();

	void   reset();

	//! Prepares the problem for enumeration.
	/*!
	 * The function shall be called once before search is started and before SharedContext::endInit()
	 * was called. It freezes enumeration-related variables and adds a suitable enumeration constraint
	 * to the master solver.
	 *
	 * \pre The problem is not yet frozen, i.e. SharedContext::endInit() was not yet called.
	 * \param problem The problem on which this enumerator should work.
	 * \param opt     Minimization mode to apply during enumeration.
	 * \param limit   Optional hint on max number of models to compute.
	 *
	 * \note In the incremental setting, init() must be called once for each incremental step.
	 */
	int    init(SharedContext& problem, OptMode opt = MinimizeMode_t::optimize, int limit = 0);

	//! Prepares the given solver for enumeration under the given path.
	/*!
	 * The function shall be called once before solving is started. It pushes the
	 * given path to the solver by calling Solver::pushRoot() and prepares s for
	 * enumeration/optimization.
	 * \return true if path was added.
	 */
	bool   start(Solver& s, const LitVec& path = LitVec(), bool disjointPath = false)  const;

	//! Updates the given solver with enumeration-related information.
	/*!
	 * The function is used to integrate enumeration-related information,
	 * like minimization bounds or previously committed models, into the search space of s.
	 * It shall be called after each commit.
	 *
	 * \param s The solver to update.
	 * \note The function is concurrency-safe, i.e. can be called
	 *       concurrently by different solvers.
	 */
	bool   update(Solver& s)  const;

	/*!
	 * \name Commit functions
	 * Functions for committing enumeration-related information to the enumerator.
	 * \note The functions in this group are *not* concurrency-safe, i.e. in a parallel search
	 *       at most one solver shall call a commit function at any one time.
	 */
	//@{

	//! Commits the model stored in the given solver.
	/*!
	 * If the model is valid and unique, the function returns true and the
	 * model can be accessed via a call to Enumerator::lastModel().
	 * Otherwise, the function returns false.
	 * In either case, Enumerator::update(s) shall be called
	 * in order to continue search for further models.
	 *
	 * \pre The solver's assignment is total.
	 */
	bool   commitModel(Solver& s);
	//! Expands the next symmetric model if any.
	bool   commitSymmetric(Solver& s);
	//! Commits an unsatisfiable path stored in the given solver.
	/*!
	 * The return value determines how search should proceed.
	 * If true is returned, the enumerator has relaxed an enumeration constraint
	 * and search may continue after a call to Enumerator::update(s).
	 * Otherwise, the search shall be stopped.
	 */
	bool   commitUnsat(Solver& s);
	//! Commits the given clause to this enumerator.
	bool   commitClause(const LitVec& clause) const;
	//! Marks current enumeration phase as completed.
	/*!
	 * If the enumerator was initialized with a minimization constraint and
	 * optimization mode MinimizeMode_t::enumOpt, the optimal bound is committed,
	 * the enumerator is prepared for enumerating optimal models, and the function
	 * returns false. Otherwise, the function returns true and search shall be stopped.
	 */
	bool   commitComplete();
	//! Commits the state stored in the given solver.
	/*!
	 * Calls commitModel() or commitUnsat() depending on the state of s.
	 * The function returns value_true, to signal that s stores a valid and
	 * unique model, value_false to signal that search shall be stopped, and
	 * value_free otherwise.
	 * \see commitModel()
	 * \see commitUnsat()
	 */
	uint8  commit(Solver& s);
	//@}

	//! Removes from s the path that was passed to start() and any active (minimization) bound.
	void   end(Solver& s) const;
	//! Returns the number of models enumerated so far.
	uint64 enumerated()   const { return model_.num; }
	//! Returns the last model enumerated.
	/*!
	 * \note If enumerated() is equal to 0, the returned object is in an indeterminate state.
	 */
	const Model& lastModel()        const { return model_; }
	//! Returns whether optimization is active.
	bool         optimize()         const { return mini_ && mini_->mode() != MinimizeMode_t::enumerate && model_.opt == 0; }
	//! Returns whether computed models are still tentative.
	bool         tentative()        const { return mini_ && mini_->mode() == MinimizeMode_t::enumOpt && model_.opt == 0; }
	//! Returns the active minimization constraint if any.
	Minimizer    minimizer()        const { return mini_; }
	//! Returns the type of models this enumerator computes.
	virtual int  modelType()        const { return Model::Sat; }
	enum UnsatType {
		unsat_stop = 0u, /*!< First unsat stops search - commitUnsat() always return false.     */
		unsat_cont = 1u, /*!< Unsat may be tentative - commitUnsat() may return true.           */
		unsat_sync = 3u, /*!< Similar to unsat_cont but additionally requires synchronization among threads. */
	};
	//! Returns whether unsat may be tentative and/or requires synchronization.
	virtual int  unsatType()        const;
	//! Returns whether or not this enumerator supports full restarts once a model was found.
	virtual bool supportsRestarts() const { return true; }
	//! Returns whether or not this enumerator supports parallel search.
	virtual bool supportsParallel() const { return true; }
	//! Returns whether or not this enumerator supports splitting-based search.
	virtual bool supportsSplitting(const SharedContext& problem) const;
	//! Returns whether this enumerator requires exhaustive search to produce a definite answer.
	virtual bool exhaustive()       const { return mini_ && mini_->mode() != MinimizeMode_t::enumerate; }
	//! Sets whether the search path stored in s is disjoint from all others.
	void         setDisjoint(Solver& s, bool b) const;
	//! Sets whether symmetric should be ignored.
	void         setIgnoreSymmetric(bool b);
	ConPtr       constraint(const Solver& s) const;
protected:
	//! Shall prepare the enumerator and freeze any enumeration-related variable.
	/*!
	 * \return A prototypical enumeration constraint to be used in a solver.
	 */
	virtual ConPtr doInit(SharedContext& ctx, SharedMinimizeData* min, int numModels) = 0;
	virtual void   doReset();
	Model&         model();
private:
	class SharedQueue;
	Enumerator(const Enumerator&);
	Enumerator& operator=(const Enumerator&);
	SharedMinimizeData* mini_;
	SharedQueue*        queue_;
	SumVec              costs_;
	Model               model_;
};

//! A solver-local (i.e. thread-local) constraint to support enumeration.
/*!
 * An enumeration constraint is used to extract/store enumeration-related information
 * from models.
 */
class EnumerationConstraint : public Constraint {
public:
	typedef EnumerationConstraint*   ConPtr;
	typedef MinimizeConstraint*      MinPtr;
	typedef Enumerator::ThreadQueue* QueuePtr;
	//! Returns true if search-path is disjoint from all others.
	bool     disjointPath()const { return (flags_ & flag_path_disjoint) != 0u; }
	ValueRep state()       const { return static_cast(flags_ & 3u); }
	//! Returns true if optimization is active.
	bool     optimize()    const;
	MinPtr   minimizer()   const { return mini_; }
	// Methods used by enumerator
	void init(Solver& s, SharedMinimizeData* min, QueuePtr q);
	bool start(Solver& s, const LitVec& path, bool disjoint);
	void end(Solver& s);
	bool update(Solver& s);
	void setDisjoint(bool x);
	bool integrateBound(Solver& s);
	bool integrateNogoods(Solver& s);
	bool commitModel(Enumerator& ctx, Solver& s);
	bool commitUnsat(Enumerator& ctx, Solver& s);
	void setMinimizer(MinPtr min) { mini_ = min; }
	void add(Constraint* c);
	void modelHeuristic(Solver& s);
protected:
	EnumerationConstraint();
	virtual ~EnumerationConstraint();
	// base interface
	virtual void        destroy(Solver* s, bool detach);
	virtual PropResult  propagate(Solver&, Literal, uint32&) { return PropResult(true, true); }
	virtual void        reason(Solver&, Literal, LitVec&)    {}
	virtual bool        simplify(Solver& s, bool reinit);
	virtual bool        valid(Solver& s);
	virtual Constraint* cloneAttach(Solver& s);
	// own interface
	virtual ConPtr      clone() = 0;
	virtual bool        doUpdate(Solver& s) = 0;
	virtual void        doCommitModel(Enumerator&, Solver&) {}
	virtual void        doCommitUnsat(Enumerator&, Solver&) {}
	uint32              rootLevel() const { return root_; }
private:
	enum Flag { flag_path_disjoint = 4u, flag_model_heuristic = 8u };
	enum { clear_state_mask = ~uint32(value_true|value_false) };
	typedef PodVector::type ConstraintDB;
	typedef SingleOwnerPtr QPtr;
	MinimizeConstraint* mini_;
	QPtr                queue_;
	ConstraintDB        nogoods_;
	LitVec              next_;
	uint32              flags_ : 4;
	uint32              root_  : 28;
};
//@}
}

#endif
clasp-3.2.2/libclasp/clasp/heuristics.h000066400000000000000000000401421304134206100200410ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_HEURISTICS_H_INCLUDED
#define CLASP_HEURISTICS_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

/*!
 * \file
 * \brief Defines various decision heuristics to be used in clasp.
 */

#include 
#include 
#include 
#include 
namespace Clasp {

//! Computes a moms-like score for var v.
uint32 momsScore(const Solver& s, Var v);

//! A variant of the BerkMin decision heuristic from the BerkMin Sat-Solver.
/*!
 * \ingroup heuristic
 * \see E. Goldberg, Y. Navikov: "BerkMin: a Fast and Robust Sat-Solver"
 *
 * \note
 * This version of the BerkMin heuristic varies mostly in the following points from the original BerkMin:
 *  -# it considers loop-nogoods if requested (this is the default)
 *  -# it uses a MOMS-like heuristic as long as there are no conflicts (and therefore no activities)
 *  -# it uses a MOMS-like score to break ties whenever multiple variables from an unsatisfied learnt constraint have equal activities
 *  -# it uses a lazy decaying scheme that only touches active variables
 */
class ClaspBerkmin : public DecisionHeuristic {
public:
	/*!
	 * \note Checks at most params.param candidates when searching for not yet
	 * satisfied learnt constraints. If param is 0, all candidates are checked.
	 */
	explicit ClaspBerkmin(const HeuParams& params = HeuParams());
	void setConfig(const HeuParams& params);
	void startInit(const Solver& s);
	void endInit(Solver& s);
	void newConstraint(const Solver& s, const Literal* first, LitVec::size_type size, ConstraintType t);
	void updateReason(const Solver& s, const LitVec& lits, Literal resolveLit);
	bool bump(const Solver& s, const WeightLitVec& lits, double adj);
	void undoUntil(const Solver&, LitVec::size_type);
	void updateVar(const Solver& s, Var v, uint32 n);
protected:
	Literal doSelect(Solver& s);
private:
	Literal selectLiteral(Solver& s, Var v, bool vsids) const;
	Literal selectRange(Solver& s, const Literal* first, const Literal* last);
	bool    initHuang() const { return order_.score[0].occ == 1; }
	void    initHuang(bool b) { order_.score[0].occ = b; }
	bool    hasActivities() const { return order_.score[0].act != 0; }
	void    hasActivities(bool b) { order_.score[0].act = b; }
	Var  getMostActiveFreeVar(const Solver& s);
	Var  getTopMoms(const Solver& s);
	bool hasTopUnsat(Solver& s);
	// Gathers heuristic information for one variable v.
	struct HScore {
		HScore(uint32 d = 0) :  occ(0), act(0), dec(uint16(d)) {}
		void incAct(uint32 gd, bool h, bool sign) {
			occ += int(h) * (1 - (2*int(sign)));
			decay(gd, h);
			++act;
		}
		void incOcc(bool sign) { occ += 1 - (2*int(sign)); }
		uint32 decay(uint32 gd, bool h) {
			if (uint32 x = (gd-dec)) {
				// NOTE: shifts might overflow, i.e.
				// activity is actually shifted by x%32.
				// We deliberately ignore this "logical inaccuracy"
				// and treat it as random noise ;)
				act >>= x;
				dec   = uint16(gd);
				occ  /= (1<<(x*int(h)));
			}
			return act;
		}
		int32  occ;
		uint16 act;
		uint16 dec;
	};
	typedef PodVector::type   Scores;
	typedef VarVec::iterator Pos;

	struct Order {
		explicit Order() : decay(0), huang(false), resScore(3u) {}
		struct Compare {
			explicit Compare(Order* o) : self(o) {}
			bool operator()(Var v1, Var v2) const {
				return self->decayedScore(v1) > self->decayedScore(v2)
					|| (self->score[v1].act == self->score[v2].act && v1 < v2);
			}
			Order* self;
		};
		uint32  decayedScore(Var v) { return score[v].decay(decay, huang); }
		int32   occ(Var v)   const  { return score[v].occ; }
		void    inc(Literal p, bool inNant) {
			if (!this->nant || inNant) {
				score[p.var()].incAct(decay, huang, p.sign());
			}
		}
		void    incOcc(Literal p) { score[p.var()].incOcc(p.sign()); }
		int     compare(Var v1, Var v2) {
			return int(decayedScore(v1)) - int(decayedScore(v2));
		}
		void    resetDecay();
		Scores  score;        // For each var v score_[v] stores heuristic score of v
		uint32  decay;        // "global" decay counter. Increased every decP_ decisions
		bool    huang;        // Use Huang's scoring scheme (see: Jinbo Huang: "A Case for Simple SAT Solvers")
		bool    nant;         // only score vars v with varInfo(v).nant()?
		uint8   resScore;
	private:
		Order(const Order&);
		Order& operator=(const Order&);
	}       order_;
	VarVec  cache_;         // Caches the most active variables
	LitVec  freeLits_;      // Stores free variables of the last learnt conflict clause that is not sat
	LitVec  freeOtherLits_; // Stores free variables of the last other learnt nogood that is not sat
	uint32  topConflict_;   // Index into the array of learnt nogoods used when searching for conflict clauses that are not sat
	uint32  topOther_;      // Index into the array of learnt nogoods used when searching for other learnt nogoods that are not sat
	Var     front_;         // First variable whose truth-value is not already known - reset on backtracking
	Pos     cacheFront_;    // First unprocessed cache position - reset on backtracking
	uint32  cacheSize_;     // Cache at most cacheSize_ variables
	uint32  numVsids_;      // Number of consecutive vsids-based decisions
	uint32  maxBerkmin_;    // When searching for an open learnt constraint, check at most maxBerkmin_ candidates.
	TypeSet types_;         // When searching for an open learnt constraint, consider these types of nogoods.
	RNG     rng_;
};

//! Variable Move To Front decision strategies inspired by Siege.
/*!
 * \ingroup heuristic
 * \see Lawrence Ryan: "Efficient Algorithms for Clause Learning SAT-Solvers"
 *
 * \note This implementation of VMTF differs from the original implementation in three points:
 *  - it optionally moves to the front a selection of variables from learnt loop nogoods
 *  - it measures variable activity by using a BerkMin-like score scheme
 *  - the initial order of the var list is determined using a MOMs-like score scheme
 */
class ClaspVmtf : public DecisionHeuristic {
public:
	/*!
	 * \note Moves at most params.param literals from constraints used during
	 *  conflict resolution to the front. If params.param is 0, the default is
	 *  to move up to 8 literals.
	 */
	explicit ClaspVmtf(const HeuParams& params = HeuParams());
	void setConfig(const HeuParams& params);
	void startInit(const Solver& s);
	void endInit(Solver&);
	void newConstraint(const Solver& s, const Literal* first, LitVec::size_type size, ConstraintType t);
	void updateReason(const Solver& s, const LitVec& lits, Literal resolveLit);
	bool bump(const Solver& s, const WeightLitVec& lits, double adj);
	void simplify(const Solver&, LitVec::size_type);
	void undoUntil(const Solver&, LitVec::size_type);
	void updateVar(const Solver& s, Var v, uint32 n);
protected:
	Literal doSelect(Solver& s);
private:
	Literal selectRange(Solver& s, const Literal* first, const Literal* last);
	typedef std::list VarList;
	typedef VarList::iterator VarPos;
	struct VarInfo {
		VarInfo(VarPos it) : pos_(it), activity_(0), occ_(0), decay_(0) { }
		VarPos  pos_;       // position of var in var list
		uint32  activity_;  // activity of var - initially 0
		int32   occ_;       // which literal of var occurred more often in learnt constraints?
		uint32  decay_;     // counter for lazy decaying activity
		uint32& activity(uint32 globalDecay) {
			if (uint32 x = (globalDecay - decay_)) {
				activity_ >>= (x<<1);
				decay_ = globalDecay;
			}
			return activity_;
		}
	};
	typedef PodVector::type Score;

	struct LessLevel {
		LessLevel(const Solver& s, const Score& sc) : s_(s), sc_(sc) {}
		bool operator()(Var v1, Var v2) const {
			return s_.level(v1) < s_.level(v2)
				|| (s_.level(v1) == s_.level(v2) && sc_[v1].activity_ > sc_[v2].activity_);
		}
		bool operator()(Literal l1, Literal l2) const {
			return (*this)(l1.var(), l2.var());
		}
	private:
		LessLevel& operator=(const LessLevel&);
		const Solver& s_;
		const Score&  sc_;
	};
	Score   score_; // For each var v score_[v] stores heuristic score of v
	VarList vars_;  // List of possible choices, initially ordered by MOMs-like score
	VarVec  mtf_;   // Vars to be moved to the front of vars_
	VarPos  front_; // Current front-position in var list - reset on backtracking
	uint32  decay_; // "Global" decay counter. Increased every 512 decisions
	uint32  nMove_; // Limit on number of vars to move
	TypeSet types_; // Type of nogoods to score during resolution
	uint32  scType_;// Type of scoring
	bool    nant_;  // only move vars v with varInfo(v).nant()?
};

//! Score type for VSIDS heuristic.
/*!
 * \see ClaspVsids
 */
struct VsidsScore {
	typedef VsidsScore SC;
	VsidsScore(double sc = 0.0) : value(sc) {}
	double get()                  const { return value; }
	bool   operator>(const SC& o) const { return value > o.value; }
	void   set(double f)                { value = f; }
	template 
	static double applyFactor(C&, Var, double f) { return f; }
	double value; // activity
};

//! A variable state independent decision heuristic favoring variables that were active in recent conflicts.
/*!
 * \ingroup heuristic
 * \see M. W. Moskewicz, C. F. Madigan, Y. Zhao, L. Zhang, and S. Malik:
 * "Chaff: Engineering an Efficient SAT Solver"
 *
 * \note By default, the implementation uses the exponential VSIDS scheme from MiniSAT and
 * applies a MOMs-like score scheme to get an initial var order.
 */
template 
class ClaspVsids_t : public DecisionHeuristic {
public:
	/*!
	 * \note Uses params.param to init the decay value d and inc factor 1.0/d.
	 * If params.param is 0, d is set 0.95. Otherwise, d is set to 0.x, where x is params.param.
	 */
	explicit ClaspVsids_t(const HeuParams& params = HeuParams());
	virtual void setConfig(const HeuParams& params);
	virtual void startInit(const Solver& s);
	virtual void endInit(Solver&);
	virtual void newConstraint(const Solver& s, const Literal* first, LitVec::size_type size, ConstraintType t);
	virtual void updateReason(const Solver& s, const LitVec& lits, Literal resolveLit);
	virtual bool bump(const Solver& s, const WeightLitVec& lits, double adj);
	virtual void undoUntil(const Solver&, LitVec::size_type);
	virtual void simplify(const Solver&, LitVec::size_type);
	virtual void updateVar(const Solver& s, Var v, uint32 n);
protected:
	virtual Literal doSelect(Solver& s);
	virtual Literal selectRange(Solver& s, const Literal* first, const Literal* last);
	virtual void    initScores(Solver& s, bool moms);
	typedef typename PodVector::type ScoreVec;
	typedef PodVector::type              OccVec;
	void updateVarActivity(const Solver& s, Var v, double f = 1.0);
	void incOcc(Literal p) { occ_[p.var()] += 1 - (int(p.sign()) << 1); }
	int  occ(Var v) const  { return occ_[v]; }
	void normalize();
	struct CmpScore {
		explicit CmpScore(const ScoreVec& s) : sc_(s) {}
		bool operator()(Var v1, Var v2) const { return sc_[v1] > sc_[v2]; }
	private:
		CmpScore& operator=(const CmpScore&);
		const ScoreVec& sc_;
	};
	typedef bk_lib::indexed_priority_queue VarOrder;
	struct Decay : Range{
		Decay(double x = 0.0, double y = 0.95, uint32 b = 0, uint32 f = 0) : Range(x, y), bump(b), freq(f), next(f) {
			this->df = 1.0 / (freq && lo > 0.0 ? lo : hi);
		}
		double df; // active decay factor for evsids (>= 1.0)
		uint32 bump;
		uint32 freq : 16;
		uint32 next : 16;
	};
	ScoreVec score_; // vsids score for each variable
	OccVec   occ_;   // occurrence balance of each variable
	VarOrder vars_;  // priority heap of variables
	Decay    decay_; // (dynamic) decaying strategy
	double   inc_;   // var bump for evsids or conflict index for acids (increased on conflict)
	TypeSet  types_; // set of constraints to score
	uint32   scType_;// score type (one of HeuParams::Score)
	bool     acids_; // whether to use acids instead if evsids scoring
	bool     nant_;  // whether bumps are restricted to vars v with varInfo(v).nant()
};
typedef ClaspVsids_t ClaspVsids;

//! Score type for DomainHeuristic.
/*!
 * \see DomainHeuristic
 */
struct DomScore : VsidsScore {
	static const uint32 domMax = (1u << 30) - 1;
	typedef DomScore SC;
	DomScore(double v = 0.0) : VsidsScore(v), level(0), factor(1), domP(domMax), sign(0), init(0) {}
	bool   operator>(const SC& o) const { return (level > o.level) || (level == o.level && value > o.value); }
	bool   isDom()                const { return domP != domMax; }
	void   setDom(uint32 key)           { domP = key; }
	template 
	static double applyFactor(C& sc, Var v, double f) {
		int16 df = sc[v].factor;
		return df == 1 ? f : static_cast(df) * f;
	}
	int16  level;     // priority level
	int16  factor;    // factor used when bumping activity
	uint32 domP : 30; // index into dom-table if dom var
	uint32 sign :  1; // whether v has a sign modification
	uint32 init :  1; // whether value is from init modification
};

//! A VSIDS heuristic supporting additional domain knowledge.
/*!
 * \ingroup heuristic
 *
 * \see M. Gebser, B. Kaufmann, R. Otero, J. Romero, T. Schaub, P. Wanko:
 *      "Domain-specific Heuristics in Answer Set Programming",
 *      http://www.cs.uni-potsdam.de/wv/pdfformat/gekaotroscwa13a.pdf
 */
class DomainHeuristic : public ClaspVsids_t
                      , private Constraint {
public:
	typedef ClaspVsids_t  BaseType;
	explicit DomainHeuristic(const HeuParams& params = HeuParams());
	~DomainHeuristic();
	void setDefaultMod(HeuParams::DomMod mod, uint32 prefSet);
	virtual void setConfig(const HeuParams& params);
	virtual void startInit(const Solver& s);
	const DomScore& score(Var v) const { return score_[v]; }
protected:
	// base interface
	virtual Literal     doSelect(Solver& s);
	virtual void        initScores(Solver& s, bool moms);
	virtual void        detach(Solver& s);
	// Constraint interface
	virtual Constraint* cloneAttach(Solver&) { return 0; }
	virtual void        reason(Solver&, Literal, LitVec&){}
	virtual PropResult  propagate(Solver&, Literal, uint32&);
	virtual void        undoLevel(Solver& s);
private:
	struct DomAction {
		static const uint32 UNDO_NIL = (1u << 31) - 1;
		uint32 var:30; // dom var to be modified
		uint32 mod: 2; // modification to apply
		uint32 undo:31;// next action in undo list
		uint32 next: 1;// next action belongs to same condition?
		int16  bias;   // value to apply
		uint16 prio;   // prio of modification
	};
	struct DomPrio {
		void clear() { prio[0] = prio[1] = prio[2] = prio[3] = 0; }
		uint16  operator[](unsigned i) const { return prio[i]; }
		uint16& operator[](unsigned i)       { return prio[i]; }
		uint16  prio[4];
	};
	struct Frame {
		Frame(uint32 lev, uint32 h) : dl(lev), head(h) {}
		uint32 dl;
		uint32 head;
	};
	typedef PodVector::type ActionVec;
	typedef PodVector::type   PrioVec;
	typedef PodVector::type     FrameVec;
	typedef DomainTable::ValueType     DomMod;
	typedef PodVector >::type VarScoreVec;

	uint32  addDomAction(const DomMod& e, Solver& s,  VarScoreVec& outInit, Literal& lastW);
	void    addDefAction(Solver& s, Literal x, int16 lev, uint32 domKey);
	void    pushUndo(uint32& head, uint32 actionId);
	void    applyAction(Solver& s, DomAction& act, uint16& oldPrio);
	uint16& prio(Var v, uint32 mod) { return prios_[score_[v].domP][mod]; }
	PrioVec   prios_;    // priorities for domain vars
	ActionVec actions_;  // dynamic modifications
	FrameVec  frames_;   // dynamic undo information
	uint32    domSeen_;  // offset into domain table
	uint32    defMax_;   // max var with default modification
	uint16    defMod_;   // default modifier
	uint16    defPref_;  // default preferences
};
}
#endif
clasp-3.2.2/libclasp/clasp/literal.h000066400000000000000000000211551304134206100173160ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_LITERAL_H_INCLUDED
#define CLASP_LITERAL_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
#include   // std::swap
#include 
/*!
 * \file
 * \brief Types and functions related to literals and variables.
 */
namespace Clasp {
/*!
 * \addtogroup constraint
 */
//@{

//! A variable is an integer in the range [0..varMax).
typedef uint32 Var;

//! varMax is not a valid variale, i.e. currently Clasp supports at most 2^30 variables.
const Var varMax = (Var(1) << 30);

//! The variable 0 has a special meaning in the solver.
const Var sentVar = 0;

//! Literal ids are in the range [0..litIdMax).
const uint32 litIdMax = (Var(1) << 31);

//! Possible types of a variable.
struct Var_t {
	enum Type { Atom = 1, Body = 2, Hybrid = Atom | Body};
	static bool isBody(Type t) {
		return (static_cast(t) & static_cast(Body)) != 0;
	}
	static bool isAtom(Type t) {
		return (static_cast(t) & static_cast(Atom)) != 0;
	}
};
typedef Var_t::Type VarType;

//! A literal is a variable or its negation.
/*!
 * \par Implementation:
 * A literal's state is stored in a single 32-bit integer as follows:
 *  - 30-bits   : variable id
 *  - 1-bit     : sign, 1 if negative, 0 if positive
 *  - 1-bit     : general purpose flag for marking a literal instance
 */
class Literal {
public:
	static const uint32 sign_bit = 2u;
	static const uint32 flag_bit = 1u;

	//! The default constructor creates the positive literal of the special sentinel var.
	Literal() : rep_(0) { }

	//! Creates a literal of the variable var with sign s.
	/*!
	 * \param var  The literal's variable.
	 * \param sign true if new literal should be negative.
	 * \pre var < varMax
	 */
	Literal(Var var, bool sign) : rep_( (var<> sign_bit; }

	//! Returns the sign of the literal.
	/*!
	 * \return true if the literal is negative. Otherwise false.
	 */
	bool sign() const { return (rep_ & sign_bit) != 0; }

	//! Returns var and sign encoded in a unique id.
	/*!
	 * \note The watch-flag is ignored and thus the id of a literal can be stored in 31-bits.
	 */
	uint32 id() const { return rep_ >> flag_bit; }

	//! Returns the stored representation of this literal.
	uint32& rep()       { return rep_; }
	uint32  rep() const { return rep_; }

	//! Creates a literal from an id.
	static Literal fromId(uint32 id) {
		assert(id < litIdMax);
		return Literal(id<(-p)) : posLit(static_cast(p)); }
//! Converts the given (non-sentinel) literal to a signed integer s.th. p == toLit(toInt(p)).
inline int32   toInt(Literal p) { return p.sign() ? -static_cast(p.var()) : static_cast(p.var()); }
//! Always-true literal.
// TODO: replace with constant using constexpr ctor once we switch to C++11
inline Literal lit_true() { return Literal(sentVar, false); }
//! Always-false literal.
// TODO: replace with constant using constexpr ctor once we switch to C++11
inline Literal lit_false() { return Literal(sentVar, true); }
//! Returns true if p represents the special variable 0
inline bool    isSentinel(Literal p) { return p.var() == sentVar; }

// Low-level conversion between Literals and int literals.
// We cannot use toInt() here because it is not defined for the
// sentinel literals lit_true() and lit_false().
inline int32   encodeLit(Literal x) { return !x.sign() ? static_cast(x.var()+1) : -static_cast(x.var()+1); }
inline Var     decodeVar(int32 x)   { return static_cast(x >= 0 ? x : -x) - 1; }
inline Literal decodeLit(int32 x)   { return Literal(decodeVar(x), x < 0); }

inline unsigned hashId(unsigned key) {
	key = ~key + (key << 15);
	key ^= (key >> 11);
	key += (key << 3);
	key ^= (key >> 5);
	key += (key << 10);
	key ^= (key >> 16);
	return key;
}
inline uint32 hashLit(Literal p) { return hashId(p.id()); }

//! A signed integer type used to represent weights.
typedef int32 weight_t;
//! A signed integer type used to represent sums of weights.
typedef int64 wsum_t;
#define CLASP_WEIGHT_T_MAX ( 2147483647)
#define CLASP_WEIGHT_T_MIN (-2147483647 - 1)
#define CLASP_WEIGHT_SUM_MAX INT64_MAX
#define CLASP_WEIGHT_SUM_MIN INT64_MIN

typedef PodVector::type      VarVec;    //!< A vector of variables.
typedef PodVector::type  LitVec;    //!< A vector of literals.
typedef PodVector::type WeightVec; //!< A vector of weights.
typedef PodVector::type   SumVec;    //!< A vector of sums of weights.
typedef std::pair   WeightLiteral; //!< A literal associated with a weight.
typedef PodVector::type WeightLitVec;  //!< A vector of weight-literals.
///////////////////////////////////////////////////////////////////////////////
// Truth values
///////////////////////////////////////////////////////////////////////////////
typedef uint8 ValueRep;           //!< Type of the three value-literals.
const ValueRep value_true   = 1;  //!< Value used for variables that are true.
const ValueRep value_false  = 2;  //!< Value used for variables that are false.
const ValueRep value_free   = 0;  //!< Value used for variables that are unassigned.
typedef PodVector::type ValueVec;

//! Returns the value that makes the literal lit true.
/*!
 * \param lit The literal for which the true-value should be determined.
 * \return
 *   - value_true  iff lit is a positive literal
 *   - value_false iff lit is a negative literal.
 *   .
 */
inline ValueRep trueValue(const Literal& lit) { return 1 + lit.sign(); }

//! Returns the value that makes the literal lit false.
/*!
 * \param lit The literal for which the false-value should be determined.
 * \return
 *   - value_false iff lit is a positive literal
 *   - value_true  iff lit is a negative literal.
 *   .
 */
inline ValueRep falseValue(const Literal& lit) { return 1 + !lit.sign(); }

//! Returns the sign that matches the value.
/*!
 * \return
 *   - false iff v == value_true
 *   - true  otherwise
 */
inline bool valSign(ValueRep v) { return v != value_true; }
//@}
}
#endif
clasp-3.2.2/libclasp/clasp/logic_program.h000066400000000000000000000726531304134206100205170ustar00rootroot00000000000000//
// Copyright (c) 2013-2016 Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_LOGIC_PROGRAM_H_INCLUDED
#define CLASP_LOGIC_PROGRAM_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
#include 
#include 
namespace Clasp { namespace Asp {
/*!
 * \file
 * \defgroup asp Asp
 * \brief Classes and functions for defining logic programs.
 * \ingroup problem
 */
//@{

//! A struct for counting program rules and directives.
struct RuleStats {
	typedef uint32& Ref_t;
	typedef uint32 const& CRef_t;
	//! Rules and directives counted by this object.
	enum Key {
		Normal    = Head_t::Disjunctive,//!< Normal or disjunctive rules.
		Choice    = Head_t::Choice,     //!< Choice rules.
		Minimize  ,                     //!< Distinct minimize constraints.
		Acyc      ,                     //!< Edge directives.
		Heuristic ,                     //!< Heuristic directives.
		Key__num
	};
	//! Returns a string representation of the given key.
	static const char* toStr(int k);
	//! Returns the number of keys distinguished by this type.
	static uint32      numKeys()   { return Key__num; }
	//! Updates the number of rules of the given type.
	void up(Key k, int amount)     { key[k] += static_cast(amount); }
	//! Returns the number of rules of the given type.
	Ref_t  operator[](int k)       { return key[k]; }
	//! @copydoc operator[](int k)
	CRef_t operator[](int k) const { return key[k]; }
	//! Returns the sum of all rules.
	uint32 sum()             const;
	uint32 key[Key__num]; //!< @private
};
//! A struct for counting distinct program bodies.
struct BodyStats {
	typedef uint32& Ref_t;
	typedef uint32 const& CRef_t;
	//! Body types distinguished by this object.
	typedef Body_t Key;
	//! Returns a string representation of the given key.
	static const char* toStr(int k);
	//! Returns the number of keys distinguished by this type.
	static uint32      numKeys()   { return Body_t::eMax + 1; }
	//! Updates the number of bodies of the given type.
	void up(Key k, int amount)     { key[k] += static_cast(amount); }
	//! Returns the number of bodies of the given type.
	Ref_t  operator[](int k)       { return key[k]; }
	//! @copydoc operator[](int k)
	CRef_t operator[](int k) const { return key[k]; }
	//! Returns the sum of all bodies.
	uint32 sum()             const;
	uint32 key[Body_t::eMax + 1]; //!< @private
};

//! A type for maintaining a set of program statistics.
class LpStats {
public:
	LpStats() { reset(); }
	void   reset();
	//! Returns the sum of all equivalences.
	uint32 eqs()             const { return eqs(Var_t::Atom) + eqs(Var_t::Body) + eqs(Var_t::Hybrid); }
	//! Returns the number of equivalences of the given type.
	uint32 eqs(VarType t)    const { return eqs_[t-1]; }
	//! Increments the number of equivalences of the given type.
	void   incEqs(VarType t)       { ++eqs_[t-1]; }
	//! Computes *this += o.
	void   accu(const LpStats& o);
	RuleStats rules[2];        /**< RuleStats (initial, final). */
	BodyStats bodies[2];       /**< BodyStats (initial, final). */
	uint32    atoms;           /**< Number of program atoms.    */
	uint32    auxAtoms;        /**< Number of aux atoms created. */
	uint32    disjunctions[2]; /**< Number of disjunctions (initial, non-hcf). */
	uint32    sccs;            /**< How many strongly connected components? */
	uint32    nonHcfs;         /**< How many non head-cycle free components?*/
	uint32    gammas;          /**< How many non-hcf gamma rules. */
	uint32    ufsNodes;        /**< How many nodes in the positive dependency graph? */
	// StatisticObject
	static uint32 size();
	static const char* key(uint32 i);
	StatisticObject at(const char* k) const;
private:
	uint32 eqs_[3];
};
//! Exception type for signaling an invalid incremental program update.
class RedefinitionError : public std::logic_error {
public:
	explicit RedefinitionError(unsigned atomId, const char* atomName = "");
	unsigned atom() const { return atomId_; }
private:
	unsigned atomId_;
};
using Potassco::TheoryData;

//! A class for defining a logic program.
/*!
 * Use this class to specify a logic program. Once the program is completly defined,
 * call endProgram() to load the logic program into a SharedContext object.
 */
class LogicProgram : public ProgramBuilder {
public:
	LogicProgram();
	~LogicProgram();
	//! Defines the possible modes for handling extended rules, i.e. choice, cardinality, and weight rules.
	enum ExtendedRuleMode {
		mode_native           = 0, //!< Handle extended rules natively.
		mode_transform        = 1, //!< Transform extended rules to normal rules.
		mode_transform_choice = 2, //!< Transform only choice rules to normal rules.
		mode_transform_card   = 3, //!< Transform only cardinality rules to normal rules.
		mode_transform_weight = 4, //!< Transform cardinality- and weight rules to normal rules.
		mode_transform_scc    = 5, //!< Transform recursive cardinality- and weight rules to normal rules.
		mode_transform_nhcf   = 6, //!< Transform cardinality- and weight rules in non-hcf components to normal rules.
		mode_transform_integ  = 7, //!< Transform cardinality-based integrity constraints.
		mode_transform_dynamic= 8  //!< Heuristically decide whether or not to transform a particular extended rule.
	};

	//! Options for the Asp-Preprocessor.
	struct AspOptions {
		static const uint32 MAX_EQ_ITERS = static_cast( (1u<<26)-1 );
		typedef ExtendedRuleMode TrMode;
		AspOptions() {
			std::memset(this, 0, sizeof(AspOptions));
			iters = 5;
		}
		AspOptions& iterations(uint32 it)   { iters   = it;return *this;}
		AspOptions& depthFirst()            { dfOrder = 1; return *this;}
		AspOptions& backpropagate()         { backprop= 1; return *this;}
		AspOptions& noScc()                 { noSCC   = 1; return *this;}
		AspOptions& noEq()                  { iters   = 0; return *this;}
		AspOptions& disableGamma()          { noGamma = 1; return *this;}
		AspOptions& ext(ExtendedRuleMode m) { erMode  = m; return *this;}
		TrMode erMode;       //!< How to handle extended rules?
		uint32 iters    : 26;//!< Number of iterations in eq-preprocessing or 0 to disable.
		uint32 noSCC    :  1;//!< Disable scc checking?
		uint32 suppMod  :  1;//!< Disable scc checking and compute supported models.
		uint32 dfOrder  :  1;//!< Visit nodes in eq-preprocessing in depth-first order?
		uint32 backprop :  1;//!< Enable backpropagation during preprocessing?
		uint32 oldMap   :  1;//!< Use old and larger mapping for disjunctive programs.
		uint32 noGamma  :  1;//!< Disable creation of (shifted) gamma rules for non-hcf disjunctions?
	};

	/*!
	 * \name Step control functions
	 */
	//@{

	//! Starts the definition of a logic program.
	LogicProgram& start(SharedContext& ctx, const AspOptions& opts = AspOptions()) {
		startProgram(ctx);
		setOptions(opts);
		return *this;
	}
	//! Sets the mode for handling extended rules (default: mode_native).
	void setExtendedRuleMode(ExtendedRuleMode m) { opts_.ext(m); }
	//! Sets preprocessing options.
	void setOptions(const AspOptions& opts);
	//! Sets the configuration to be used for checker solvers in disjunctive LP solving.
	void setNonHcfConfiguration(Configuration* c){ nonHcfs_.config = c; }

	//! Unfreezes a currently frozen program and starts an incremental step.
	/*!
	 * If a program is to be defined incrementally, this function must be called
	 * exactly once for each step before any new rules or atoms are added.
	 * \note Program update only works correctly under the following assumptions:
	 *  - Atoms introduced in step i are either:
	 *    - solely defined in step i OR,
	 *    - marked as frozen in step i and solely defined in step i+k OR,
	 *    - forced to false by a compute statement in step 0.
	 *
	 * \pre The program is either frozen or at step 0.
	 * \post The program is no longer frozen and calling program mutating functions is valid again.
	 * \throws std::logic_error precondition is violated.
	 * \note The function is an alias for ProgramBuilder::updateProgram().
	 */
	bool update() { return updateProgram(); }

	//! Finishes the definition of the logic program (or its current increment).
	/*!
	 * Applies program mutating operations issued in the current step and transforms
	 * the new program into the solver's internal representation.
	 *
	 * \return false if the program is conflicting, true otherwise.
	 *
	 * \post
	 *  - If true is returned, the program is considered to be "frozen" and calling
	 *    program mutating functions is invalid until the next call to update().
	 *  - If false is returned, the state of the object is undefined and start()
	 *    and dispose() are the only remaining valid operations.
	 *  .
	 * \note The function is an alias for ProgramBuilder::endProgram().
	 */
	bool end() { return endProgram(); }

	//! Visits the the simplified program by notifying out on its elements.
	void accept(Potassco::AbstractProgram& out);

	//! Disposes (parts of) the internal representation of the logic program.
	/*!
	 * \param forceFullDispose If set to true, the whole program is disposed. Otherwise,
	 *  only the rules (of the current step) are disposed but atoms and any incremental
	 *  control data remain.
	 */
	void dispose(bool forceFullDispose);

	//! Clones the program and adds it to the given ctx.
	/*
	 * \pre The program is currently frozen.
	 */
	bool clone(SharedContext& ctx);

	//@}

	/*!
	 * \name Program mutating functions
	 *
	 * Functions in this group shall only be called if the program is currently not
	 * frozen. That is, only between the call to start() (resp. update() if in
	 * incremental setting) and end(). A std::logic_error is raised if this precondition is violated.
	 *
	 */
	//@{

	//! Adds a new atom to the program and returns the new atom's id.
	Atom_t newAtom();

	//! Sets atomId as the last input atom of the current step.
	/*!
	* All (new or existing) atoms with a larger id than atomId
	* are considered to be auxiliary and automatically removed before
	* a new incremental step is started.
	*
	* \pre atomId >= startAtom()
	* \post startAuxAtom() == atomId + 1
	*/
	void   setMaxInputAtom(uint32 atomId);

	//! Adds a new conjunctive condition to the program.
	/*!
	 * \param cond A (possibly empty) list of atom literals.
	 * \return The id of the new condition, which can be later passed to
	 * extractCondition() or getLiteral().
	 */
	Id_t   newCondition(const Potassco::LitSpan& cond);

	//! Adds the given string to the problem's output table.
	/*!
	 * \param str The string to add.
	 * \param cond The condition under which str should be considered part of a model.
	 */
	LogicProgram& addOutput(const ConstString& str, const Potassco::LitSpan& cond);
	LogicProgram& addOutput(const ConstString& str, Id_t cond);

	//! Adds the given atoms to the set of projection variables.
	LogicProgram& addProject(const Potassco::AtomSpan& atoms);

	//! Protects an otherwise undefined atom from preprocessing.
	/*!
	 * If the atom is defined in this or a previous step, the operation has no effect.
	 * \note If atomId is not yet known, an atom with the given id is implicitly created.
	 * \note The second parameter defines the assumption that shall hold during solving, i.e.
	 *       - posLit(atomId), if value is value_true,
	 *       - negLit(atomId), if value is value_false, or
	 *       - no assumption, if value is value_free.
	 *
	 * \see ProgramBuilder::getAssumptions(LitVec&) const;
	 */
	LogicProgram& freeze(Atom_t atomId, ValueRep value = value_false);

	//! Removes any protection from the given atom.
	/*!
	 * If the atom is defined in this or a previous step, the operation has no effect.
	 * \note
	 *   - The effect is logically equivalent to adding a rule atomId :- false.
	 *   - A call to unfreeze() always overwrites a call to freeze() even if the
	 *     latter comes after the former
	 *   .
	 */
	LogicProgram& unfreeze(Atom_t atomId);

	//! Adds the given rule (or integrity constraint) to the program.
	/*!
	 * \pre The the rule does not define an atom from a previous incremental step.
	 *
	 * Simplifies the given rule and adds it to the program if it
	 * is neither tautological (e.g. a :- a) nor contradictory (e.g. a :- b, not b).
	 * Atoms in the simplified rule that are not yet known are implicitly created.
	 *
	 * \throws RedefinitionError if the precondition is violated.
	 * \note If the head of the simplified rule mentions an atom from a previous step,
	 *       that atom shall either be frozen or false. In the former case,
	 *       unfreeze() is implicitly called. In the latter case, the rule is interpreted
	 *       as an integrity constraint.
	 */
	LogicProgram& addRule(const Rule& rule);
	LogicProgram& addRule(Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body);
	LogicProgram& addRule(Head_t ht, const Potassco::AtomSpan& head, Potassco::Weight_t bound, const Potassco::WeightLitSpan& lits);
	LogicProgram& addRule(Potassco::RuleBuilder& rb);
	//! Adds the given minimize statement.
	/*!
	 * \param prio The priority of the minimize statement.
	 * \param lits The literals to minimize.
	 * \note All minimize statements of the same priority are merged into one.
	 */
	LogicProgram& addMinimize(weight_t prio, const Potassco::WeightLitSpan& lits);

	//! Adds an edge to the extended (user-defined) dependency graph.
	LogicProgram& addAcycEdge(uint32 n1, uint32 n2, const Potassco::LitSpan& condition) { return addAcycEdge(n1, n2, newCondition(condition)); }
	LogicProgram& addAcycEdge(uint32 n1, uint32 n2, Id_t cond);

	//! Adds a conditional domain heuristic directive to the program.
	LogicProgram& addDomHeuristic(Atom_t atom, DomModType t, int bias, unsigned prio, const Potassco::LitSpan& condition) { return addDomHeuristic(atom, t, bias, prio, newCondition(condition)); }
	LogicProgram& addDomHeuristic(Atom_t atom, DomModType t, int bias, unsigned prio, Id_t cond);
	//! Adds an unconditional domain heuristic directive to the program.
	LogicProgram& addDomHeuristic(Atom_t atom, DomModType t, int bias, unsigned prio);

	//! Forces the given literals to be true during solving.
	/*!
	 * Assumptions are retracted on the next program update.
	 */
	LogicProgram& addAssumption(const Potassco::LitSpan& cube);

	//! Adds or updates the given external atom.
	/*!
	* \see LogicProgram::freeze(Atom_t atomId, ValueRep value);
	* \see LogicProgram::unfreeze(Atom_t atomId);
	*/
	LogicProgram& addExternal(Atom_t atomId, Potassco::Value_t value);

	//! Returns an object for adding theory data to this program.
	TheoryData&   theoryData();
	//@}

	/*!
	 * \name Query functions
	 *
	 * Functions in this group are useful to query important information
	 * once the program is frozen, i.e. after end() was called.
	 * They do not throw exceptions.
	 */
	 //@{
	//! Returns whether the program can be represented in internal smodels format.
	bool   supportsSmodels() const;
	//! Returns whether the program is to be defined incrementally.
	bool   isIncremental()   const { return incData_ != 0; }
	//! Returns whether the program contains any minimize statements.
	bool   hasMinimize()     const { return !minimize_.empty(); }
	//! Returns whether the program contains any theory data.
	bool   hasTheoryData()   const { return theory_ != 0; }
	//! Returns the number of atoms in the logic program.
	uint32 numAtoms()        const { return (uint32)atoms_.size()-1; }
	//! Returns the number of bodies in the current (slice of the) logic program.
	uint32 numBodies()       const { return (uint32)bodies_.size(); }
	//! Returns the number of disjunctive heads.
	uint32 numDisjunctions() const { return (uint32)disjunctions_.size(); }
	//! Returns the id of the first atom of the current step.
	Atom_t startAtom()       const { return input_.lo; }
	//! Returns an id one past the last valid atom id in the program.
	Atom_t endAtom()         const { return numAtoms() + 1; }
	//! Returns the id of the first atom that is not an input atom or endAtom() if no such atoms exists.
	Atom_t startAuxAtom()    const;
	//! Returns whether a is an atom in the (simplified) program.
	bool   inProgram(Atom_t a)  const;
	//! Returns whether a is an external atom, i.e. is frozen in this step.
	bool   isExternal(Atom_t a) const;
	//! Returns whether a occurs in the head of a rule.
	bool   isDefined(Atom_t a)  const;
	//! Returns whether a is a fact.
	bool   isFact(Atom_t a)     const;
	//! Returns the internal solver literal that is associated with the given atom or condition.
	/*!
	 * \pre id is the id of a valid atom literal or was previously returned by newCondition().
	 * \note Untill end() is called, the function returns lit_false() for
	 *       all atoms and conditions defined in the current step.
	 * \note For an atom literal lit with Potassco::atom(lit) == a,
	 *       getLiteral(Potassco::id(lit)) returns
	 *        getLiteral(a), iff lit ==  a, or
	 *       ~getLiteral(a), iff lit == -a.
	 */
	Literal getLiteral(Id_t id) const;
	//! Returns the atom literals belonging to the given condition.
	/*!
	 * \pre cId was previously returned by newCondition() in the current step.
	 */
	bool    extractCondition(Id_t cId, Potassco::LitVec& lits) const;
	LpStats stats; //!< Statistics of the current step.
	//@}

	/*!
	 * \name Implementation functions
	 * Low-level implementation functions. Use with care and only if you
	 * know what you are doing!
	 */
	//@{
	typedef VarVec::const_iterator                VarIter;
	typedef PrgHead*const*                        HeadIter;
	typedef std::pair EdgeRange;
	typedef std::pair         HeadRange;
	struct SRule {
		SRule() : hash(0), pos(0), bid(varMax) {}
		uint32 hash; // hash value of the body
		uint32 pos;  // positive size of body
		uint32 bid;  // id of existing body or varMax
	};
	const AspOptions& options()    const { return opts_; }
	bool       hasConflict()       const { return getTrueAtom()->literal() != lit_true(); }
	bool       ok()                const { return !hasConflict() && ProgramBuilder::ok(); }
	PrgAtom*   getAtom(Id_t atomId)const { return atoms_[atomId]; }
	PrgHead*   getHead(PrgEdge it) const { return it.isAtom() ? (PrgHead*)getAtom(it.node()) : (PrgHead*)getDisj(it.node()); }
	PrgNode*   getSupp(PrgEdge it) const { return it.isBody() ? (PrgNode*)getBody(it.node()) : (PrgNode*)getDisj(it.node()); }
	Id_t       getRootId(Id_t atom)const { return getEqNode(atoms_, atom); }
	PrgAtom*   getRootAtom(Id_t a) const { return getAtom(getRootId(a)); }
	PrgBody*   getBody(Id_t bodyId)const { return bodies_[bodyId]; }
	Id_t       getEqBody(Id_t b)   const { return getEqNode(bodies_, b); }
	PrgDisj*   getDisj(Id_t disjId)const { return disjunctions_[disjId]; }
	HeadIter   disj_begin()        const { return disjunctions_.empty() ? 0 : reinterpret_cast(&disjunctions_[0]); }
	HeadIter   disj_end()          const { return disj_begin() + numDisjunctions(); }
	HeadIter   atom_begin()        const { return reinterpret_cast(&atoms_[0]); }
	HeadIter   atom_end()          const { return atom_begin() + (numAtoms()+1); }
	VarIter    unfreeze_begin()    const { return incData_?incData_->unfreeze.begin() : propQ_.end(); }
	VarIter    unfreeze_end()      const { return incData_?incData_->unfreeze.end()   : propQ_.end(); }
	bool       validAtom(Id_t aId) const { return aId < (uint32)atoms_.size(); }
	bool       validBody(Id_t bId) const { return bId < numBodies(); }
	bool       validDisj(Id_t dId) const { return dId < numDisjunctions(); }
	Literal    getDomLiteral(Atom_t a) const;
	bool       isFact(PrgAtom* a)  const;
	const char*findName(Atom_t x)  const;
	bool       simplifyRule(const Rule& r, Potassco::RuleBuilder& out, SRule& meta);
	Atom_t     falseAtom();
	VarVec&    getSupportedBodies(bool sorted);
	uint32     update(PrgBody* b, uint32 oldHash, uint32 newHash);
	bool       assignValue(PrgAtom* a, ValueRep v, PrgEdge reason);
	bool       assignValue(PrgHead* h, ValueRep v, PrgEdge reason);
	bool       propagate(bool backprop);
	PrgAtom*   mergeEqAtoms(PrgAtom* a, Id_t rootAtom);
	PrgBody*   mergeEqBodies(PrgBody* b, Id_t rootBody, bool hashEq, bool atomsAssigned);
	bool       propagate()               { return propagate(options().backprop != 0); }
	void       setConflict()             { getTrueAtom()->setLiteral(lit_false()); }
	AtomState& atomState()               { return atomState_; }
	void       addMinimize();
	// ------------------------------------------------------------------------
	// Statistics
	void incTrAux(uint32 n)   { stats.auxAtoms += n; }
	void incEqs(VarType t)    { stats.incEqs(t);     }
	void upStat(RuleStats::Key k, int n = 1){ stats.rules[statsId_].up(k, n); }
	void upStat(Body_t k, int n = 1) { stats.bodies[statsId_].up(k, n); }
	void upStat(Head_t k, int n = 1) { stats.rules[statsId_].up(static_cast(unsigned(k)), n); }
	// ------------------------------------------------------------------------
	//@}
private:
	LogicProgram(const LogicProgram&);
	LogicProgram& operator=(const LogicProgram&);
	struct DlpTr;
	struct AcycArc { Id_t cond; uint32 node[2]; };
	struct DomRule { uint32 atom : 29; uint32 type : 3; Id_t cond; int16 bias; uint16 prio; };
	struct Eq      { Atom_t var; Literal lit; };
	struct TFilter { bool operator()(const Potassco::TheoryAtom& atom) const; LogicProgram* self; };
	struct Min     { weight_t prio; Potassco::WLitVec lits; };
	struct CmpMin  { bool operator()(const Min* m1, const Min* m2) const { return m1->prio < m2->prio; } };
	typedef Potassco::RuleBuilder           RuleBuilder;
	typedef std::pair    ShowPair;
	typedef PodVector::type       ShowVec;
	typedef PodVector::type        DomRules;
	typedef PodVector::type        AcycRules;
	typedef PodVector::type   RuleList;
	typedef PodVector::type           MinList;
	typedef PodVector::type          SccMap;
	typedef PodVector::type             EqVec;
	typedef Clasp::HashMap_t::multi_map_type IndexMap;
	typedef IndexMap::iterator              IndexIter;
	typedef std::pair IndexRange;
	typedef Potassco::WLitVec               LpWLitVec;
	typedef Potassco::LitVec                LpLitVec;
	typedef Range                   AtomRange;
	// ------------------------------------------------------------------------
	// virtual overrides
	bool doStartProgram();
	bool doUpdateProgram();
	bool doEndProgram();
	void doGetAssumptions(LitVec& out) const;
	ProgramParser* doCreateParser();
	int  doType() const { return Problem_t::Asp; }
	// ------------------------------------------------------------------------
	// Program definition
	bool     isNew(Atom_t atomId) const { return atomId >= startAtom(); }
	PrgAtom* resize(Atom_t atomId);
	void     pushFrozen(PrgAtom* atom, ValueRep v);
	void     addRule(const Rule& r, const SRule& meta);
	void     addFact(const Potassco::AtomSpan& head);
	void     addIntegrity(const Rule& b, const SRule& meta);
	bool     handleNatively(const Rule& r) const;
	bool     transformNoAux(const Rule& r) const;
	void     freezeTheory();
	void     transformExtended();
	void     transformIntegrity(uint32 nAtoms, uint32 maxAux);
	PrgBody* getBodyFor(const Rule& r, const SRule& m, bool addDeps = true);
	PrgBody* getTrueBody();
	PrgDisj* getDisjFor(const Potassco::AtomSpan& heads, uint32 headHash);
	PrgBody* assignBodyFor(const Rule& r, const SRule& m, EdgeType x, bool strongSimp);
	bool     equalLits(const PrgBody& b, const WeightLitSpan& lits) const;
	bool     simplifyNormal(Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body, RuleBuilder& out, SRule& info);
	bool     simplifySum(Head_t ht, const Potassco::AtomSpan& head, const Potassco::Sum_t& body, RuleBuilder& out, SRule& info);
	bool     pushHead(Head_t ht, const Potassco::AtomSpan& head, weight_t slack, RuleBuilder& out);
	ValueRep litVal(const PrgAtom* a, bool pos) const;
	uint32   findBody(uint32 hash, Body_t type, uint32 size, weight_t bound = -1, Potassco::WeightLit_t* wlits = 0);
	uint32   findEqBody(const PrgBody* b, uint32 hash);
	uint32   removeBody(PrgBody* b, uint32 oldHash);
	Literal  getEqAtomLit(Literal lit, const BodyList& supports, Preprocessor& p, const SccMap& x);
	bool     positiveLoopSafe(PrgBody* b, PrgBody* root) const;
	void     prepareExternals();
	void     updateFrozenAtoms();
	void     normalize();
	template 
	Id_t getEqNode(C& vec, Id_t id)  const {
		if (!vec[id]->eq()) return id;
		typedef typename C::value_type NodeType;
		NodeType n = vec[id], r;
		Id_t root  = n->id();
		for (r = vec[root]; r->eq(); r = vec[root]) {
			// n == r and r == r' -> n == r'
			assert(root != r->id());
			n->setEq(root = r->id());
		}
		return root;
	}
	bool checkBody(const PrgBody& rhs, Body_t type, uint32 size, weight_t bound) const {
		return (rhs.relevant() || (rhs.eq() && getBody(getEqBody(rhs.id()))->relevant()))
			&& rhs.type() == type && rhs.size() == size && rhs.bound() == bound;
	}
	// ------------------------------------------------------------------------
	// Nogood creation
	void prepareProgram(bool checkSccs);
	void prepareOutputTable();
	void finalizeDisjunctions(Preprocessor& p, uint32 numSccs);
	void prepareComponents();
	bool addConstraints();
	void addAcycConstraint();
	void addDomRules();
	// ------------------------------------------------------------------------
	void deleteAtoms(uint32 start);
	PrgAtom* getTrueAtom() const { return atoms_[0]; }
	RuleBuilder rule_;        // temporary: active rule
	AtomState   atomState_;   // which atoms appear in the active rule?
	IndexMap    bodyIndex_;   // hash -> body id
	IndexMap    disjIndex_;   // hash -> disjunction id
	IndexMap    domEqIndex_;  // maps eq atoms modified by dom heuristic to aux vars
	BodyList    bodies_;      // all bodies
	AtomList    atoms_;       // all atoms
	DisjList    disjunctions_;// all (head) disjunctions
	MinList     minimize_;    // list of minimize rules
	RuleList    extended_;    // extended rules to be translated
	ShowVec     show_;        // shown atoms/conditions
	VarVec      initialSupp_; // bodies that are (initially) supported
	VarVec      propQ_;       // assigned atoms
	VarVec      frozen_;      // list of frozen atoms
	NonHcfSet   nonHcfs_;     // set of non-hcf sccs
	TheoryData* theory_;      // optional map of theory data
	AtomRange   input_;       // input atoms of current step
	int         statsId_;     // which stats to update (0 or 1)
	struct Aux {
		AtomList  scc;          // atoms that are strongly connected
		DomRules  dom;          // list of domain heuristic directives
		AcycRules acyc;         // list of user-defined edges for acyclicity check
		LpLitVec  assume;       // set of assumptions
		VarVec    project;      // atoms in projection directives
		VarVec    external;     // atoms in external directives
	}*          auxData_;     // additional state for handling extended constructs
	struct Incremental  {
		Incremental();
		uint32    startScc;     // first valid scc number in this iteration
		VarVec    unfreeze;     // list of atoms to unfreeze in this step
		VarVec    doms;         // list of atom variables with domain modification
	}*          incData_;     // additional state for handling incrementally defined programs
	AspOptions  opts_;        // preprocessing
};
//! Returns the internal solver literal that is associated with the given atom literal.
/*!
 * \pre The prg is frozen and atomLit is a known atom in prg.
 */
inline Literal solverLiteral(const LogicProgram& prg, Potassco::Lit_t atomLit) {
	CLASP_ASSERT_CONTRACT(prg.frozen() && prg.validAtom(Potassco::atom(atomLit)));
	return prg.getLiteral(Potassco::id(atomLit));
}
//! Adapts a LogicProgram object to the Potassco::AbstractProgram interface.
class LogicProgramAdapter : public Potassco::AbstractProgram {
public:
	LogicProgramAdapter(LogicProgram& prg);
	void initProgram(bool inc);
	void beginStep();
	void endStep();
	void rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body);
	void rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, Potassco::Weight_t bound, const Potassco::WeightLitSpan& body);
	void minimize(Potassco::Weight_t prio, const Potassco::WeightLitSpan& lits);
	void project(const Potassco::AtomSpan& atoms);
	void output(const Potassco::StringSpan& str, const Potassco::LitSpan& cond);
	void external(Potassco::Atom_t a, Potassco::Value_t v);
	void assume(const Potassco::LitSpan& lits);
	void heuristic(Potassco::Atom_t a, Potassco::Heuristic_t t, int bias, unsigned prio, const Potassco::LitSpan& cond);
	void acycEdge(int s, int t, const Potassco::LitSpan& cond);
	void theoryTerm(Potassco::Id_t termId, int number);
	void theoryTerm(Potassco::Id_t termId, const Potassco::StringSpan& name);
	void theoryTerm(Potassco::Id_t termId, int cId, const Potassco::IdSpan& args);
	void theoryElement(Potassco::Id_t elementId, const Potassco::IdSpan& terms, const Potassco::LitSpan& cond);
	void theoryAtom(Potassco::Id_t atomOrZero, Potassco::Id_t termId, const Potassco::IdSpan& elements);
	void theoryAtom(Potassco::Id_t atomOrZero, Potassco::Id_t termId, const Potassco::IdSpan& elements, Potassco::Id_t op, Potassco::Id_t rhs);
protected:
	Asp::LogicProgram* lp_;
	bool               inc_;
};
//@}

} } // end namespace Asp
#endif
clasp-3.2.2/libclasp/clasp/logic_program_types.h000066400000000000000000000655571304134206100217500ustar00rootroot00000000000000//
// Copyright (c) 2006-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_LOGIC_PROGRAM_TYPES_H_INCLUDED
#define CLASP_LOGIC_PROGRAM_TYPES_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif
/*!
 * \file
 * \brief Basic types for working with a logic program.
 */
#include 
#include 
#include 
#include 
namespace Potassco {
	typedef Clasp::PodVector::type       LitVec;
	typedef Clasp::PodVector::type WLitVec;
}
namespace Clasp {
class ClauseCreator;
using Potassco::idMax;
namespace Asp {
typedef PodVector::type AtomList;
typedef PodVector::type BodyList;
typedef PodVector::type DisjList;
const   ValueRep value_weak_true = 3; /**< true but no proof */
using Potassco::Atom_t;
using Potassco::Id_t;
/*!
 * \addtogroup asp
 */
//@{
//! A node of a program-dependency graph.
/*!
 * A node represents a relevant part in a logic program. Each node
 * has at least a literal and a value.
 */
class PrgNode {
public:
	//! Supported node types.
	enum Type { Atom = 0u, Body = 1u, Disj = 2u };
	static const uint32 noScc  = (1u << 27)-1;
	static const uint32 noNode = (1u << 28)-1;
	static const uint32 noLit  = 1;
	//! Creates a new node that corresponds to a literal that is false.
	explicit PrgNode(uint32 id, bool checkScc = true);
	//! Is the node still relevant or removed() resp. eq()?
	bool relevant() const { return eq_ == 0; }
	//! Was the node removed?
	bool removed()  const { return eq_ != 0 && id_ == noNode; }
	//! Ignore the node during scc checking?
	bool ignoreScc()const { return noScc_ != 0;  }
	//! Returns true if this node is equivalent to some other node.
	/*!
	 * If eq() is true, the node is no longer relevant and must not be used any further.
	 * The only sensible operation is to call id() in order to get the id of the node
	 * that is equivalent to this node.
	 */
	bool eq()       const { return eq_ != 0 && id_ != noNode; }
	bool seen()     const { return seen_ != 0; }
	//! Returns true if node has an associated variable in a solver.
	bool hasVar()   const { return litId_ != noLit; }
	//! Returns the variable associated with this node or sentVar if no var is associated with this node.
	Var  var()      const { return litId_ >> 1; }
	//! Returns the literal associated with this node or a sentinel literal if no var is associated with this node.
	Literal  literal()   const { return Literal::fromId(litId_); }
	//! Returns the value currently assigned to this node.
	ValueRep value()     const { return val_; }
	//! Returns the current id of this node.
	uint32   id()        const { return id_;  }
	//! Returns the literal that must be true in order to fulfill the truth-value of this node.
	Literal   trueLit()  const {
		return value() == value_free
			? lit_true()
			: literal() ^ (value() == value_false);
	}

	/*!
	 * \name implementation functions
	 * Low-level implementation functions. Use with care and only if you
	 * know what you are doing!
	 */
	//@{
	void setLiteral(Literal x)   { litId_ = x.id(); }
	void clearLiteral(bool clVal){ litId_ = noLit; if (clVal) val_ = value_free; }
	void setValue(ValueRep v)    { val_   = v; }
	void setEq(uint32 eqId)      { id_    = eqId; eq_ = 1; seen_ = 1; }
	void setIgnoreScc(bool b)    { noScc_ = (uint32)b; }
	void markRemoved()           { if (!eq()) setEq(noNode); }
	void setSeen(bool b)         { seen_  = uint32(b); }
	void resetId(uint32 id, bool seen) {
		id_ = id;
		eq_ = 0;
		seen_ = (uint32)seen;
	}
	bool assignValueImpl(ValueRep v, bool noWeak) {
		if (v == value_weak_true && noWeak) { v = value_true; }
		if (value() == value_free || v == value() || (value() == value_weak_true && v == value_true)) {
			setValue(v);
			return true;
		}
		return v == value_weak_true && value() == value_true;
	}
	//@}
protected:
	uint32 litId_ : 31; // literal-id in solver
	uint32 noScc_ :  1; // ignore during scc checks?
	uint32 id_    : 28; // own id/eq-id/root-id/ufs-id
	uint32 val_   :  2; // assigned value
	uint32 eq_    :  1; // removed or eq to some other node?
	uint32 seen_  :  1; // marked as seen?
private:
	PrgNode(const PrgNode&);
	PrgNode& operator=(const PrgNode&);
};
typedef PrgNode::Type NodeType;
//! An edge of a program-dependency graph.
/*!
 * Currently, clasp distinguishes four types of edges:
 *  - a Normal edge stipulates an implication between body and head,
 *    i.e. tableau-rules FTA and BFA for atoms.
 *  - a Choice edge only stipulates a support.
 *  - a Gamma edge is like a Normal edge that is only considered during
 *    nogood creation but ignored in the dependency graph.
 *  - a GammaChoice edge is like a Gamma edge but only stipulates a support.
 * The head of a rule is either an atom or a disjunction.
 */
struct PrgEdge {
	//! Type of edge.
	enum Type { Normal = 0, Gamma = 1, Choice = 2, GammaChoice = 3 };
	static PrgEdge noEdge() { PrgEdge x; x.rep = UINT32_MAX; return x; }

	template 
	static PrgEdge newEdge(const NT& n, Type eType) {
		// 28-bit node id, 2-bit node type, 2-bit edge type
		PrgEdge x = { (n.id() << 4) | (static_cast(n.nodeType()) << 2) | eType };
		return x;
	}
	//! Returns the id of the adjacent node.
	uint32   node()     const { return rep >> 4; }
	//! Returns the type of this edge.
	Type     type()     const { return Type(rep & 3u); }
	//! Returns the type of adjacent node.
	NodeType nodeType() const { return NodeType((rep >> 2) & 3u); }
	//! Returns true if edge has normal semantic (normal edge or gamma edge).
	bool     isNormal() const { return (rep & 2u) == 0; }
	//! Returns true if edge has choice semantic.
	bool     isChoice() const { return (rep & 2u) != 0; }
	//! Returns true if the edge is a gamma (aux normal) edge.
	bool     isGamma()  const { return (rep & 1u) != 0; }
	//! Returns true if the adjacent node is a body.
	bool     isBody()   const { return nodeType() == PrgNode::Body; }
	//! Returns true if the adjacant node is an atom.
	bool     isAtom()   const { return nodeType() == PrgNode::Atom; }
	//! Returns true if the adjacent node is a disjunction.
	bool     isDisj()   const { return nodeType() == PrgNode::Disj; }
	bool     operator< (PrgEdge rhs) const { return rep < rhs.rep; }
	bool     operator==(PrgEdge rhs) const { return rep == rhs.rep; }
	uint32 rep;
};

typedef PrgEdge::Type               EdgeType;
typedef const PrgEdge*              EdgeIterator;
typedef bk_lib::pod_vector EdgeVec;
inline bool isChoice(EdgeType t) { return t >= PrgEdge::Choice;  }

using Potassco::Body_t;
using Potassco::Head_t;
using Potassco::WeightLitSpan;
typedef Potassco::Rule_t Rule;
//! A class for translating extended rules to normal rules.
class RuleTransform {
public:
	//! Interface that must be implemented to get the result of a transformation.
	struct ProgramAdapter {
		virtual Atom_t newAtom() = 0;
		virtual void addRule(const Rule& r) = 0;
	protected: ~ProgramAdapter() {}
	};
	//! Supported transformation strategies.
	enum Strategy { strategy_default, strategy_select_no_aux, strategy_split_aux };
	RuleTransform(ProgramAdapter& prg);
	RuleTransform(LogicProgram& prg);
	~RuleTransform();
	//! Transforms the given (extended) rule to a set of normal rules.
	uint32 transform(const Rule& r, Strategy s = strategy_default);
private:
	RuleTransform(const RuleTransform&);
	RuleTransform& operator=(const RuleTransform&);
	struct Impl;
	Impl* impl_;
};

//! A set of flags used during rule simplification.
class AtomState {
public:
	static const uint8 pos_flag    = 0x1u; //!< In positive body of active rule
	static const uint8 neg_flag    = 0x2u; //!< In negative body of active rule
	static const uint8 head_flag   = 0x4u; //!< In normal head of active rule
	static const uint8 choice_flag = 0x8u; //!< In choice head of active rule
	static const uint8 disj_flag   = 0x10u;//!< In disjunctive head of active rule
	static const uint8 rule_mask   = 0x1Fu;//!< In active rule
	static const uint8 fact_flag   = 0x20u;//!< Atom is a fact (sticky)
	static const uint8 false_flag  = 0x40u;//!< Atom is false  (sticky)
	static const uint8 simp_mask   = 0x7fu;//!< In active rule or assigned
	static const uint8 dom_flag    = 0x80u;//!< Var of atom is a dom var (sticky)
	AtomState() {}
	void  swap(AtomState& o) { state_.swap(o.state_); }
	//! Does t.node() appear in the head of the active rule?
	bool  inHead(PrgEdge t)         const { return isSet(t.node(), headFlag(t)); }
	bool  inHead(Atom_t atom)       const { return isSet(atom, head_flag); }
	//! Does p appear in the body of the active rule?
	bool  inBody(Literal p)         const { return isSet(p.var(), pos_flag+p.sign()); }
	bool  isSet(Var v, uint8 f)     const { return v < state_.size() && (state_[v] & f) != 0; }
	bool  isFact(Var v)             const { return isSet(v, fact_flag); }
	//! Mark v as a head of the active rule.
	void  addToHead(Atom_t v)             { set(v, head_flag); }
	void  addToHead(PrgEdge t)            { set(t.node(), headFlag(t)); }
	//! Mark p as a literal contained in the active rule.
	void  addToBody(Literal p)            { set(p.var(), pos_flag+p.sign()); }

	void  set(Var v, uint8 f)             { grow(v); state_[v] |= f; }
	void  clear(Var v, uint8 f)           { if (v < state_.size()) { state_[v] &= ~f; } }
	void  clearRule(Var v)                { clear(v, rule_mask); }
	void  clearHead(PrgEdge t)            { clear(t.node(), headFlag(t)); }
	void  clearBody(Literal p)            { clear(p.var(), pos_flag+p.sign()); }
	void  resize(uint32 sz)               { state_.resize(sz); }

	template 
	bool  allMarked(IT first, IT last, uint8 f) const {
		for (; first != last; ++first) {
			if (!isSet(*first, f)) return false;
		}
		return true;
	}
	bool  inBody(const Literal* first, const Literal* last) const {
		bool all = true;
		for (; first != last && (all = inBody(*first)) == true; ++first) { ; }
		return all;
	}
private:
	typedef PodVector::type StateVec;
	void  grow(Var v)                { if (v >= state_.size()) { state_.resize(v+1); } }
	uint8 headFlag(PrgEdge t) const  {
		return t.isAtom() ? (head_flag << uint8(t.isChoice())) : disj_flag;
	}
	StateVec state_;
};

//! A head node of a program-dependency graph.
/*!
 * A head node is either an atom or a disjunction
 * and stores its possible supports.
 */
class PrgHead : public PrgNode {
public:
	enum Simplify { no_simplify = 0, force_simplify = 1 };
	typedef EdgeIterator sup_iterator;

	//! Is the head part of the (simplified) program?
	bool         inUpper()    const  { return relevant() && upper_ != 0;  }
	//! Is this head an atom?
	bool         isAtom()     const  { return isAtom_ != 0; }
	//! Number of supports (rules) for this head.
	uint32       supports()   const  { return supports_.size();  }
	sup_iterator supps_begin()const  { return supports_.begin(); }
	sup_iterator supps_end()  const  { return supports_.end();   }
	//! External atom (or defined in a later incremental step)?
	bool         frozen()     const  { return freeze_ != uint32(freeze_no); }
	//! If frozen(), value to assume during solving.
	ValueRep     freezeValue()const  { return static_cast(freeze_ - uint32(freeze_ != 0)); }
	//! If frozen(), literal to assume during solving.
	Literal      assumption() const  { return freeze_ > uint32(freeze_free) ? literal() ^ (freeze_ == freeze_false) : lit_true(); }
	//! Adds r as support edge for this node.
	void         addSupport(PrgEdge r){ addSupport(r, force_simplify); }
	void         addSupport(PrgEdge r, Simplify s);
	//! Removes r from the head's list of supports.
	void         removeSupport(PrgEdge r);
	void         clearSupports();
	void         clearSupports(EdgeVec& to) { to.swap(supports_); clearSupports(); }
	//! Removes any superfluous/irrelevant supports.
	bool         simplifySupports(LogicProgram& prg, bool strong, uint32* numDiffSupps = 0);
	//! Assigns the value v to this head.
	bool         assignValue(ValueRep v) { return assignValueImpl(v, ignoreScc() && !frozen()); }
	/*!
	 * \name implementation functions
	 * Low-level implementation functions. Use with care and only if you
	 * know what you are doing!
	 */
	//@{
	void         setInUpper(bool b)   { upper_ = (uint32)b; }
	void         markDirty()          { dirty_ = 1; }
	void         assignVar(LogicProgram& prg, PrgEdge it, bool allowEq = true);
	NodeType     nodeType()  const    { return isAtom() ? PrgNode::Atom : PrgNode::Disj; }
	//@}
protected:
	enum FreezeState { freeze_no = 0u, freeze_free = 1u, freeze_true = 2u, freeze_false = 3u };
	//! Creates a new node that corresponds to a literal that is false.
	explicit PrgHead(uint32 id, NodeType t, uint32 data = 0, bool checkScc = true);
	bool      backpropagate(LogicProgram& prg, ValueRep val, bool bpFull);
	EdgeVec supports_;  // possible supports (body or disjunction)
	uint32 data_  : 27; // number of atoms in disjunction or scc of atom
	uint32 upper_ :  1; // in (simplified) program?
	uint32 dirty_ :  1; // is list of supports dirty?
	uint32 freeze_:  2; // incremental freeze state
	uint32 isAtom_:  1; // is this head an atom?
};

//! An atom in a logic program.
/*!
 * An atom stores the list of bodies depending on it.
 * Furthermore, once strongly-connected components are identified,
 * atoms store their SCC-number. All trivial SCCs are represented
 * with the special SCC-number PrgNode::noScc.
 */
class PrgAtom : public PrgHead {
public:
	enum Dependency { dep_pos = 0, dep_neg = 1, dep_all = 2 };
	typedef LitVec::const_iterator dep_iterator;
	explicit PrgAtom(uint32 id, bool checkScc = true);
	NodeType     nodeType() const { return PrgNode::Atom; }
	//! Strongly connected component of this node.
	uint32       scc() const { return data_; }
	//! If eq(), stores the literal that is eq to this atom.
	Literal      eqGoal(bool sign) const;
	//! Returns true if atom belongs to a disjunctive head.
	bool         inDisj()   const;
	/*!
	 * \name forward dependencies (bodies containing this atom)
	 */
	//@{
	dep_iterator deps_begin()                   const { return deps_.begin(); }
	dep_iterator deps_end()                     const { return deps_.end();   }
	bool         hasDep(Dependency d)           const;
	void         addDep(Id_t bodyId, bool pos);
	void         removeDep(Id_t bodyId, bool pos);
	void         clearDeps(Dependency d);
	//@}

	/*!
	 * \name implementation functions
	 * Low-level implementation functions. Use with care and only if you
	 * know what you are doing!
	 */
	//@{
	void setEqGoal(Literal x);
	bool propagateValue(LogicProgram& prg, bool backprop);
	bool addConstraints(const LogicProgram& prg, ClauseCreator& c);
	void setScc(uint32 scc)    { data_ = scc; }
	void markFrozen(ValueRep v){ freeze_ = v + freeze_free; }
	void clearFrozen()         { freeze_ = freeze_no; markDirty(); }
	//@}
private:
	LitVec deps_; // bodies depending on this atom
};

//! A (rule) body in a logic program.
class PrgBody : public PrgNode {
public:
	typedef EdgeIterator   head_iterator;
	typedef const Literal* goal_iterator;

	//! Creates a new body node and (optionally) connects it to its predecessors (i.e. atoms).
	/*!
	 * \param prg     The program in which the new body is used.
	 * \param id      The id for the new body node.
	 * \param rule    The rule for which a body node is to be created.
	 * \param pos     Positive body size.
	 * \param addDeps If true, add an edge between each atom subgoal and the new node.
	 */
	static PrgBody* create(LogicProgram& prg, uint32 id, const Rule& rule, uint32 pos, bool addDeps);
	//! Destroys a body node created via create().
	void     destroy();
	Body_t   type()  const { return Body_t(static_cast(type_)); }
	//! Returns the number of atoms in the body.
	uint32   size()  const { return size_; }
	bool     noScc() const { return size() == 0 || goal(0).sign(); }
	//! Returns the bound of this body, or size() if the body is a normal body.
	weight_t bound() const { if (type() == Body_t::Normal) return (weight_t)size(); else return hasWeights() ? sumData()->bound : aggData().bound; }
	//! Returns the sum of the subgoals weights, or size() if the body is not a sum with weights.
	weight_t sumW()  const { return static_cast(!hasWeights() ? (weight_t)size() : sumData()->sumW); }
	//! Returns the idx'th subgoal as a literal.
	Literal  goal(uint32 idx)  const { assert(idx < size()); return *(goals_begin()+idx); }
	//! Returns the weight of the idx'th subgoal.
	weight_t weight(uint32 idx)const { assert(idx < size()); return !hasWeights() ? 1 : sumData()->weights[idx]; }
	//! Returns true if the body node is supported.
	/*!
	 * A normal body is supported, iff all of its positive subgoals are supported.
	 * A count/sum body is supported if the sum of the weights of the supported positive +
	 * the sum of the negative weights is >= lowerBound().
	 */
	bool     isSupported() const { return unsupp_ <= 0; }
	//! Returns true if this body defines any head.
	bool     hasHeads()    const { return isSmallHead() ? head_ != 0 : !largeHead()->empty(); }
	bool     inRule()      const { return hasHeads() || freeze_; }

	head_iterator heads_begin() const { return isSmallHead() ? smallHead()       : largeHead()->begin(); }
	head_iterator heads_end()   const { return isSmallHead() ? smallHead()+head_ : largeHead()->end(); }
	goal_iterator goals_begin() const { return const_cast(this)->goals_begin(); }
	goal_iterator goals_end()   const { return goals_begin() + size(); }
	//! Adds a rule edge between this body and the given head.
	/*!
	 * \note
	 *   The function also adds a corresponding back edge to the head.
	 * \note
	 *   Adding a head invalidates the set property for the heads of this body.
	 *   To restore it, call simplifyHeads()
	 */
	void     addHead(PrgHead* h, EdgeType t);
	//! Simplifies the heads of this body and establishes set property.
	/*!
	 * Removes superfluous heads and sets the body to false if for some atom a
	 * in the head of this body B, Ta -> FB. In that case, all heads atoms are removed, because
	 * a false body can't define any atom.
	 * If strong is true, removes head atoms that are not associated with a variable.
	 * \return
	 *    setValue(value_false) if setting a head of this body to true would
	 *    make the body false (i.e. the body is a selfblocker). Otherwise, true.
	 */
	bool     simplifyHeads(LogicProgram& prg, bool strong);
	bool     mergeHeads(LogicProgram& prg, PrgBody& heads, bool strong, bool simplify = true);
	void     removeHead(PrgHead* h, EdgeType t);
	bool     hasHead(PrgHead* h, EdgeType t) const;
	//! Simplifies the body, i.e. its predecessors-lists.
	/*!
	 * - removes true/false atoms from B+/B- resp.
	 * - removes/merges duplicate subgoals
	 * - checks whether body must be false (e.g. contains false/true atoms in B+/B- resp. or contains p and ~p)
	 *
	 * \pre prg.getBody(id()) == this
	 *
	 * \param[in] prg    The program containing this body.
	 * \param[in] strong If true, treats atoms that have no variable associated as false.
	 * \param[out] eqId  The id of a body in prg that is equivalent to this body.
	 *
	 * \return
	 *  - true if simplification was successful
	 *  - false if simplification detected a conflict
	 */
	bool     simplifyBody(LogicProgram& prg, bool strong, uint32* eqId = 0);
	//! Calls simplifyBody() and/or simplifyHeads() if necessary.
	bool     simplify(LogicProgram& prg, bool strong, uint32* eqId = 0) {
		return simplifyBody(prg, strong, eqId) && simplifyHeads(prg, strong);
	}
	bool     toData(const LogicProgram& prg, Potassco::RuleBuilder& out) const;
	//! Notifies the body node about the fact that its positive subgoal v is supported.
	/*!
	 * \return true if the body is now also supported, false otherwise.
	 */
	bool     propagateSupported(Var /* v */);
	//! Propagates the assignment of subgoal p.
	bool     propagateAssigned(LogicProgram& prg, Literal p, ValueRep v);
	//! Propagates the assignment of a head.
	bool     propagateAssigned(LogicProgram& prg, PrgHead* h, EdgeType t);
	//! Propagates the value of this body.
	bool     propagateValue(LogicProgram& prg, bool backprop);
	bool     propagateValue(LogicProgram& prg);
	bool     addConstraints(const LogicProgram& prg, ClauseCreator& c);
	void     markDirty()      { sBody_ = 1; }
	void     markHeadsDirty() { sHead_ = 1; }
	void     markFrozen()     { freeze_= 1; }
	void     clearHeads();
	bool     resetSupported();
	void     assignVar(LogicProgram& prg);
	bool     assignValue(ValueRep v) { return assignValueImpl(v, noScc()); }
	uint32   scc(const LogicProgram& prg) const;
	bool     hasWeights()  const { return type() == Body_t::Sum; }
	void     clearRule(AtomState& rs) const {
		for (head_iterator it = heads_begin(), end = heads_end(); it != end; ++it) {
			rs.clearRule(it->node());
		}
		for (const Literal* it = goals_begin(), *end = it + size(); it != end; ++it) {
			rs.clearRule(it->var());
		}
	}
	NodeType nodeType() const  { return PrgNode::Body; }
private:
	static const uint32 maxSize = (1u<<26)-1;
	typedef unsigned char byte_t;
CLASP_WARNING_BEGIN_RELAXED
	struct SumData {
		enum { LIT_OFFSET = sizeof(void*)/sizeof(uint32) };
		static SumData* create(uint32 size, weight_t bnd, weight_t ws);
		void     destroy();
		weight_t bound;
		weight_t sumW;
		weight_t weights[0];
	};
	struct Agg {
		union {
			SumData* sum;
			weight_t bound;
		};
		Literal lits[0];
	};
	struct Norm { Literal lits[0]; };
	PrgBody(uint32 id, LogicProgram& prg, const Potassco::LitSpan& lits, uint32 pos, bool addDeps);
	PrgBody(uint32 id, LogicProgram& prg, const Potassco::Sum_t& sum, bool hasWeights, uint32 pos, bool addDeps);
	void init(Body_t t, uint32 sz);
	~PrgBody();
	uint32   findLit(const LogicProgram& prg, Literal p) const;
	bool     normalize(const LogicProgram& prg, weight_t bound, weight_t sumW, weight_t reachW, uint32& hashOut);
	void     prepareSimplifyHeads(LogicProgram& prg, AtomState& rs);
	bool     simplifyHeadsImpl(LogicProgram& prg, PrgBody& target, AtomState& rs, bool strong);
	bool     superfluousHead(const LogicProgram& prg, const PrgHead* head, PrgEdge it, const AtomState& rs) const;
	bool     blockedHead(PrgEdge it, const AtomState& rs) const;
	void     addHead(PrgEdge h);
	bool     eraseHead(PrgEdge h);
	bool     isSmallHead() const { return head_ != 3u; }
	byte_t*  data()        const { return const_cast(static_cast(data_)); }
	PrgEdge* smallHead()   const { return const_cast(headData_.sm); }
	EdgeVec* largeHead()   const { return headData_.ext; }
	SumData* sumData()     const { return aggData().sum;}
	Agg&     aggData()     const { return *reinterpret_cast(data()); }
	Literal* goals_begin()       { return type() == Body_t::Normal ? reinterpret_cast(data())->lits  : aggData().lits; }
	Literal* goals_end()         { return goals_begin() + size(); }

	uint32    size_   : 25; // |B|
	uint32    head_   :  2; // simple or extended head?
	uint32    type_   :  2; // body type
	uint32    sBody_  :  1; // simplify body?
	uint32    sHead_  :  1; // simplify head?
	uint32    freeze_ :  1; // keep body even if it does not occur in a rule?
	weight_t  unsupp_;      // <= 0 -> body is supported
	union Head {
		PrgEdge  sm[2];
		EdgeVec* ext;
	}         headData_;    // successors of this body
	byte_t    data_[0];     // empty or one of Agg|Norm
CLASP_WARNING_END_RELAXED
};
//! The head of a disjunctive rule.
class PrgDisj : public PrgHead {
public:
	typedef const Var* atom_iterator;
	//! Constructor for disjunctions.
	static PrgDisj* create(uint32 id, const Potassco::AtomSpan& head);
	//! Destroys a disjunction created via create().
	void          destroy();
	void          detach(LogicProgram& prg);
	//! Number of atoms in disjunction.
	uint32        size()               const { return data_; }
	atom_iterator begin()              const { return atoms_; }
	atom_iterator end()                const { return atoms_ + size(); }
	//! Propagates the assignment of an atom in this disjunction.
	bool          propagateAssigned(LogicProgram& prg, PrgHead* at, EdgeType t);
private:
	explicit PrgDisj(uint32 id, const Potassco::AtomSpan& head);
	~PrgDisj();
CLASP_WARNING_BEGIN_RELAXED
	Var atoms_[0]; // atoms in disjunction
CLASP_WARNING_END_RELAXED
};

inline ValueRep getMergeValue(const PrgNode* lhs, const PrgNode* rhs) {
	return static_cast(std::min(static_cast(lhs->value()-1), static_cast(rhs->value()-1)) + 1);
}

template 
bool mergeValue(NT* lhs, NT* rhs){
	ValueRep mv = getMergeValue(lhs, rhs);
	return (lhs->value() == mv || lhs->assignValue(mv))
	  &&   (rhs->value() == mv || rhs->assignValue(mv));
}

//! A class for computing strongly connected components of the positive atom-body dependency graph.
class SccChecker {
public:
	SccChecker(LogicProgram& prg, AtomList& sccAtoms, uint32 startScc);
	uint32 sccs()              const { return sccs_; }
	void  visit(PrgBody* body)       { visitDfs(body, PrgNode::Body); }
	void  visit(PrgAtom* atom)       { visitDfs(atom, PrgNode::Atom); }
	void  visit(PrgDisj* disj)       { visitDfs(disj, PrgNode::Disj); }
private:
	struct Call {
		uintp    node;
		uint32   min;
		uint32   next;
	};
	typedef PodVector::type  CallStack;
	typedef PodVector::type NodeStack;
	static uintp    packNode(PrgNode* n, NodeType t)  { return reinterpret_cast(n) + uintp(t); }
	static PrgNode* unpackNode(uintp n)               { return reinterpret_cast(n & ~uintp(3u));}
	static bool     isNode(uintp n, NodeType t)       { return (n & 3u) == uintp(t); }
	bool  doVisit(PrgNode* n, bool seen = true) const { return !n->ignoreScc() && n->relevant() && n->hasVar() && (!seen || !n->seen()); }
	void  visitDfs(PrgNode* n, NodeType t);
	bool  recurse(Call& c);
	bool  onNode(PrgNode* n, NodeType t, Call& c, uint32 data);
	void  addCall(PrgNode* n, NodeType t, uint32 next, uint32 min = 0) {
		Call c = {packNode(n, t), min, next};
		callStack_.push_back(c);
	}
	CallStack     callStack_;
	NodeStack     nodeStack_;
	LogicProgram* prg_;
	AtomList*     sccAtoms_;
	uint32        count_;
	uint32        sccs_;
};
//! A set of ids of strongly connected components having at least one head-cycle.
struct NonHcfSet : private PodVector::type {
public:
	typedef PodVector::type base_type;
	typedef base_type::const_iterator const_iterator;
	using base_type::begin;
	using base_type::end;
	using base_type::size;
	NonHcfSet() : config(0) {}
	void add(uint32 scc) {
		iterator it = std::lower_bound(begin(), end(), scc);
		if (it == end() || *it != scc) { insert(it, scc); }
	}
	bool find(uint32 scc) const {
		const_iterator it = scc != PrgNode::noScc ? std::lower_bound(begin(), end(), scc) : end();
		return it != end() && *it == scc;
	}
	Configuration* config;
};
//@}
} }
#endif
clasp-3.2.2/libclasp/clasp/lookahead.h000066400000000000000000000216071304134206100176130ustar00rootroot00000000000000//
// Copyright (c) 2009, 2012 Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_LOOKAHEAD_H_INCLUDED
#define CLASP_LOOKAHEAD_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

/*!
 * \file
 * \brief Defines lookahead related types.
 *
 * Lookahead can be used as a post propagator (e.g. failed-literal detection) and
 * optionally as an heuristic.
 */

#include 
#include 
namespace Clasp {
/*!
 * \addtogroup propagator
 */
//@{

//! Type used to store lookahead-information for one variable.
struct VarScore {
	VarScore() { clear(); }
	void clear() { std::memset(this, 0, sizeof(VarScore)); }
	//! Mark literal p as dependent.
	void setSeen( Literal p )    { seen_ |= uint32(p.sign()) + 1; }
	//! Is literal p dependent?
	bool seen(Literal p) const   { return (seen_ & (uint32(p.sign())+1)) != 0; }
	//! Is this var dependent?
	bool seen()          const   { return seen_ != 0; }
	//! Mark literal p as tested during lookahead.
	void setTested( Literal p )  { tested_ |= uint32(p.sign()) + 1; }
	//! Was literal p tested during lookahead?
	bool tested(Literal p) const { return (tested_ & (uint32(p.sign())+1)) != 0; }
	//! Was some literal of this var tested?
	bool tested()          const { return tested_ != 0; }
	//! Were both literals of this var tested?
	bool testedBoth()      const { return tested_  == 3; }

	//! Sets the score for literal p to value and marks p as tested.
	void setScore(Literal p, LitVec::size_type value) {
		if (value > (1U<<14)-1) value = (1U<<14)-1;
		if (p.sign()) nVal_ = uint32(value);
		else          pVal_ = uint32(value);
		setTested(p);
	}
	//! Sets the score of a dependent literal p to min(sc, current score).
	void setDepScore(Literal p, uint32 sc) {
		if (!seen(p) || score(p) > sc) {
			if (sc > (1U<<14)-1) sc = (1U<<14)-1;
			if (p.sign()) nVal_ = std::min(uint32(nVal_-(nVal_==0)), sc);
			else          pVal_ = std::min(uint32(pVal_-(pVal_==0)), sc);
		}
	}
	//! Returns the score for literal p.
	uint32 score(Literal p) const { return p.sign() ? nVal_ : pVal_; }
	//! Returns the scores of the two literals of a variable.
	/*!
	 * \param[out] mx The maximum score.
	 * \param[out] mn The minimum score.
	 */
	void score(uint32& mx, uint32& mn) const {
		if (nVal_ > pVal_) {
			mx = nVal_;
			mn = pVal_;
		}
		else {
			mx = pVal_;
			mn = nVal_;
		}
	}
	//! Returns the sign of the literal that has the higher score.
	bool prefSign() const { return nVal_ > pVal_; }

	uint32 nVal() const { return nVal_; }
	uint32 pVal() const { return pVal_; }
private:
	uint32 pVal_  : 14;
	uint32 nVal_  : 14;
	uint32 seen_  : 2;
	uint32 tested_: 2;
};

//! A small helper class used to score the result of a lookahead operation.
struct ScoreLook {
	enum Mode { score_max, score_max_min };
	typedef PodVector::type VarScores; /**< A vector of variable-scores */
	ScoreLook() : best(0), mode(score_max), addDeps(true), nant(false) {}
	bool    validVar(Var v) const { return v < score.size(); }
	void    scoreLits(const Solver& s, const Literal* b, const Literal *e);
	void    clearDeps();
	uint32  countNant(const Solver& s, const Literal* b, const Literal *e) const;
	bool    greater(Var lhs, Var rhs)const;
	bool    greaterMax(Var x, uint32 max) const {
		return score[x].nVal() > max || score[x].pVal() > max;
	}
	bool    greaterMaxMin(Var lhs, uint32 max, uint32 min) const {
		uint32 lhsMin, lhsMax;
		score[lhs].score(lhsMax, lhsMin);
		return lhsMin > min || (lhsMin == min && lhsMax > max);
	}
	VarScores score;  //!< score[v] stores lookahead score of v
	VarVec    deps;   //!< Tested vars and those that follow from them.
	VarType   types;  //!< Var types to consider.
	Var       best;   //!< Var with best score among those in deps.
	Mode      mode;   //!< Score mode to apply.
	bool      addDeps;//!< Add/score dependent vars?
	bool      nant;   //!< Score only atoms in NegAnte(P)?
};

class UnitHeuristic;

//! Lookahead extends propagation with failed-literal detection.
/*!
 * The class provides different kinds of one-step lookahead.
 * Atom- and body-lookahead are uniform lookahead types, where
 * either only atoms or bodies are tested. Hybrid-lookahead tests
 * both types of vars but each only in a single phase. I.e. atoms
 * are only tested negatively while bodies are tested positively.
 */
class Lookahead : public PostPropagator {
public:
	//! Set of parameters to configure lookahead.
	struct Params {
		Params(VarType t = Var_t::Atom) : type(t), lim(0), topLevelImps(true), restrictNant(false) {}
		Params& lookahead(VarType t){ type         = t; return *this; }
		Params& addImps(bool b)     { topLevelImps = b; return *this; }
		Params& nant(bool b)        { restrictNant = b; return *this; }
		Params& limit(uint32 x)     { lim = x;          return *this; }
		VarType type;
		uint32  lim;
		bool    topLevelImps;
		bool    restrictNant;
	};
	static bool isType(uint32 t) { return t != 0 && t <= Var_t::Hybrid; }
	/*!
	 * \param p Lookahead parameters to use.
	 */
	explicit Lookahead(const Params& p);
	~Lookahead();

	bool    init(Solver& s);
	//! Clears the lookahead list.
	void    clear();
	//! Returns true if lookahead list is empty.
	bool    empty() const { return head()->next == head_id; }
	//! Adds literal p to the lookahead list.
	void    append(Literal p, bool testBoth);
	//! Executes a single-step lookahead on all vars in the loookahead list.
	bool    propagateFixpoint(Solver& s, PostPropagator*);
	//! Returns PostPropagator::priority_reserved_look.
	uint32  priority() const;
	void    destroy(Solver* s, bool detach);
	ScoreLook score; //!< State of last lookahead operation.
	//! Returns "best" literal w.r.t scoring of last lookahead or lit_true() if no such literal exists.
	Literal heuristic(Solver& s);
	void    detach(Solver& s);
	bool    hasLimit() const { return limit_ != 0; }
protected:
	bool propagateLevel(Solver& s); // called by propagate
	void undoLevel(Solver& s);
	bool test(Solver& s, Literal p);
private:
	typedef uint32 NodeId;
	enum { head_id = NodeId(0), undo_id = NodeId(1) };
	struct LitNode {
		LitNode(Literal x) : lit(x), next(UINT32_MAX) {}
		Literal  lit;
		NodeId   next;
	};
	typedef PodVector::type  UndoStack;
	typedef PodVector::type LookList;
	typedef UnitHeuristic*           HeuPtr;
	void splice(NodeId n);
	LitNode* node(NodeId n) { return &nodes_[n]; }
	LitNode* head()         { return &nodes_[head_id]; } // head of circular candidate list
	LitNode* undo()         { return &nodes_[undo_id]; } // head of undo list
	bool     checkImps(Solver& s, Literal p);
	const LitNode* head() const { return &nodes_[head_id]; }
	LookList   nodes_; // list of literals to test
	UndoStack  saved_; // stack of undo lists
	LitVec     imps_;  // additional top-level implications
	NodeId     last_;  // last candidate in list; invariant: node(last_)->next == head_id;
	NodeId     pos_;   // current lookahead start position
	uint32     top_;   // size of top-level
	uint32     limit_; // stop lookahead after this number of applications
};
//@}

//! Heuristic that uses the results of lookahead.
/*!
 * \ingroup heuristic
 * The heuristic uses a Lookahead post propagator to select a literal with the highest score,
 * where the score is determined by counting assignments made during
 * failed-literal detection. For hybrid_lookahead, the heuristic selects the literal that
 * derived the most literals. On the other hand, for uniform_lookahead the heuristic is similar to
 * the smodels lookahead heuristic and selects the literal that maximizes the minimum.
 * \see Patrik Simons: "Extending and Implementing the Stable Model Semantics" for a
 * detailed description of the lookahead heuristic.
 *
 * \note The heuristic might itself apply some lookahead but only on variables that
 *       did not fail in a previous call to Lookahead::propagateFixpoint(). I.e. if
 *       priorities are correct for all post propagators in s, the lookahead operations can't fail.
 *
 * \note If no Lookahead post propagator exists in the solver, the heuristic selects the first free variable!
 */
class UnitHeuristic : public SelectFirst {
public:
	UnitHeuristic();
	//! Decorates the heuristic given in other with temporary lookahead.
	static UnitHeuristic* restricted(DecisionHeuristic* other);
	void    endInit(Solver& /* s */);
	Literal doSelect(Solver& s);
};

}
#endif
clasp-3.2.2/libclasp/clasp/minimize_constraint.h000066400000000000000000000610501304134206100217450ustar00rootroot00000000000000//
// Copyright (c) 2010-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_MINIMIZE_CONSTRAINT_H_INCLUDED
#define CLASP_MINIMIZE_CONSTRAINT_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif
/*!
* \file
* \brief Types and functions for implementing minimization constraints.
*/
#include 
#include 
#include 
#include 

namespace Clasp {
class MinimizeConstraint;
class WeightConstraint;

//! Supported minimization modes.
/*!
 * \ingroup constraint
 * Defines the possible minimization modes used during solving.
 * If optimize is used, a valid candidate model is a solution that is
 * strictly smaller than all previous solutions. Otherwise,
 * solutions with costs no greater than a fixed bound are considered valid.
 */
struct MinimizeMode_t {
	enum Mode {
		ignore    = 0, //!< Ignore optimize statements during solving.
		optimize  = 1, //!< Optimize via a decreasing bound.
		enumerate = 2, //!< Enumerate models with cost less or equal to a fixed bound.
		enumOpt   = 3, //!< Enumerate models with cost equal to optimum.
	};
	//! Strategy to use when optimization is active.
	enum Strategy {
		opt_bb = 0, //!< Branch and bound based optimization.
		opt_usc= 1, //!< Unsatisfiable-core based optimization.
	};
	//! Options for branch and bound based optimization.
	enum BBOption {
		bb_step_def  = 0u, //!< Branch and bound with fixed step of size 1.
		bb_step_hier = 1u, //!< Hierarchical branch and bound.
		bb_step_inc  = 2u, //!< Hierarchical branch and bound with increasing steps.
		bb_step_dec  = 3u, //!< Hierarchical branch and bound with decreasing steps.
	};
	//! Options for unsatisfiable-core based optimization.
	enum UscOption {
		usc_preprocess = 1u, //!< Enable (disjoint) preprocessing.
		usc_imp_only   = 2u, //!< Only add constraints for one direction (instead of eq).
		usc_clauses    = 4u, //!< Only add clauses (instead of cardinality constraints).
		usc_stratify   = 8u, //!< Use stratified heuristic for weighted optimization.
	};
	//! Heuristic options common to all optimization strategies.
	enum Heuristic {
		heu_sign  = 1,  //!< Use optimize statements in sign heuristic.
		heu_model = 2,  //!< Apply model heuristic when optimizing.
	};
	static bool supportsSplitting(Strategy s) { return s != opt_usc; }
};
typedef MinimizeMode_t::Mode MinimizeMode;

//! A type holding data (possibly) shared between a set of minimize constraints.
/*!
 * \ingroup shared_con
 */
class SharedMinimizeData {
public:
	typedef SharedMinimizeData ThisType;
	//! A type to represent a weight at a certain level.
	/*!
	 * Objects of this type are used to create sparse vectors of weights. E.g.
	 * a weight vector (w1\@L1, w2\@L3, w3\@L5) is represented as \[\\\\],
	 * where each \-tuple is an object of type LevelWeight.
	 */
	struct LevelWeight {
		LevelWeight(uint32 l, weight_t w) : level(l), next(0), weight(w) {}
		uint32   level : 31; //!< The level of this weight.
		uint32   next  :  1; //!< Does this weight belong to a sparse vector of weights?
		weight_t weight;     //!< The weight at this level.
	};
	//! A type for holding sparse vectors of level weights of a multi-level constraint.
	typedef PodVector::type WeightVec;
	typedef PodVector::type    PrioVec;
	explicit SharedMinimizeData(const SumVec& lhsAdjust, MinimizeMode m = MinimizeMode_t::optimize);
	//! Increases the reference count of this object.
	ThisType*      share()               { ++count_; return this; }
	//! Decreases the object's reference count and destroys it if reference count drops to 0.
	void           release()             { if (--count_ == 0) destroy(); }
	//! Number of minimize statements contained in this constraint.
	uint32         numRules()       const{ return static_cast(adjust_.size()); }
	uint32         maxLevel()       const{ return numRules()-1; }
	static wsum_t  maxBound()            { return INT64_MAX; }
	//! Returns the active minimization mode.
	MinimizeMode   mode()           const{ return mode_; }
	//! Returns true if optimization is active.
	bool           optimize()       const{ return optGen_ ? checkNext() : mode_ != MinimizeMode_t::enumerate; }
	//! Returns the lower bound of level x.
	wsum_t         lower(uint32 x)  const;
	//! Returns the upper bound of level x.
	wsum_t         upper(uint32 x)  const{ return upper()[x]; }
	const wsum_t*  upper()          const{ return &(up_ + (gCount_ & 1u))->front(); }
	//! Returns the sum of level x in the most recent model.
	wsum_t         sum(uint32 x)    const{ return sum()[x]; }
	const wsum_t*  sum()            const{ return (mode_ != MinimizeMode_t::enumerate) ? upper() : &up_[1][0]; }
	//! Returns the adjustment for level x.
	wsum_t         adjust(uint32 x) const{ return adjust_[x]; }
	const wsum_t*  adjust()         const{ return &adjust_[0]; }
	//! Returns the current (ajusted and possibly tentative) optimum for level x.
	wsum_t         optimum(uint32 x)const;
	//! Returns the highest level of the literal with the given index i.
	uint32         level(uint32 i)  const{ return numRules() == 1 ? 0 : weights[lits[i].second].level; }
	//! Returns the most important weight of the literal with the given index i.
	weight_t       weight(uint32 i) const{ return numRules() == 1 ? lits[i].second : weights[lits[i].second].weight; }
	uint32         generation()     const{ return gCount_; }
	//! Returns whether minimization should search for solutions with current or next smaller upper bound.
	bool           checkNext()      const{ return mode() != MinimizeMode_t::enumerate && generation() != optGen_; }
	/*!
	 * \name interface for optimization
	 * If not otherwise specified, the following functions shall not be called concurrently.
	 */
	//@{

	//! Sets the enumeration mode and (optionally) an initial bound.
	/*!
	 * \note If m is MinimizeMode::enumerate, the caller should always
	 * set a bound. Otherwise, *all* solutions are considered valid.
	 */
	bool setMode(MinimizeMode m, const wsum_t* bound = 0, uint32 boundSize = 0);
	bool setMode(MinimizeMode m, const SumVec& bound) { return setMode(m, bound.empty() ? 0 : &bound[0], (uint32)bound.size()); }
	void resetBounds();

	//! Attaches a new minimize constraint to this data object.
	/*!
	 * \param s      Solver in which the new minimize constraint should apply.
	 * \param strat  The optimization strategy to use (see MinimizeMode_t::Strategy).
	 * \param param  Parameter to pass to the optimization strategy.
	 * \param addRef If true, the ref count of the shared object is increased.
	 *               Otherwise, the new minimize constraint inherits the reference to the shared object.
	 */
	MinimizeConstraint* attach(Solver& s, MinimizeMode_t::Strategy strat, uint32 param = 0, bool addRef = true);

	//! Makes opt the new (tentative) optimum.
	/*!
	 * \pre opt is a pointer to an array of size numRules()
	 */
	const SumVec* setOptimum(const wsum_t* opt);
	//! Marks the current tentative optimum as the final optimum.
	/*!
	 * \note Once a final optimum is set, further calls to setOptimum()
	 * are ignored until resetBounds() is called.
	 */
	void          markOptimal();
	//! Sets the lower bound of level lev to low.
	void          setLower(uint32 lev, wsum_t low);
	//! Sets the lower bound of level lev to the maximum of low and the existing value lower(lev).
	/*!
	 * \note This function is thread-safe, i.e., can be called safely from multiple threads.
	 */
	wsum_t        incLower(uint32 lev, wsum_t low);
	//@}

	/*!
	 * \name Arithmetic functions on weights.
	 */
	//@{
	//! Computes lhs += weight(lit).
	void add(wsum_t* lhs, const WeightLiteral& lit) const { if (weights.empty()) *lhs += lit.second; else add(lhs, &weights[lit.second]); }
	void add(wsum_t* lhs, const LevelWeight* w)     const { do { lhs[w->level] += w->weight; } while (w++->next); }
	//! Computes lhs -= weight(lit).
	void sub(wsum_t* lhs, const WeightLiteral& lit, uint32& aLev) const { if (weights.empty()) *lhs -= lit.second; else sub(lhs, &weights[lit.second], aLev); }
	void sub(wsum_t* lhs, const LevelWeight* w, uint32& aLev)     const;
	//! Returns (lhs + weight(lit)) > rhs
	bool imp(wsum_t* lhs, const WeightLiteral& lit, const wsum_t* rhs, uint32& lev) const {
		return weights.empty() ? (*lhs+lit.second) > *rhs : imp(lhs, &weights[lit.second],  rhs, lev);
	}
	bool imp(wsum_t* lhs, const LevelWeight* w, const wsum_t* rhs, uint32& lev) const;
	//! Returns the weight of lit at level lev.
	weight_t weight(const WeightLiteral& lit, uint32 lev) const {
		if (numRules() == 1) { return lit.second * (lev == 0); }
		const LevelWeight* w = &weights[lit.second];
		do { if (w->level == lev) return w->weight; } while (w++->next);
		return 0;
	}
	//@}
private:
	typedef Clasp::Atomic_t::type CounterType;
	typedef Clasp::Atomic_t::type LowerType;
	SumVec       adjust_;  // initial bound adjustments
	SumVec       up_[2];   // buffers for update via "double buffering"
	LowerType*   lower_;   // (unadjusted) lower bound of constraint
	MinimizeMode mode_;    // how to compare assignments?
	CounterType  count_;   // number of refs to this object
	CounterType  gCount_;  // generation count - used when updating optimum
	uint32       optGen_;  // generation of optimal bound
public:
	WeightVec     weights; // sparse vectors of weights - only used for multi-level constraints
	PrioVec       prios;   // (optional): maps levels to original priorities
CLASP_WARNING_BEGIN_RELAXED
	WeightLiteral lits[0]; // (shared) literals - terminated with lit_true()
CLASP_WARNING_END_RELAXED
private:
	~SharedMinimizeData();
	void destroy() const;
	SharedMinimizeData(const SharedMinimizeData&);
	SharedMinimizeData& operator=(const SharedMinimizeData&);
};
//! Helper class for creating minimize constraints.
/*!
 * \ingroup constraint
 */
class MinimizeBuilder {
public:
	typedef SharedMinimizeData SharedData;
	MinimizeBuilder();

	MinimizeBuilder& add(weight_t prio, const WeightLitVec& lits);
	MinimizeBuilder& add(weight_t prio, WeightLiteral lit);
	MinimizeBuilder& add(weight_t prio, weight_t adjust);
	MinimizeBuilder& add(const SharedData& minCon);

	bool empty() const;

	//! Creates a new data object from previously added minimize literals.
	/*!
	 * The function creates a new minimize data object from
	 * the previously added literals to minimize. The returned
	 * object can be used to attach one or more MinimizeConstraints.
	 * \param ctx A ctx object to be associated with the new minmize constraint.
	 * \return A data object representing previously added minimize statements or 0 if empty().
	 * \pre !ctx.frozen()
	 * \post empty()
	 */
	SharedData* build(SharedContext& ctx);

	//! Discards any previously added minimize literals.
	void clear();
private:
	struct MLit {
		MLit(const WeightLiteral& wl, weight_t at) : lit(wl.first), prio(at), weight(wl.second) {}
		Literal  lit;
		weight_t prio;
		weight_t weight;
	};
	struct CmpPrio  { bool operator()(const MLit& lhs, const MLit& rhs) const; };
	struct CmpLit   { bool operator()(const MLit& lhs, const MLit& rhs) const; };
	struct CmpWeight{
		CmpWeight(const SharedData::WeightVec* w) : weights(w) {}
		bool operator()(const MLit& lhs, const MLit& rhs) const;
		const SharedData::WeightVec* weights;
	};
	typedef PodVector::type LitVec;
	void prepareLevels(const Solver& s, SumVec& adjustOut, WeightVec& priosOut);
	void mergeLevels(SumVec& adjust, SharedData::WeightVec& weightsOut);
	SharedData* createShared(SharedContext& ctx, const SumVec& adjust, const CmpWeight& cmp);
	LitVec lits_;
};

//! Base class for implementing (mulit-level) minimize statements.
/*!
 * \ingroup constraint
 * A solver contains at most one minimize constraint, but a minimize constraint
 * may represent several minimize statements. In that case, each minimize statement
 * has a unique level (starting at 0) and minimize statements with a lower level
 * have higher priority. Priorities are handled like in smodels, i.e. statements
 * with lower priority become relevant only if all statements with higher priority
 * currently have an optimal assignment.
 *
 * MinimizeConstraint supports two modes of operation: if mode is set to
 * optimize, solutions are considered optimal only if they are strictly smaller
 * than previous solutions. Otherwise, if mode is set to enumerate a
 * solution is valid if it is not greater than the initially set optimum.
 * Example:
 *  m0: {a, b}
 *  m1: {c, d}
 *  All models: {a, c,...}, {a, d,...} {b, c,...}, {b, d,...} {a, b,...}
 *  Mode = optimize: {a, c, ...} (m0 = 1, m1 = 1}
 *  Mode = enumerate and initial opt=1,1: {a, c, ...}, {a, d,...}, {b, c,...}, {b, d,...}
 *
 */
class MinimizeConstraint : public Constraint {
public:
	typedef SharedMinimizeData SharedData;
	typedef const SharedData*  SharedDataP;
	//! Returns a pointer to the shared representation of this constraint.
	SharedDataP shared()  const { return shared_; }
	//! Attaches this object to the given solver.
	virtual bool attach(Solver& s)    = 0;
	//! Shall activate the minimize constraint by integrating bounds stored in the shared data object.
	virtual bool integrate(Solver& s) = 0;
	//! Shall relax this constraint (i.e. remove any bounds).
	/*!
	 * If reset is true, shall also remove search-path related state.
	 */
	virtual bool relax(Solver& s, bool reset) = 0;
	//! Shall commit the model in s to the shared data object.
	/*!
	 * The return value indicates whether the model is valid w.r.t the
	 * costs stored in the shared data object.
	 */
	virtual bool handleModel(Solver& s) = 0;
	//! Shall handle the unsatisfiable path in s.
	virtual bool handleUnsat(Solver& s, bool upShared, LitVec& restore) = 0;
	virtual bool supportsSplitting() const { return true; }
	// base interface
	void         destroy(Solver*, bool);
	Constraint*  cloneAttach(Solver&) { return 0; }
protected:
	MinimizeConstraint(SharedData* s);
	~MinimizeConstraint();
	void reportLower(Solver& s, uint32 level, wsum_t low) const;
	bool prepare(Solver& s, bool useTag);
	SharedData* shared_; // common shared data
	Literal     tag_;    // (optional) literal for tagging reasons
};

//! Minimization via branch and bound.
/*!
 * \ingroup constraint
 * The class supports both basic branch and bound as well as
 * hierarchical branch and bound (with or without varying step sizes).
 */
class DefaultMinimize : public MinimizeConstraint {
public:
	explicit DefaultMinimize(SharedData* d, uint32 strat);
	// base interface
	//! Attaches the constraint to the given solver.
	/*!
	 * \pre s.decisionLevel() == 0
	 * \note If either MinimizeMode_t::enumOpt or hierarchical optimization
	 * is active, s.sharedContext()->tagLiteral() shall be an unassigned literal.
	 */
	bool       attach(Solver& s);
	bool       integrate(Solver& s)           { return integrateBound(s); }
	bool       relax(Solver&, bool reset)     { return relaxBound(reset); }
	bool       handleModel(Solver& s)         { commitUpperBound(s); return true; }
	bool       handleUnsat(Solver& s, bool up, LitVec& out);
	// constraint interface
	PropResult propagate(Solver& s, Literal p, uint32& data);
	void       undoLevel(Solver& s);
	void       reason(Solver& s, Literal p, LitVec& lits);
	bool       minimize(Solver& s, Literal p, CCMinRecursive* r);
	void       destroy(Solver*, bool);
	// own interface
	bool       active()  const { return *opt() != SharedData::maxBound(); }
	//! Number of minimize statements contained in this constraint.
	uint32     numRules()const { return size_; }
	//! Tries to integrate the next tentative bound into this constraint.
	/*!
	 * Starting from the current optimum stored in the shared data object,
	 * the function tries to integrate the next candidate bound into
	 * this constraint.
	 *
	 * \return The function returns true if integration succeeded. Otherwise
	 * false is returned and s.hasConflict() is true.
	 *
	 * \note If integrateBound() failed, the bound of this constraint
	 *       is relaxed. The caller has to resolve the conflict first
	 *       and then integrateBound() shall be called again.
	 *
	 * \note The caller has to call s.propagate() to propagate any new information
	 *       from the new bound.
	 *
	 * \note If the tag literal (if any) is not true, the minimize constraint first assumes it.
	 */
	bool       integrateBound(Solver& s);

	//! Sets the current local sum as the global optimum (upper bound).
	/*!
	 * commitUpperBound() shall be called whenever the solver finds a model.
	 * The current local sum is recorded as new optimum in the shared data object.
	 * Once the local bound is committed, the function integrateBound() has to be
	 * called in order to continue optimization.
	 */
	void       commitUpperBound(const Solver& s);
	//! Sets the current local upper bound as the lower bound of this constraint.
	/*!
	 * commitLowerBound() shall be called on unsat. The function stores
	 * the local upper bound as new lower bound in this constraint. If upShared is true,
	 * the lower bound is also copied to the shared data object.
	 *
	 * Once the local bound is committed, the function integrateBound() has to be
	 * called in order to continue optimization.
	 * \return false if search-space is exceeded w.r.t this constraint.
	 */
	bool       commitLowerBound(Solver& s, bool upShared);

	//! Removes the local upper bound of this constraint and therefore disables it.
	/*!
	 * If full is true, also removes search-path related state.
	 */
	bool       relaxBound(bool full = false);

	bool       more() const { return step_.lev != size_; }

	// FOR TESTING ONLY!
	wsum_t sum(uint32 i, bool adjust) const { return sum()[i] + (adjust ? shared_->adjust(i):0); }
private:
	enum PropMode  { propagate_new_sum, propagate_new_opt };
	union UndoInfo;
	typedef const WeightLiteral* Iter;
	~DefaultMinimize();
	// bound operations
	wsum_t* opt() const { return bounds_; }
	wsum_t* sum() const { return bounds_ + size_; }
	wsum_t* temp()const { return bounds_ + (size_*2); }
	wsum_t* end() const { return bounds_ + (size_*3); }
	void    assign(wsum_t* lhs, wsum_t* rhs)  const;
	bool    greater(wsum_t* lhs, wsum_t* rhs, uint32 len, uint32& aLev) const;
	// propagation & undo
	uint32  lastUndoLevel(const Solver& s) const;
	bool    litSeen(uint32 i) const;
	bool    propagateImpl(Solver& s, PropMode m);
	uint32  computeImplicationSet(const Solver& s, const WeightLiteral& it, uint32& undoPos);
	void    pushUndo(Solver& s, uint32 litIdx);
	bool    updateBounds(bool applyStep);
	// step
	wsum_t& stepLow() const { return *(end() + step_.lev); }
	void    stepInit(uint32 n);
	wsum_t*      bounds_;  // [upper,sum,temp[,lower]]
	Iter         pos_;     // position of literal to look at next
	UndoInfo*    undo_;    // one "seen" flag for each literal +
	uint32       undoTop_; // undo stack holding assigned literals
	uint32       posTop_;  // stack of saved "look at" positions
	const uint32 size_;    // number of rules
	uint32       actLev_;  // first level to look at when comparing bounds
	struct Step {          // how to reduce next tentative bound
	uint32 size;           //   size of step
	uint32 lev : 30;       //   level on which step is applied
	uint32 type:  2;       //   type of step (one of MinimizeMode_t::BBOption)
	}            step_;
};

//! Minimization via unsat cores.
/*!
 * \ingroup constraint
 */
class UncoreMinimize : public MinimizeConstraint {
public:
	// constraint interface
	PropResult propagate(Solver& s, Literal p, uint32& data);
	void       reason(Solver& s, Literal p, LitVec& lits);
	void       destroy(Solver*, bool);
	bool       simplify(Solver& s, bool reinit = false);
	// base interface
	bool       attach(Solver& s);
	bool       integrate(Solver& s);
	bool       relax(Solver&, bool reset);
	bool       valid(Solver& s);
	bool       handleModel(Solver& s);
	bool       handleUnsat(Solver& s, bool up, LitVec& out);
	bool       supportsSplitting() const { return false; }
private:
	friend class SharedMinimizeData;
	explicit UncoreMinimize(SharedData* d, uint32 options = 0u);
	typedef DefaultMinimize* EnumPtr;
	struct LitData {
		LitData(weight_t w, bool as, uint32 c) : weight(w), coreId(c), assume((uint32)as) {}
		weight_t weight;
		uint32   coreId : 31;
		uint32   assume :  1;
	};
	struct LitPair {
		LitPair(Literal p, uint32 dataId) : lit(p), id(dataId) {}
		Literal lit;
		uint32  id;
	};
	struct Core {
		Core(WeightConstraint* c, weight_t b, weight_t w) : con(c), bound(b), weight(w) {}
		uint32  size()       const;
		Literal at(uint32 i) const;
		Literal tag()        const;
		WeightConstraint* con;
		weight_t          bound;
		weight_t          weight;
	};
	struct WCTemp {
		typedef WeightLitVec WLitVec;
		void     start(weight_t b){ lits.clear(); bound = b; }
		void     add(Solver& s, Literal p);
		bool     unsat() const { return bound > 0 && static_cast(bound) > static_cast(lits.size()); }
		weight_t bound;
		WLitVec  lits;
	};
	typedef PodVector::type     LitTable;
	typedef PodVector::type        CoreTable;
	typedef PodVector::type ConTable;
	typedef PodVector::type     LitSet;
	// literal and core management
	bool     hasCore(const LitData& x) const { return x.coreId != 0; }
	LitData& getData(uint32 id)              { return litData_[id-1];}
	Core&    getCore(const LitData& x)       { return open_[x.coreId-1]; }
	LitData& addLit(Literal p, weight_t w);
	void     releaseLits();
	bool     addCore(Solver& s, const LitPair* lits, uint32 size, weight_t w);
	uint32   allocCore(WeightConstraint* con, weight_t bound, weight_t weight, bool open);
	bool     closeCore(Solver& s, LitData& x, bool sat);
	bool     addOll(Solver& s, const LitPair* lits, uint32 size, weight_t w);
	bool     addOllCon(Solver& s, const WCTemp& wc, weight_t w);
	enum CompType { comp_disj = 0, comp_conj = 1 };
	bool     addPmr(Solver& s, const LitPair* lits, uint32 size, weight_t w);
	bool     addPmrCon(CompType t, Solver& s, Literal head, Literal body1, Literal body2);
	// algorithm
	void     init();
	uint32   initRoot(Solver& s);
	bool     initLevel(Solver& s);
	uint32   analyze(Solver& s, weight_t& minW, LitVec& poppedOther);
	bool     pushPath(Solver& s);
	void     integrateOpt(Solver& s);
	bool     popPath(Solver& s, uint32 dl, LitVec& out);
	bool     fixLit(Solver& s, Literal p);
	bool     fixLevel(Solver& s);
	void     detach(Solver* s, bool b);
	wsum_t*  computeSum(Solver& s) const;
	void     setLower(wsum_t x);
	bool     validLowerBound() const {
		wsum_t cmp = lower_ - upper_;
		return cmp < 0 || (cmp == 0 && level_ == shared_->maxLevel() && !shared_->checkNext());
	}
	// data
	EnumPtr   enum_;      // for supporting (optimal) model enumeration in parallel mode
	wsum_t*   sum_;       // costs of active model
	LitTable  litData_;   // data for active literals (tag lits for cores + lits from active minimize)
	CoreTable open_;      // open cores, i.e. relaxable and referenced by an assumption
	ConTable  closed_;    // closed cores represented as weight constraints
	LitSet    assume_;    // current set of assumptions
	LitSet    todo_;      // core(s) not yet represented as constraint
	LitVec    fix_;       // set of fixed literals
	LitVec    conflict_;  // temporary: conficting set of assumptions
	WCTemp    temp_;      // temporary: used for creating weight constraints
	wsum_t    lower_;     // lower bound of active level
	wsum_t    upper_;     // upper bound of active level
	uint32    auxInit_;   // number of solver aux vars on attach
	uint32    auxAdd_;    // number of aux vars added for cores
	uint32    gen_;       // active generation
	uint32    level_ : 26;// active level
	uint32    valid_ :  1;// valid w.r.t active generation?
	uint32    sat_   :  1;// update because of model
	uint32    pre_   :  1;// preprocessing active?
	uint32    path_  :  1;// push path?
	uint32    next_  :  1;// assume next level?
	uint32    init_  :  1;// init constraint?
	weight_t  actW_;      // active weight limit (only weighted minimization with preprocessing)
	weight_t  nextW_;     // next weight limit   (only weighted minimization with preprocessing)
	uint32    eRoot_;     // saved root level of solver (initial gp)
	uint32    aTop_;      // saved assumption level (added by us)
	uint32    freeOpen_;  // head of open core free list
	uint32    options_;   // active options
};

} // end namespace Clasp

#endif
clasp-3.2.2/libclasp/clasp/model_enumerators.h000066400000000000000000000121641304134206100214060ustar00rootroot00000000000000//
// Copyright (c) 2006-2011, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
//! \file
//! \brief Model enumeration with minimization and projection.
#ifndef CLASP_MODEL_ENUMERATORS_H
#define CLASP_MODEL_ENUMERATORS_H

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 

namespace Clasp {

//! Class for model enumeration with minimization and projection.
/*!
 * This class implements algorithms for enumerating models with or without optimization
 * and/or projection. It supports two different algorithms (strategies). First, enumeration
 * via restricted backjumping, and second, enumeration via recording of solution nogoods.
 *
 * The first strategy, strategy_backtrack, maintains a special backtracking level to
 * suppress certain backjumps that could otherwise "re-open" search spaces already visited.
 * If projection is not active, no extra nogoods are created.
 * Otherwise, the number of additional solution nogoods is linear in the number of projection atoms.
 *
 * The second strategy, strategy_record, enumerates models by recording nogoods for found solutions.
 * In general, this strategy is exponential in space (bounded by the number of solutions).
 * On the other hand, if optimization is active, additional nogoods are not needed
 * because the optimization constraint already serves as solution nogood.
 *
 * There is also a third strategy, strategy_auto, provided for convenience. This
 * strategy automatically selects between strategy_backtrack and strategy_record
 * based on the problem at hand. It uses strategy_record, if one of the following holds:
 *  - optimization is active, or
 *  - only one model is requested, or
 *  - both parallel search as well as projection are active
 *  .
 * In all other cases, strategy_auto selects strategy_backtrack.
 *
 * \ingroup enumerator
 */
class ModelEnumerator : public Enumerator {
public:
	//! Enumeration algorithms.
	enum Strategy {
		strategy_auto      = 0, //!< Use strategy best suited to problem.
		strategy_backtrack = 1, //!< Use backtrack-based enumeration.
		strategy_record    = 2  //!< Use nogood-based enumeration.
	};
	//! Projective solution enumeration and options.
	enum ProjectOptions {
		project_enable_simple = 1, //!< Enable projective solution enumeration.
		project_use_heuristic = 2, //!< Use heuristic when selecting a literal from a projection nogood.
		project_save_progress = 4, //!< Enable progress saving after the first solution was found.
		project_enable_full   = 6, //!< Enable projective solution enumeration with heuristic and progress saving.
		project_dom_lits      = 8, //!< In strategy record, project only on true domain literals.
	};
	/*!
	 * \param st Enumeration strategy to apply.
	 */
	explicit ModelEnumerator(Strategy st = strategy_auto);
	~ModelEnumerator();

	//! Configure strategy.
	/*!
	 * \param st         Enumeration strategy to use.
	 * \param projection The set of ProjectOptions to be applied or 0 to disable projective enumeration.
	 * \param filter     Ignore output predicates starting with filter in projective enumeration.
	 */
	void     setStrategy(Strategy st = strategy_auto, uint32 projection = 0, char filter = '_');
	bool     projectionEnabled()const { return projectOpts() != 0; }
	Strategy strategy()         const { return static_cast(options_ & 3u); }
	bool     project(Var v)     const;
protected:
	bool   supportsRestarts() const { return optimize() || strategy() == strategy_record; }
	bool   supportsParallel() const { return !projectionEnabled() || strategy() != strategy_backtrack; }
	bool   supportsSplitting(const SharedContext& problem) const {
		return (strategy() == strategy_backtrack || (projectOpts() & project_dom_lits) == 0u) && Enumerator::supportsSplitting(problem);
	}
	ConPtr doInit(SharedContext& ctx, SharedMinimizeData* m, int numModels);
private:
	enum { detect_strategy_flag = 4u, trivial_flag = 8u, strategy_opts_mask = 15u };
	class ModelFinder;
	class BacktrackFinder;
	class RecordFinder;
	typedef PodVector::type WordVec;
	void    initProjection(SharedContext& ctx);
	void    addProject(SharedContext& ctx, Var v);
	uint32  projectOpts()    const { return (options_ >> 4) & strategy_opts_mask; }
	bool    detectStrategy() const { return (options_ & detect_strategy_flag) == detect_strategy_flag; }
	bool    trivial()        const { return (options_ & trivial_flag) == trivial_flag; }
	LitVec  domRec_;
	uint32  options_;
	WordVec project_;
};

}
#endif
clasp-3.2.2/libclasp/clasp/parallel_solve.h000066400000000000000000000342561304134206100206740ustar00rootroot00000000000000//
// Copyright (c) 2010-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_PARALLEL_SOLVE_H_INCLUDED
#define CLASP_PARALLEL_SOLVE_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#if WITH_THREADS

#include 
#include 
#include 
#include 
#include 
#include 

/*!
 * \file
 * \brief Defines classes controlling multi-threaded parallel solving.
 */
namespace Clasp {
//! Namespace for types and functions needed for implementing multi-threaded parallel solving.
namespace mt {

/**
 * \defgroup mt Multi-threading
 * \brief Parallel solving and related classes.
 * \ingroup enumerator
 */
//@{

class ParallelHandler;
class ParallelSolve;

//! Options for controlling parallel solving.
struct ParallelSolveOptions : BasicSolveOptions {
	//! Nogood distribution options.
	struct Distribution : Distributor::Policy {
		enum Mode { mode_global = 0, mode_local = 1 };
		Distribution(Mode m = mode_global) : Distributor::Policy(), mode(m) {}
		Distributor::Policy& policy() { return *this; }
		uint32 mode;
	};
	ParallelSolveOptions() {}
	//! Algorithm options.
	struct Algorithm {
		//! Possible search strategies.
		enum SearchMode { mode_split = 0, mode_compete  = 1 };
		Algorithm() : threads(1), mode(mode_compete) {}
		uint32     threads;
		SearchMode mode;
	};
	//! Nogood integration options.
	struct Integration {
		static const uint32 GRACE_MAX = (1u<<28)-1;
		Integration() :  grace(1024), filter(filter_gp), topo(topo_all) {}
		enum Filter   { filter_no = 0, filter_gp = 1, filter_sat = 2, filter_heuristic = 3 };
		enum Topology { topo_all  = 0, topo_ring = 1, topo_cube  = 2, topo_cubex = 3       };
		uint32 grace : 28; /**< Lower bound on number of shared nogoods to keep. */
		uint32 filter: 2;  /**< Filter for integrating shared nogoods (one of Filter). */
		uint32 topo  : 2;  /**< Integration topology */
	};
	//! Global restart options.
	struct GRestarts {
		GRestarts():maxR(0) {}
		uint32           maxR;
		ScheduleStrategy sched;
	};
	Integration  integrate; //!< Nogood integration options to apply during search.
	Distribution distribute;//!< Nogood distribution options to apply during search.
	GRestarts    restarts;  //!< Global restart strategy to apply during search.
	Algorithm    algorithm; //!< Parallel algorithm to use.
	//! Allocates a new solve object.
	SolveAlgorithm* createSolveObject() const;
	//! Returns the number of threads that can run concurrently on the current hardware.
	static uint32   recommendedSolvers()     { return Clasp::mt::thread::hardware_concurrency(); }
	//! Returns number of maximal number of supported threads.
	static uint32   supportedSolvers()       { return 64; }
	//! Returns the peers of the solver with the given id assuming the given topology.
	static uint64   initPeerMask(uint32 sId, Integration::Topology topo, uint32 numThreads);
	uint32          numSolver()        const { return algorithm.threads; }
	void            setSolvers(uint32 i)     { algorithm.threads = std::max(uint32(1), i); }
	bool            defaultPortfolio() const { return algorithm.mode == Algorithm::mode_compete; }
};

//! A parallel algorithm for multi-threaded solving with and without search-space splitting.
/*!
 * The class adapts clasp's basic solve algorithm
 * to a parallel solve algorithm that solves
 * a problem using a given number of threads.
 * It supports guiding path based solving, portfolio based solving, as well
 * as a combination of these two approaches.
 */
class ParallelSolve : public SolveAlgorithm {
public:
	explicit ParallelSolve(const ParallelSolveOptions& opts);
	~ParallelSolve();
	// base interface
	virtual bool interrupted() const;
	virtual void resetSolve();
	virtual void enableInterrupts();
	// own interface
	//! Returns the number of active threads.
	uint32 numThreads()            const;
	bool   integrateUseHeuristic() const { return test_bit(intFlags_, 31); }
	uint32 integrateGrace()        const { return intGrace_; }
	uint32 integrateFlags()        const { return intFlags_; }
	uint64 hasErrors()             const;
	//! Requests a global restart.
	void   requestRestart();
	bool   handleMessages(Solver& s);
	bool   integrateModels(Solver& s, uint32& mCount);
	void   pushWork(LitVec* gp);
	bool   commitModel(Solver& s);
	bool   commitUnsat(Solver& s);
	enum GpType { gp_none = 0, gp_split = 1, gp_fixed = 2 };
private:
	ParallelSolve(const ParallelSolve&);
	ParallelSolve& operator=(const ParallelSolve&);
	typedef SingleOwnerPtr PathPtr;
	enum ErrorCode { error_none = 0, error_oom = 1, error_runtime = 2, error_other = 4 };
	enum           { masterId = 0 };
	// -------------------------------------------------------------------------------------------
	// Thread setup
	struct EntryPoint;
	void   destroyThread(uint32 id);
	void   allocThread(uint32 id, Solver& s, const SolveParams& p);
	void   joinThreads();
	// -------------------------------------------------------------------------------------------
	// Algorithm steps
	void   setIntegrate(uint32 grace, uint8 filter);
	void   setRestarts(uint32 maxR, const ScheduleStrategy& rs);
	bool   beginSolve(SharedContext& ctx, const LitVec& assume);
	bool   doSolve(SharedContext& ctx, const LitVec& assume);
	void   doStart(SharedContext& ctx, const LitVec& assume);
	int    doNext(int last);
	void   doStop();
	bool   doInterrupt();
	void   solveParallel(uint32 id);
	void   initQueue();
	bool   requestWork(Solver& s, PathPtr& out);
	void   terminate(Solver& s, bool complete);
	bool   waitOnSync(Solver& s);
	void   exception(uint32 id, PathPtr& path, ErrorCode e, const char* what);
	void   reportProgress(const Event& ev) const;
	void   reportProgress(const Solver& s, const char* msg) const;
	// -------------------------------------------------------------------------------------------
	typedef ParallelSolveOptions::Distribution Distribution;
	struct SharedData;
	// SHARED DATA
	SharedData*       shared_;       // Shared control data
	ParallelHandler** thread_;       // Thread-locl control data
	// READ ONLY
	Distribution      distribution_; // distribution options
	uint32            maxRestarts_;  // disable global restarts once reached
	uint32            intGrace_ : 30;// grace period for clauses to integrate
	uint32            intTopo_  :  2;// integration topology
	uint32            intFlags_;     // bitset controlling clause integration
	bool              modeSplit_;
};
//! An event type for debugging messages sent between threads.
struct MessageEvent : SolveEvent {
	enum Action { sent, received, completed };
	MessageEvent(const Solver& s, const char* message, Action a, double t = 0.0)
		: SolveEvent(s, verbosity_high), msg(message), time(t) { op = (uint32)a; }
	const char* msg;    // name of message
	double      time;   // only for action completed
};
//! A per-solver (i.e. thread) class that implements message handling and knowledge integration.
/*!
 * The class adds itself as a post propagator to the given solver. During propagation
 * it checks for new messages and lemmas to integrate.
 */
class ParallelHandler : public MessageHandler {
public:
	typedef ParallelSolve::GpType GpType;

	//! Creates a new parallel handler to be used in the given solve group.
	/*!
	 * \param ctrl The object controlling the parallel solve operation.
	 * \param s    The solver that is to be controlled by this object.
	 * \param p    The solver-specific solve options.
	 */
	explicit ParallelHandler(ParallelSolve& ctrl, Solver& s, const SolveParams& p);
	~ParallelHandler();
	//! Attaches the object's solver to ctx and adds this object as a post propagator.
	bool attach(SharedContext& ctx);
	//! Removes this object from the list of post propagators of its solver and detaches the solver from ctx.
	void detach(SharedContext& ctx, bool fastExit);

	void setError(int e) { error_ = e; }
	int  error() const   { return (int)error_; }
	void setWinner()     { win_ = 1; }
	bool winner() const  { return win_ != 0; }
	void setThread(Clasp::mt::thread& x) { assert(!joinable()); x.swap(thread_); assert(joinable()); }

	//! True if *this has an associated thread of execution, false otherwise.
	bool joinable() const { return thread_.joinable(); }
	//! Waits for the thread of execution associated with *this to finish.
	int join() { if (joinable()) { thread_.join(); } return error(); }

	// overridden methods

	//! Integrates new information.
	bool propagateFixpoint(Solver& s, PostPropagator*);
	bool handleMessages() { return ctrl_->handleMessages(solver()); }
	void reset() { up_ = 1; }
	bool simplify(Solver& s, bool re);
	//! Checks whether new information has invalidated current model.
	bool isModel(Solver& s);

	// own interface

	// TODO: make functions virtual once necessary

	//! Returns true if handler's guiding path is disjoint from all others.
	bool disjointPath() const { return gp_.type == ParallelSolve::gp_split; }
	//! Returns true if handler has a guiding path.
	bool hasPath()      const { return gp_.type != ParallelSolve::gp_none; }
	void setGpType(GpType t)  { gp_.type = t; }

	//! Entry point for solving the given guiding path.
	/*!
	 * \param solve   The object used for solving.
	 * \param type    The guiding path's type.
	 * \param restart Request restart after restart number of conflicts.
	 */
	ValueRep solveGP(BasicSolve& solve, GpType type, uint64 restart);

	/*!
	 * \name Message handlers
	 * \note
	 *   Message handlers are intended as callbacks for ParallelSolve::handleMessages().
	 *   They shall not change the assignment of the solver object.
	 */
	//@{

	//! Algorithm is about to terminate.
	/*!
	 * Removes this object from the solver's list of post propagators.
	 */
	void handleTerminateMessage();

	//! Request for split.
	/*!
	 * Splits off a new guiding path and adds it to the control object.
	 * \pre The guiding path of this object is "splittable"
	 */
	void handleSplitMessage();

	//! Request for (global) restart.
	/*!
	 * \return true if restart is valid, else false.
	 */
	bool handleRestartMessage();

	Solver&            solver()      { return *solver_; }
	const SolveParams& params() const{ return *params_; }
	//@}
private:
	void add(ClauseHead* h);
	void clearDB(Solver* s);
	bool integrate(Solver& s);
	typedef PodVector::type ClauseDB;
	typedef SharedLiterals**             RecBuffer;
	enum { RECEIVE_BUFFER_SIZE = 32 };
	ParallelSolve*     ctrl_;       // my message source
	Solver*            solver_;     // my solver
	const SolveParams* params_;     // my solving params
	Clasp::mt::thread  thread_;     // active thread or empty for master
	RecBuffer          received_;   // received clauses not yet integrated
	ClauseDB           integrated_; // my integrated clauses
	uint32             recEnd_;     // where to put next received clause
	uint32             intEnd_;     // where to put next clause
	uint32             error_:30;   // error code or 0 if ok
	uint32             win_  : 1;   // 1 if thread was the first to terminate the search
	uint32             up_   : 1;   // 1 if next propagate should check for new lemmas/models
	uint32             act_  : 1;   // 1 if gp is active
	struct GP {
		uint64 restart;  // don't give up before restart number of conflicts
		uint32 modCount; // integration counter for synchronizing models
		GpType type ;    // type of gp
		void reset(uint64 r = UINT64_MAX, GpType t = ParallelSolve::gp_none) {
			restart = r;
			modCount= 0;
			type    = t;
		}
	} gp_;
};
//! A class that uses a global list to exchange nogoods between threads.
class GlobalDistribution : public Distributor {
public:
	explicit GlobalDistribution(const Policy& p, uint32 maxShare, uint32 topo);
	~GlobalDistribution();
	uint32  receive(const Solver& in, SharedLiterals** out, uint32 maxOut);
	void    publish(const Solver& source, SharedLiterals* n);
private:
	void release();
	struct ClausePair {
		ClausePair(uint32 sId = UINT32_MAX, SharedLiterals* x = 0) : sender(sId), lits(x) {}
		uint32          sender;
		SharedLiterals* lits;
	};
	class Queue : public MultiQueue {
	public:
		typedef MultiQueue base_type;
		using base_type::publish;
		Queue(uint32 m) : base_type(m) {}
	};
	struct ThreadInfo {
		uint64          peerMask;
		union {
			Queue::ThreadId id;
			uint64          rep;
		};
		char            pad[64 - (sizeof(uint64)*2)];
	};
	Queue::ThreadId& getThreadId(uint32 sId) const { return threadId_[sId].id; }
	uint64           getPeerMask(uint32 sId) const { return threadId_[sId].peerMask; }
	Queue*           queue_;
	ThreadInfo*      threadId_;
};
//! A class that uses thread-local lists to exchange nogoods between threads.
class LocalDistribution : public Distributor {
public:
	explicit LocalDistribution(const Policy& p, uint32 maxShare, uint32 topo);
	~LocalDistribution();
	uint32  receive(const Solver& in, SharedLiterals** out, uint32 maxOut);
	void    publish(const Solver& source, SharedLiterals* n);
private:
	typedef Detail::RawStack   RawStack;
	typedef MPSCPtrQueue::Node QNode;
	enum { BLOCK_CAP = 128 };
	QNode* allocNode(uint32 tId, SharedLiterals* clause);
	void   freeNode(uint32  tId, QNode* n) const;
	struct ThreadData {
		MPSCPtrQueue received; // queue holding received clauses
		uint64       peers;    // set of peers from which this thread receives clauses
		QNode        sentinal; // sentinal node for simplifying queue impl
		QNode*       free;     // local free list - only accessed by this thread
	}**            thread_;    // one entry for each thread
	RawStack       blocks_;    // allocated node blocks
	uint32         numThread_; // number of threads, i.e. size of array thread_
};
//@}
} }
#endif

#endif
clasp-3.2.2/libclasp/clasp/parser.h000066400000000000000000000141701304134206100171550ustar00rootroot00000000000000//
// Copyright (c) Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_PARSER_H_INCLUDED
#define CLASP_PARSER_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
#include 
#include 
#include 
#include 
/*!
 * \file
 * \brief Defines parsers for supported input formats.
 */
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// PARSING BASE
/////////////////////////////////////////////////////////////////////////////////////////
/*!
 * \addtogroup problem
 */
//@{

//! Auto-detect type of program given in prg.
ProblemType detectProblemType(std::istream& prg);

//! Parse additional information in symbol table/comments.
struct ParserOptions {
	//! Supported parser extensions.
	enum Extension {
		parse_heuristic = 1u, //!< Parse heuristic info in smodels, dimacs, and pb format.
		parse_acyc_edge = 2u, //!< Parse acyc info in smodels, dimacs, and pb format.
		parse_minimize  = 4u, //!< Parse cost function in dimacs format.
		parse_project   = 8u, //!< Parse project directive in dimacs and pb format.
		parse_assume    = 16u,//!< Parse assumption directive in dimacs and pb format.
		parse_output    = 32u,//!< Parse output directive in dimacs and pb format.
		parse_full      = 63u
	};
	ParserOptions() : ext(0) {}
	ParserOptions& enableHeuristic() { ext |= parse_heuristic; return *this; }
	ParserOptions& enableAcycEdges() { ext |= parse_acyc_edge; return *this; }
	ParserOptions& enableMinimize()  { ext |= parse_minimize; return *this; }
	ParserOptions& enableProject()   { ext |= parse_project; return *this; }
	ParserOptions& enableAssume()    { ext |= parse_assume;  return *this;}
	ParserOptions& enableOutput()    { ext |= parse_output;  return *this; }
	bool isEnabled(Extension e) const { return (ext & static_cast(e)) != 0u; }
	bool isEnabled(uint8 f) const { return (ext & f) != 0u;  }
	uint8 ext;
};
//! Base class for parsers.
class ProgramParser {
public:
	typedef Potassco::ProgramReader StrategyType;
	static const Var VAR_MAX = varMax - 1;
	ProgramParser();
	virtual ~ProgramParser();
	bool accept(std::istream& str, const ParserOptions& o = ParserOptions());
	bool incremental() const;
	bool isOpen() const;
	bool parse();
	bool more();
	void reset();
private:
	virtual StrategyType* doAccept(std::istream& str, const ParserOptions& o) = 0;
	StrategyType* strat_;
};

//! Parser for logic programs in smodels-internal or aspif format.
class AspParser : public ProgramParser {
public:
	static bool accept(char c);
	explicit AspParser(Asp::LogicProgram& prg);
	~AspParser();
	enum Format { format_smodels = -1, format_aspif = 1 };
	static void write(Asp::LogicProgram& prg, std::ostream& os);
	static void write(Asp::LogicProgram& prg, std::ostream& os, Format f);
protected:
	virtual StrategyType* doAccept(std::istream& str, const ParserOptions& o);
private:
	struct SmAdapter;
	Asp::LogicProgram*         lp_;
	StrategyType*              in_;
	Potassco::AbstractProgram* out_;
};
/////////////////////////////////////////////////////////////////////////////////////////
// SAT parsing
/////////////////////////////////////////////////////////////////////////////////////////
//! Base class for dimacs and opb parser.
class SatReader : public Potassco::ProgramReader {
public:
	SatReader();
	ParserOptions options;
protected:
	bool skipLines(char start);
	void parseExt(const char* pre, uint32 maxVar, SharedContext& ctx);
	//  ::= {  } 
	void parseProject(uint32 maxVar, SharedContext& ctx);
	//  ::= {  } 
	void parseAssume(uint32 maxVar);
	//  ::=     
	void parseHeuristic(uint32 maxVar, SharedContext& ctx);
	//  ::= "range"  
	//           |    
	void parseOutput(uint32 maxVar, SharedContext& ctx);
	void parseGraph(uint32 maxVar, const char* pre, ExtDepGraph& graph);
	virtual void addObjective(const WeightLitVec& vec) = 0;
	virtual void addAssumption(Literal x) = 0;
private:
	Literal matchLit(Var max);
};
//! Parser for (extended) dimacs format.
class DimacsReader : public SatReader {
public:
	static bool accept(char c) { return c == 'c' || c == 'p'; }
	DimacsReader(SatBuilder&);
protected:
	virtual bool doAttach(bool& inc);
	virtual bool doParse();
	virtual void addObjective(const WeightLitVec& vec);
	virtual void addAssumption(Literal x);
private:
	SatBuilder* program_;
	Var         numVar_;
	bool        wcnf_;
};
//! Parser for opb format.
class OpbReader : public SatReader {
public:
	OpbReader(PBBuilder&);
	static bool accept(char c) { return c == '*'; }
protected:
	virtual bool doAttach(bool& inc);
	virtual bool doParse();
	virtual void addObjective(const WeightLitVec& vec);
	virtual void addAssumption(Literal x);
	void parseOptObjective();
	void parseConstraint();
	void parseSum();
	void parseTerm();
private:
	PBBuilder* program_;
	weight_t   minCost_;
	weight_t   maxCost_;
	struct Temp {
		WeightLitVec lits;
		LitVec       term;
		weight_t     bound;
		bool         eq;
	}          active_;
};
//! Parser for SAT or PB problems.
class SatParser : public ProgramParser {
public:
	explicit SatParser(SatBuilder& prg);
	explicit SatParser(PBBuilder& prg);
	~SatParser();
protected:
	virtual StrategyType* doAccept(std::istream& str, const ParserOptions& o);
private:
	SatReader* reader_;
};
//@}

}
#endif
clasp-3.2.2/libclasp/clasp/pod_vector.h000066400000000000000000000062721304134206100200310ustar00rootroot00000000000000//
// Copyright (c) 2006-2007, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_POD_VECTOR_H_INCLUDED
#define CLASP_POD_VECTOR_H_INCLUDED
#include 
#include 
#include 
#include 

namespace Clasp {

#if defined(_DEBUG) && _DEBUG
	template 
	struct PodVector {
		typedef std::vector type;
		static void destruct(type& t) {t.clear();}
	};
#else
	//! Type selector for a vector type optimized for storing POD-types.
	template 
	struct PodVector {
		typedef bk_lib::pod_vector type;
		static void destruct(type& t) {
			for (typename type::size_type i = 0, end = t.size(); i != end; ++i) {
				t[i].~Type();
			}
			t.clear();
		}
	};
#endif
inline uint32 toU32(std::size_t x) {
	assert(sizeof(std::size_t) <= sizeof(uint32) || x <= static_cast(UINT32_MAX));
	return static_cast(x);
}
template 
inline uint32 sizeVec(const T& c) { return toU32(c.size()); }
template 
inline void releaseVec(T& t) {
	T().swap(t);
}

template 
inline void shrinkVecTo(T& t, typename T::size_type j) {
	t.erase(t.begin()+j, t.end());
}

template 
inline void growVecTo(T& vec, typename T::size_type j, const typename T::value_type& val = typename T::value_type()) {
	if (vec.size() < j) {
		if (vec.capacity() < j) { vec.reserve(j + j / 2); }
		vec.resize(j, val);
	}
}

template 
void moveDown(T& t, typename T::size_type from, typename T::size_type to) {
	for (typename T::size_type end = t.size(); from != end;) {
		t[to++] = t[from++];
	}
	shrinkVecTo(t, to);
}
//! A simple vector-based fifo queue for storing POD-types.
template 
struct PodQueue {
	typedef typename PodVector::type  vec_type;
	typedef typename vec_type::size_type size_type;
	PodQueue() : qFront(0) {}
	bool      empty() const   { return qFront == vec.size(); }
	size_type size()  const   { return vec.size() - qFront; }
	const T&  front() const   { return vec[qFront]; }
	const T&  back()  const   { return vec.back(); }
	T&        front()         { return vec[qFront]; }
	T&        back()          { return vec.back(); }
	void      push(const T& x){ vec.push_back(x);  }
	void      pop()           { ++qFront; }
	T         pop_ret()       { return vec[qFront++]; }
	void      clear()         { vec.clear(); qFront = 0; }
	void      rewind()        { qFront = 0; }
	vec_type  vec;    // the underlying vector holding the items
	size_type qFront; // front position
};

}

#endif
clasp-3.2.2/libclasp/clasp/program_builder.h000066400000000000000000000226601304134206100210410ustar00rootroot00000000000000//
// Copyright (c) 2006-2015 Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_PROGRAM_BUILDER_H_INCLUDED
#define CLASP_PROGRAM_BUILDER_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
#include 
#include 
#include 
#include 

namespace Clasp {

/**
 * \file
 * \defgroup problem Input
 * \brief Classes and functions for defining input programs.
 */
//@{

//! Interface for defining an input program.
class ProgramBuilder {
public:
	typedef SharedMinimizeData SharedMinimize;
	typedef SingleOwnerPtr MinPtr;

	ProgramBuilder();
	virtual ~ProgramBuilder();
	//! Starts the definition of a program.
	/*!
	 * This function shall be called exactly once before a new program is defined.
	 * It discards any previously added program.
	 *
	 * \param ctx The context object in which the program should be stored.
	 */
	bool startProgram(SharedContext& ctx);
	//! Parses the given stream as a program of type() and adds it to this object.
	bool parseProgram(std::istream& prg);
	//! Unfreezes a currently frozen program.
	bool updateProgram();
	//! Loads the program into the shared context passed to startProgram().
	bool endProgram();
	//! Returns any assumptions that shall hold during solving.
	/*!
	 * \pre frozen()
	 */
	void             getAssumptions(LitVec& out) const;
	//! Returns bounds that shall hold during minimization.
	void             getWeakBounds(SumVec& out)  const;
	//! Returns the type of program that is created by this builder.
	int              type()   const { return doType(); }
	//! Returns true if the program is currently frozen.
	bool             frozen() const { return frozen_; }
	//! Returns true if the program is not conflicting.
	virtual bool     ok()     const;
	//! Returns the stored context object.
	SharedContext*   ctx()    const { return ctx_; }
	//! Returns a parser for this type of program associated with this object.
	ProgramParser&   parser();
protected:
	void addMinLit(weight_t prio, WeightLiteral x);
	void setFrozen(bool frozen)  { frozen_ = frozen; }
	void setCtx(SharedContext* x){ ctx_    = x; }
	void markOutputVariables() const;
private:
	typedef SingleOwnerPtr MinBuildPtr;
	typedef SingleOwnerPtr   ParserPtr;
	ProgramBuilder(const ProgramBuilder&);
	ProgramBuilder& operator=(ProgramBuilder&);
	virtual bool doStartProgram()                    = 0;
	virtual bool doUpdateProgram()                   = 0;
	virtual bool doEndProgram()                      = 0;
	virtual void doGetWeakBounds(SumVec& out)  const;
	virtual void doGetAssumptions(LitVec& out) const = 0;
	virtual int  doType() const                      = 0;
	virtual ProgramParser* doCreateParser()          = 0;
	SharedContext* ctx_;
	ParserPtr      parser_;
	bool           frozen_;
};

//! A class for defining a SAT-problem in CNF.
class SatBuilder : public ProgramBuilder {
public:
	explicit SatBuilder(bool maxSat = false);
	// program definition

	//! Creates necessary variables and prepares the problem.
	/*!
	 * \param numVars          Number of variables to create.
	 * \param hardClauseWeight Weight identifying hard clauses (0 means no weight).
	 *                         Clauses added with a weight != hardClauseWeight are
	 *                         considered soft clauses (see addClause()).
	 * \param clauseHint       A hint on how many clauses will be added.
	 */
	void prepareProblem(uint32 numVars, wsum_t hardClauseWeight = 0, uint32 clauseHint = 100);
	//! Returns the number of variables in the problem.
	Var numVars() const { return vars_; }
	//! Adds the given clause to the problem.
	/*!
	 * The SatBuilder supports the creation of (weighted) MaxSAT problems
   * via the creation of "soft clauses". For this, clauses
   * added to this object have an associated weight cw. If cw
	 * does not equal hardClauseWeight (typically 0), the clause is a
	 * soft clause and not satisfying it results in a penalty of cw.
	 *
	 * \pre v <= numVars(), for all variables v occuring in clause.
	 * \pre cw >= 0.
	 * \param clause The clause to add.
	 * \param cw     The weight associated with the clause.
	 */
	bool addClause(LitVec& clause, wsum_t cw = 0);
	//! Adds the given PB-constraint (sum(lits) >= bound) to the problem.
	bool addConstraint(WeightLitVec& lits, weight_t bound);
	//! Adds min as an objective function to the problem.
	bool addObjective(const WeightLitVec& min);
	//! Adds v to the set of projection vars.
	void addProject(Var v);
	//! Adds x to the set of initial assumptions.
	void addAssumption(Literal x);
private:
	typedef PodVector::type VarState;
	bool doStartProgram();
	ProgramParser* doCreateParser();
	int  doType() const                    { return Problem_t::Sat; }
	bool doUpdateProgram()                 { return !frozen(); }
	void doGetAssumptions(LitVec& a) const { a.insert(a.end(), assume_.begin(), assume_.end()); }
	bool doEndProgram();
	bool satisfied(LitVec& clause);
	bool markAssigned();
	void markLit(Literal x) { varState_[x.var()] |= 1 + x.sign(); }
	VarState varState_;
	LitVec   softClauses_;
	LitVec   assume_;
	wsum_t   hardWeight_;
	Var      vars_;
	uint32   pos_;
	bool     maxSat_;
};

//! A class for defining a PB-problem.
class PBBuilder : public ProgramBuilder {
public:
	PBBuilder();
	// program definition
	//! Creates necessary variables and prepares the problem.
	/*!
	 * \param numVars          Number of problem variables to create.
	 * \param maxProduct       Max number of products in the problem.
	 * \param maxSoft          Max number of soft constraints in the problem.
	 * \param constraintHint   A hint on how many clauses will be added.
	 */
	void    prepareProblem(uint32 numVars, uint32 maxProduct, uint32 maxSoft, uint32 constraintHint = 100);
	//! Returns the number of variables in the problem.
	uint32  numVars() const { return auxVar_ - 1; }
	//! Adds the given PB-constraint to the problem.
	/*!
	 * A PB-constraint consists of a list of weighted Boolean literals (lhs),
	 * a comparison operator (either >= or =), and an integer bound (rhs).
	 *
	 * \pre v <= numVars(), for all variables v occuring in lits.
	 * \pre bound >= 0 && cw >= 0.
	 *
	 * \param lits  The lhs of the PB-constraint.
	 * \param bound The rhs of the PB-constraint.
	 * \param eq    If true, use '=' instead of '>=' as comparison operator.
	 * \param cw    If > 0, treat constraint as soft constraint with weight cw.
	 */
	bool    addConstraint(WeightLitVec& lits, weight_t bound, bool eq = false, weight_t cw = 0);
	//! Adds the given product to the problem.
	/*!
	 * The function creates the equality x == l1 && ... && ln, where x is a new
	 * literal and each li is a literal in lits.
	 * \pre The number of products added so far is < maxProduct that was given in prepareProblem().
	 */
	Literal addProduct(LitVec& lits);
	//! Adds min as an objective function to the problem.
	bool    addObjective(const WeightLitVec& min);
	//! Adds v to the set of projection vars.
	void    addProject(Var v);
	//! Adds x to the set of initial assumptions.
	void    addAssumption(Literal x);
	//! Only allow solutions where the sum of violated soft constraint is less than bound.
	bool    setSoftBound(wsum_t bound);
private:
	struct PKey {
		LitVec lits;
		std::size_t operator()(const PKey& k)                    const { return k.lits[0].rep(); }
		bool        operator()(const PKey& lhs, const PKey& rhs) const { return lhs.lits == rhs.lits; }
	};
	typedef Clasp::HashMap_t::map_type ProductIndex;
	bool doStartProgram();
	void doGetWeakBounds(SumVec& out) const;
	int  doType() const                    { return Problem_t::Pb; }
	bool doUpdateProgram()                 { return !frozen(); }
	void doGetAssumptions(LitVec& a) const { a.insert(a.end(), assume_.begin(), assume_.end()); }
	ProgramParser* doCreateParser();
	bool doEndProgram();
	bool productSubsumed(LitVec& lits, PKey& prod);
	void addProductConstraints(Literal eqLit, LitVec& lits);
	Var  getAuxVar();
	ProductIndex products_;
	PKey         prod_;
	LitVec       assume_;
	uint32       auxVar_;
	uint32       endVar_;
	wsum_t       soft_;
};

//! Adapts a Sat or PB builder to the Potassco::AbstractProgram interface.
class BasicProgramAdapter : public Potassco::AbstractProgram {
public:
	BasicProgramAdapter(ProgramBuilder& prg);
	void initProgram(bool inc);
	void beginStep();
	void rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body);
	void rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, Potassco::Weight_t bound, const Potassco::WeightLitSpan& body);
	void minimize(Potassco::Weight_t prio, const Potassco::WeightLitSpan& lits);
protected:
	ProgramBuilder* prg_;
	LitVec          clause_;
	WeightLitVec    constraint_;
	bool            inc_;
};

}
#endif
clasp-3.2.2/libclasp/clasp/satelite.h000066400000000000000000000156161304134206100175010ustar00rootroot00000000000000//
// Copyright (c) 2006-2010, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
//! \file
//! \brief Types and functions for SAT-based preprocessing.
#ifndef CLASP_SATELITE_H_INCLUDED
#define CLASP_SATELITE_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
#include 

namespace Clasp {
//! SatElite preprocessor for clauses.
/*!
 * \ingroup shared
 * The preprocessor implements subsumption, self-subsumption, variable elimination,
 * and (optionally) blocked clause elimination.
 * \see
 *   - Niklas Eén, Armin Biere: "Effective Preprocessing in SAT through Variable and Clause Elimination"
 *   - Matti Järvisalo, Armin Biere, Marijn Heule: "Blocked Clause Elimination"
 *   - Parts of the SatElite preprocessor are adapted from MiniSAT 2.0 beta
 *     available under the MIT licence from http://minisat.se/MiniSat.html
 *   .
 */
class SatElite : public Clasp::SatPreprocessor {
public:
	SatElite();
	~SatElite();
	Clasp::SatPreprocessor* clone();
	//! Event type for providing information on preprocessing progress.
	struct Progress : public Event_t {
		enum EventOp { event_algorithm = '*', event_bce = 'B', event_var_elim = 'E', event_subsumption = 'S', };
		Progress(SatElite* p, EventOp o, uint32 i, uint32 m) : Event_t(Event::subsystem_prepare, Event::verbosity_high), self(p), cur(i), max(m) {
			op = (uint32)o;
		}
		SatElite* self;
		uint32    cur;
		uint32    max;
	};
protected:
	bool  initPreprocess(Options& opts);
	void  reportProgress(Progress::EventOp, uint32 curr, uint32 max);
	bool  doPreprocess();
	void  doExtendModel(ValueVec& m, LitVec& open);
	void  doCleanUp();
private:
	typedef PodVector::type    TouchedList;
	typedef bk_lib::left_right_sequence ClWList;
	typedef ClWList::left_iterator                      ClIter;
	typedef ClWList::right_iterator                     WIter;
	typedef std::pair                   ClRange;
	SatElite(const SatElite&);
	const SatElite& operator=(const SatElite&);
	// For each var v
	struct OccurList {
		OccurList() : pos(0), bce(0), dirty(0), neg(0), litMark(0) {}
		ClWList refs;      // left : ids of clauses containing v or ~v  (var() == id, sign() == v or ~v)
		                   // right: ids of clauses watching v or ~v (literal 0 is the watched literal)
		uint32  pos:30;    // number of *relevant* clauses containing v
		uint32  bce:1;     // in BCE queue?
		uint32  dirty:1;   // does clauses contain removed clauses?
		uint32  neg:30;    // number of *relevant* clauses containing v
		uint32  litMark:2; // 00: no literal of v marked, 01: v marked, 10: ~v marked
		uint32  numOcc()          const { return pos + neg; }
		uint32  cost()            const { return pos * neg; }
		ClRange clauseRange()     const { return ClRange(const_cast(refs).left_begin(), const_cast(refs).left_end()); }
		void    clear() {
			this->~OccurList();
			new (this) OccurList();
		}
		void    addWatch(uint32 clId)    { refs.push_right(clId); }
		void    removeWatch(uint32 clId) { refs.erase_right(std::find(refs.right_begin(), refs.right_end(), clId)); }
		void    add(uint32 id, bool sign){
			pos += uint32(!sign);
			neg += uint32(sign);
			refs.push_left(Literal(id, sign));
		}
		void    remove(uint32 id, bool sign, bool updateClauseList) {
			pos -= uint32(!sign);
			neg -= uint32(sign);
			if (updateClauseList) {
				refs.erase_left(std::find(refs.left_begin(), refs.left_end(), Literal(id, sign)));
			}
			else { dirty = 1; }
		}
		// note: only one literal of v shall be marked at a time
		bool    marked(bool sign) const   { return (litMark & (1+int(sign))) != 0; }
		void    mark(bool sign)           { litMark = (1+int(sign)); }
		void    unmark()                  { litMark = 0; }
	};
	struct LessOccCost {
		explicit LessOccCost(OccurList*& occ) : occ_(occ) {}
		bool operator()(Var v1, Var v2) const { return occ_[v1].cost() < occ_[v2].cost(); }
	private:
		const LessOccCost& operator=(LessOccCost&);
		OccurList*& occ_;
	};
	typedef bk_lib::indexed_priority_queue ElimHeap;
	Clause*         peekSubQueue() const {
		assert(qFront_ < queue_.size());
		return (Clause*)clause( queue_[qFront_] );
	}
	inline Clause*  popSubQueue();
	inline void     addToSubQueue(uint32 clauseId);
	void            updateHeap(Var v) {
		assert(ctx_);
		if (!ctx_->varInfo(v).frozen() && !ctx_->eliminated(v)) {
			elimHeap_.update(v);
			if (occurs_[v].bce == 0 && occurs_[0].bce != 0) {
				occurs_[0].addWatch(v);
				occurs_[v].bce = 1;
			}
		}
	}
	inline uint32   findUnmarkedLit(const Clause& c, uint32 x) const;
	void    attach(uint32 cId, bool initialClause);
	void    detach(uint32 cId);
	void    bceVeRemove(uint32 cId, bool freeId, Var v, bool blocked);
	bool    propagateFacts();
	bool    backwardSubsume();
	Literal subsumes(const Clause& c, const Clause& other, Literal res) const;
	bool    strengthenClause(uint32 clauseId, Literal p);
	bool    subsumed(LitVec& cl);
	bool    eliminateVars();
	bool    bce();
	bool    bceVe(Var v, uint32 maxCnt);
	ClRange splitOcc(Var v, bool mark);
	bool    trivialResolvent(const Clause& c2, Var v) const;
	void    markAll(const Literal* lits, uint32 size) const;
	void    unmarkAll(const Literal* lits, uint32 size) const;
	bool    addResolvent(uint32 newId, const Clause& c1, const Clause& c2);
	bool    cutoff(Var v) const {
		return opts_->occLimit(occurs_[v].pos, occurs_[v].neg)
		  ||   (occurs_[v].cost() == 0 && ctx_->preserveModels());
	}
	bool    timeout() const { return time(0) > timeout_; }
	enum OccSign { pos = 0, neg = 1};
	OccurList*  occurs_;    // occur list for each variable
	ElimHeap    elimHeap_;  // candidates for variable elimination; ordered by increasing occurrence-cost
	VarVec      occT_[2];   // temporary clause lists used in eliminateVar
	ClauseList  resCands_;  // pairs of clauses to be resolved
	LitVec      resolvent_; // temporary, used in addResolvent
	VarVec      queue_;     // indices of clauses waiting for subsumption-check
	uint32      qFront_;    // front of queue_, i.e. [queue_.begin()+qFront_, queue.end()) is the subsumption queue
	uint32      facts_;     // [facts_, solver.trail.size()): new top-level facts
	std::time_t timeout_;   // stop once time > timeout_
};
}
#endif
clasp-3.2.2/libclasp/clasp/shared_context.h000066400000000000000000001164721304134206100207030ustar00rootroot00000000000000//
// Copyright (c) 2010-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_SHARED_CONTEXT_H_INCLUDED
#define CLASP_SHARED_CONTEXT_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
#include 
#include 
#include 
#include 
/*!
 * \file
 * \brief Contains common types shared between different solvers.
 */
namespace Clasp {
class Assignment;
class SharedLiterals;
struct SolverStats;
class StatisticObject;
typedef Asp::PrgDepGraph PrgDepGraph;
//! An immutable string with efficient copying.
/*!
 * \ingroup misc
 */
class ConstString {
public:
	//! Creates a string from str.
	/*!
	 * \note If o is Ownership_t::Acquire (the default), str is copied.
	 * Otherwise, no copy is made and the lifetime of str shall extend
	 * past that of the constructed object.
	 */
	ConstString(const char* str = "", Ownership_t::Type o = Ownership_t::Acquire);
	//! Creates a copy of str.
	ConstString(const StrView& str);
	ConstString(const ConstString& other);
	~ConstString();
	static ConstString fromLiteral(const char* str) { return ConstString(str, Ownership_t::Retain); }
	ConstString& operator=(const ConstString& rhs);
	const char* c_str()     const;
	operator const char* () const { return c_str(); }
	void swap(ConstString& o);
private:
	typedef uint64 RefType;
	RefType ref_;
};
/**
* \defgroup shared SharedContext
* \brief %SharedContext and related types.
*/

//! Base class for event handlers.
/*!
 * \ingroup shared
 */
class EventHandler : public ModelHandler {
public:
	//! Creates a handler for events with given verbosity or lower.
	explicit EventHandler(Event::Verbosity verbosity = Event::verbosity_quiet);
	virtual ~EventHandler();
	//! Sets the verbosity for the given event source.
	/*!
	 * Events with higher verbosity are not dispatched to this handler.
	 */
	void setVerbosity(Event::Subsystem sys, Event::Verbosity verb);
	//! Sets the active event source to sys if sys is not yet active.
	bool setActive(Event::Subsystem sys);
	Event::Subsystem active() const;
	uint32 verbosity(Event::Subsystem sys) const { return (uint32(verb_) >> (uint32(sys)<(ev.system))) { onEvent(ev); } }
	virtual void onEvent(const Event& /* ev */)  {}
	virtual bool onModel(const Solver&, const Model&) { return true; }
private:
	enum { VERB_SHIFT = 2u, VERB_MAX = 15u };
	EventHandler(const EventHandler&);
	EventHandler& operator=(const EventHandler&);
	uint16 verb_;
	uint16 sys_;
};

//! Event type for log or warning messages.
/*!
 * \ingroup enumerator
 */
struct LogEvent : Event_t {
	enum Type { Message = 'M', Warning = 'W' };
	LogEvent(Subsystem sys, Verbosity verb, Type t, const Solver* s, const char* what) : Event_t(sys, verb), solver(s), msg(what) {
		op = static_cast(t);
	}
	bool isWarning() const { return op == static_cast(Warning); }
	const Solver* solver;
	const char*   msg;
};

//! Base class for preprocessors working on clauses only.
/*!
 * \ingroup shared
 */
class SatPreprocessor {
public:
	//! A clause class optimized for preprocessing.
	class Clause {
	public:
		static Clause*  newClause(const Literal* lits, uint32 size);
		static uint64   abstractLit(Literal p)      { return uint64(1) << ((p.var()-1) & 63);  }
		uint32          size()                const { return size_;       }
		const Literal&  operator[](uint32 x)  const { return lits_[x];    }
		bool            inQ()                 const { return inQ_ != 0;   }
		uint64          abstraction()         const { return data_.abstr; }
		Clause*         next()                const { return data_.next;  }
		bool            marked()              const { return marked_ != 0;}
		Literal&        operator[](uint32 x)        { return lits_[x];    }
		void            setInQ(bool b)              { inQ_    = (uint32)b;}
		void            setMarked(bool b)           { marked_ = (uint32)b;}
		uint64&         abstraction()               { return data_.abstr; }
		Clause*         linkRemoved(Clause* next)   { data_.next = next; return this; }
		void            strengthen(Literal p);
		void            simplify(Solver& s);
		void            destroy();
	private:
		Clause(const Literal* lits, uint32 size);
		union {
			uint64  abstr;      // abstraction of literals
			Clause* next;       // next removed clause
		}       data_;
		uint32  size_   : 30; // size of the clause
		uint32  inQ_    : 1;  // in todo-queue?
		uint32  marked_ : 1;  // a marker flag
		Literal lits_[1];     // literals of the clause: [lits_[0], lits_[size_])
	};

	SatPreprocessor();
	virtual ~SatPreprocessor();

	//! Creates a clone of this preprocessor.
	/*!
	 * \note The function does not clone any clauses already added to *this.
	 */
	virtual SatPreprocessor* clone() = 0;

	uint32 numClauses() const { return (uint32)clauses_.size(); }
	//! Adds a clause to the preprocessor.
	/*!
	 * \pre clause is not a tautology (i.e. does not contain both l and ~l)
	 * \pre clause is a set (i.e. does not contain l more than once)
	 * \return true if clause was added. False if adding the clause makes the problem UNSAT
	 */
	bool addClause(const LitVec& cl) { return addClause(!cl.empty() ? &cl[0] : 0, sizeVec(cl)); }
	bool addClause(const Literal* clause, uint32 size);
	//! Runs the preprocessor on all clauses that were previously added.
	/*!
	 * \pre A ctx.startAddConstraint() was called and has variables for all added clauses.
	 */
	bool preprocess(SharedContext& ctx, SatPreParams& opts);
	bool preprocess(SharedContext& ctx);

	//! Force removal of state & clauses.
	void cleanUp(bool discardEliminated = false);

	//! Extends the model in m with values for any eliminated variables.
	void extendModel(ValueVec& m, LitVec& open);
	struct Stats {
		Stats() : clRemoved(0), clAdded(0), litsRemoved(0) {}
		uint32 clRemoved;
		uint32 clAdded;
		uint32 litsRemoved;
	} stats;
	typedef SatPreParams Options;
protected:
	typedef PodVector::type  ClauseList;
	virtual bool  initPreprocess(SatPreParams& opts) = 0;
	virtual bool  doPreprocess() = 0;
	virtual void  doExtendModel(ValueVec& m, LitVec& open) = 0;
	virtual void  doCleanUp() = 0;
	Clause*       clause(uint32 clId)       { return clauses_[clId]; }
	const Clause* clause(uint32 clId) const { return clauses_[clId]; }
	void          freezeSeen();
	void          discardClauses(bool discardEliminated);
	void          setClause(uint32 clId, const LitVec& cl) {
		clauses_[clId] = Clause::newClause(&cl[0], (uint32)cl.size());
	}
	void          destroyClause(uint32 clId){
		clauses_[clId]->destroy();
		clauses_[clId] = 0;
		++stats.clRemoved;
	}
	void          eliminateClause(uint32 id){
		elimTop_     = clauses_[id]->linkRemoved(elimTop_);
		clauses_[id] = 0;
		++stats.clRemoved;
	}
	SharedContext* ctx_;     // current context
	const Options* opts_;    // active options
	Clause*        elimTop_; // stack of blocked/eliminated clauses
private:
	SatPreprocessor(const SatPreprocessor&);
	SatPreprocessor& operator=(const SatPreprocessor&);
	ClauseList clauses_; // initial non-unit clauses
	LitVec     units_;   // initial unit clauses
	Range32    seen_;    // vars seen in previous step
};

///////////////////////////////////////////////////////////////////////////////
// Problem statistics
///////////////////////////////////////////////////////////////////////////////
/*!
 * \addtogroup shared
 * @{
 */
//! A struct for aggregating basic problem statistics.
struct ProblemStats {
	ProblemStats() { reset(); }
	struct { uint32 num, eliminated, frozen; } vars;
	struct { uint32 other, binary, ternary; } constraints;
	uint32  acycEdges;
	uint32  complexity;
	void    reset() { std::memset(this, 0, sizeof(*this)); }
	uint32  numConstraints() const   { return constraints.other + constraints.binary + constraints.ternary; }
	void diff(const ProblemStats& o) {
		vars.num           = std::max(vars.num, o.vars.num)-std::min(vars.num, o.vars.num);
		vars.eliminated    = std::max(vars.eliminated, o.vars.eliminated)-std::min(vars.eliminated, o.vars.eliminated);
		vars.frozen        = std::max(vars.frozen, o.vars.frozen)-std::min(vars.frozen, o.vars.frozen);
		constraints.other  = std::max(constraints.other, o.constraints.other) - std::min(constraints.other, o.constraints.other);
		constraints.binary = std::max(constraints.binary, o.constraints.binary) - std::min(constraints.binary, o.constraints.binary);
		constraints.ternary= std::max(constraints.ternary, o.constraints.ternary) - std::min(constraints.ternary, o.constraints.ternary);
		acycEdges          = std::max(acycEdges, o.acycEdges) - std::min(acycEdges, o.acycEdges);
	}
	void accu(const ProblemStats& o) {
		vars.num            += o.vars.num;
		vars.eliminated     += o.vars.eliminated;
		vars.frozen         += o.vars.frozen;
		constraints.other   += o.constraints.other;
		constraints.binary  += o.constraints.binary;
		constraints.ternary += o.constraints.ternary;
		acycEdges           += o.acycEdges;
	}
	// StatisticObject
	static uint32 size();
	static const char* key(uint32 i);
	StatisticObject at(const char* k) const;
};

//! Stores static information about a variable.
struct VarInfo {
	//! Possible flags.
	enum Flag {
		Mark_p = 0x1u,  //!< Mark for positive literal.
		Mark_n = 0x2u,  //!< Mark for negative literal.
		Input  = 0x4u,  //!< Is this var an input variable?
		Body   = 0x8u,  //!< Is this var representing a body?
		Eq     = 0x10u, //!< Is this var representing both a body and an atom?
		Nant   = 0x20u, //!< Is this var in NAnt(P)?
		Frozen = 0x40u, //!< Is the variable frozen?
		Output = 0x80u  //!< Is the variable an output variable?
	};
	static uint8 flags(VarType t) {
		if (t == Var_t::Body)  { return VarInfo::Body; }
		if (t == Var_t::Hybrid){ return VarInfo::Eq; }
		return 0;
	}
	explicit VarInfo(uint8 r = 0) : rep(r) { }
	//! Returns the type of the variable (or Var_t::Hybrid if variable was created with parameter eq=true).
	VarType type()          const { return has(VarInfo::Eq) ? Var_t::Hybrid : VarType(Var_t::Atom + has(VarInfo::Body)); }
	//! Returns whether var is part of negative antecedents (occurs negatively or in the head of a choice rule).
	bool    nant()          const { return has(VarInfo::Nant); }
	//! Returns true if var is excluded from variable elimination.
	bool    frozen()        const { return has(VarInfo::Frozen); }
	//! Returns true if var is an input variable.
	bool    input()         const { return has(VarInfo::Input); }
	//! Returns true if var is marked as output variable.
	bool    output()        const { return has(VarInfo::Output); }
	//! Returns the preferred sign of this variable w.r.t its type.
	/*!
	 * \return false (i.e no sign) if var originated from body, otherwise true.
	 */
	bool    preferredSign() const { return !has(VarInfo::Body); }

	bool    has(Flag f)     const { return (rep & flag(f)) != 0; }
	bool    has(uint32 f)   const { return (rep & f) != 0;       }
	bool    hasAll(uint32 f)const { return (rep & f) == f; }
	void    set(Flag f)           { rep |= flag(f); }
	void    toggle(Flag f)        { rep ^= flag(f); }
	static uint8 flag(Flag x)     { return uint8(x); }
	uint8 rep;
};

//! A class for efficiently storing and propagating binary and ternary clauses.
/*!
 * \ingroup shared_con
 */
class ShortImplicationsGraph {
public:
	ShortImplicationsGraph();
	~ShortImplicationsGraph();
	enum ImpType { binary_imp = 2, ternary_imp = 3 };

	//! Makes room for nodes number of nodes.
	void resize(uint32 nodes);
	//! Mark the instance as shared/unshared.
	/*!
	 * A shared instance adds learnt binary/ternary clauses
	 * to specialized shared blocks of memory.
	 */
	void markShared(bool b) { shared_ = b; }
	//! Adds the given constraint to the implication graph.
	/*!
	 * \return true iff a new implication was added.
	 */
	bool add(ImpType t, bool learnt, const Literal* lits);

	//! Removes p and its implications.
	/*!
	 * \pre s.isTrue(p)
	 */
	void removeTrue(const Solver& s, Literal p);

	//! Propagates consequences of p following from binary and ternary clauses.
	/*!
	 * \pre s.isTrue(p)
	 */
	bool   propagate(Solver& s, Literal p) const;
	//! Propagates immediate consequences of p following from binary clauses only.
	bool   propagateBin(Assignment& out, Literal p, uint32 dl) const;
	//! Checks whether there is a reverse arc implying p and if so returns it in out.
	bool   reverseArc(const Solver& s, Literal p, uint32 maxLev, Antecedent& out) const;

	uint32 numBinary() const { return bin_[0]; }
	uint32 numTernary()const { return tern_[0]; }
	uint32 numLearnt() const { return bin_[1] + tern_[1]; }
	uint32 numEdges(Literal p) const;
	uint32 size()      const { return sizeVec(graph_); }
	//! Applies op on all unary- and binary implications following from p.
	/*!
	 * OP must provide two functions:
	 *  - bool unary(Literal, Literal)
	 *  - bool binary(Literal, Literal, Literal)
	 * The first argument will be p, the second (resp. third) the unary
	 * (resp. binary) clause implied by p.
	 * \note For learnt imps, at least one literal has its watch-flag set.
	 */
	template 
	bool forEach(Literal p, const OP& op) const {
		const ImplicationList& x = graph_[p.id()];
		if (x.empty()) return true;
		ImplicationList::const_right_iterator rEnd = x.right_end(); // prefetch
		for (ImplicationList::const_left_iterator it = x.left_begin(), end = x.left_end(); it != end; ++it) {
			if (!op.unary(p, *it)) { return false; }
		}
		for (ImplicationList::const_right_iterator it = x.right_begin(); it != rEnd; ++it) {
			if (!op.binary(p, it->first, it->second)) { return false; }
		}
#if WITH_THREADS
		for (Block* b = (x).learnt; b ; b = b->next) {
			p.flag(); bool r = true;
			for (Block::const_iterator imp = b->begin(), endOf = b->end(); imp != endOf; ) {
				if (!imp->flagged()) { r = op.binary(p, imp[0], imp[1]); imp += 2; }
				else                 { r = op.unary(p, imp[0]);          imp += 1; }
				if (!r)              { return false; }
			}
		}
#endif
		return true;
	}
private:
	ShortImplicationsGraph(const ShortImplicationsGraph&);
	ShortImplicationsGraph& operator=(ShortImplicationsGraph&);
	struct Propagate;
	struct ReverseArc;
#if WITH_THREADS
	struct Block {
		typedef Clasp::mt::atomic atomic_size;
		typedef Clasp::mt::atomic atomic_ptr;
		typedef const Literal*      const_iterator;
		typedef       Literal*      iterator;
		enum { block_cap = (64 - (sizeof(atomic_size)+sizeof(atomic_ptr)))/sizeof(Literal) };
		explicit Block();
		const_iterator  begin() const { return data; }
		const_iterator  end()   const { return data+size(); }
		iterator        end()         { return data+size(); }
		uint32          size()  const { return size_lock >> 1; }
		bool tryLock(uint32& lockedSize);
		void addUnlock(uint32 lockedSize, const Literal* x, uint32 xs);
		atomic_ptr  next;
		atomic_size size_lock;
		Literal     data[block_cap];
	};
	typedef Block::atomic_ptr SharedBlockPtr;
	typedef bk_lib::left_right_sequence, 64-sizeof(SharedBlockPtr)> ImpListBase;
	struct ImplicationList : public ImpListBase {
		ImplicationList() : ImpListBase() { learnt = 0; }
		ImplicationList(const ImplicationList& other) : ImpListBase(other), learnt() {
			learnt = static_cast(other.learnt);
		}
		ImplicationList& operator=(const ImplicationList& other) {
			ImpListBase::operator=(other);
			learnt = static_cast(other.learnt);
			return *this;
		}
		~ImplicationList();
		bool hasLearnt(Literal q, Literal r = lit_false()) const;
		void addLearnt(Literal q, Literal r = lit_false());
		void simplifyLearnt(const Solver& s);
		bool empty() const { return ImpListBase::empty() && learnt == static_cast(0); }
		void move(ImplicationList& other);
		void clear(bool b);
		SharedBlockPtr learnt;
	};
#else
	typedef bk_lib::left_right_sequence, 64> ImplicationList;
#endif
	ImplicationList& getList(Literal p) { return graph_[p.id()]; }
	void remove_bin(ImplicationList& w, Literal p);
	void remove_tern(ImplicationList& w, Literal p);
	typedef PodVector::type ImpLists;
	ImpLists graph_;     // one implication list for each literal
	uint32   bin_[2];    // number of binary constraints (0: problem / 1: learnt)
	uint32   tern_[2];   // number of ternary constraints(0: problem / 1: learnt)
	bool     shared_;
};

//! Base class for distributing learnt knowledge between solvers.
class Distributor {
public:
	struct Policy {
		enum Types {
			no       = 0,
			conflict = Constraint_t::Conflict,
			loop     = Constraint_t::Loop,
			all      = conflict | loop,
			implicit = all + 1
		};
		Policy(uint32 a_sz = 0, uint32 a_lbd = 0, uint32 a_type = 0) : size(a_sz), lbd(a_lbd), types(a_type) {}
		uint32 size  : 22; /*!< Allow distribution up to this size only. */
		uint32 lbd   :  7; /*!< Allow distribution up to this lbd only.  */
		uint32 types :  3; /*!< Restrict distribution to these types.    */
	};
	static  uint64  mask(uint32 i)             { return uint64(1) << i; }
	static  uint32  initSet(uint32 sz)         { return (uint64(1) << sz) - 1; }
	static  bool    inSet(uint64 s, uint32 id) { return (s & mask(id)) != 0; }
	explicit Distributor(const Policy& p);
	virtual ~Distributor();
	bool            isCandidate(uint32 size, uint32 lbd, uint32 type) const {
		return size <= policy_.size && lbd <= policy_.lbd && ((type & policy_.types) != 0);
	}
	virtual void    publish(const Solver& source, SharedLiterals* lits) = 0;
	virtual uint32  receive(const Solver& in, SharedLiterals** out, uint32 maxOut) = 0;
private:
	Distributor(const Distributor&);
	Distributor& operator=(const Distributor&);
	Policy policy_;
};

//! Output table that contains predicates to be output on model.
class OutputTable {
public:
	typedef ConstString NameType;
	typedef Range32     RangeType;
	struct PredType {
		NameType name;
		Literal  cond;
		uint32   user;
	};
	typedef PodVector::type FactVec;
	typedef PodVector::type PredVec;
	typedef FactVec::const_iterator   fact_iterator;
	typedef PredVec::const_iterator   pred_iterator;
	typedef num_iterator      range_iterator;
	typedef LitVec::const_iterator    lit_iterator;
	enum ProjectMode { project_output = 0u, project_explicit = 1u };

	OutputTable();
	~OutputTable();
	//! Ignore predicates starting with c.
	void setFilter(char c);
	//! Adds a fact.
	bool add(const NameType& fact);
	//! Adds an output predicate, i.e. n is output if c is true.
	bool add(const NameType& n, Literal c, uint32 u = 0);
	//! Sets a range of output variables.
	void setVarRange(const RangeType& r);

	//! Returns whether n would be filtered out.
	bool filter(const NameType& n) const;

	fact_iterator  fact_begin() const { return facts_.begin(); }
	fact_iterator  fact_end()   const { return facts_.end();  }
	pred_iterator  pred_begin() const { return preds_.begin(); }
	pred_iterator  pred_end()   const { return preds_.end();  }
	range_iterator vars_begin() const { return range_iterator(vars_.lo); }
	range_iterator vars_end()   const { return range_iterator(vars_.hi); }

	ProjectMode    projectMode()const { return proj_.empty() ? project_output : project_explicit; }
	lit_iterator   proj_begin() const { return proj_.begin(); }
	lit_iterator   proj_end()   const { return proj_.end(); }
	void           addProject(Literal x);

	//! Returns the number of output elements, counting each element in a var range.
	uint32 size()     const;
	uint32 numFacts() const { return static_cast(facts_.size()); }
	uint32 numPreds() const { return static_cast(preds_.size()); }
	uint32 numVars()  const { return static_cast(vars_.hi - vars_.lo);  }

	//! An optional callback for getting additional theory output.
	class Theory {
	public:
		virtual ~Theory();
		//! Called once on new model m. Shall return 0 to indicate no output.
		virtual const char* first(const Model& m) = 0;
		//! Shall return 0 to indicate no output.
		virtual const char* next() = 0;
	}* theory;
private:
	FactVec facts_;
	PredVec preds_;
	LitVec  proj_;
	Range32 vars_;
	char    hide_;
};
//! A type for storing information to be used in clasp's domain heuristic.
class DomainTable {
public:
	DomainTable();
	//! A type storing a single domain modification for a variable.
	class ValueType {
	public:
		ValueType(Var v, DomModType t, int16 bias, uint16 prio, Literal cond);
		bool       hasCondition() const { return cond_ != 0; }
		Literal    cond() const { return Literal::fromId(cond_); }
		Var        var()  const { return var_; }
		DomModType type() const;
		int16      bias() const { return bias_; }
		uint16     prio() const { return prio_; }
		bool       comp() const { return comp_ != 0; }
	private:
		uint32 cond_ : 31;
		uint32 comp_ :  1;
		uint32 var_  : 30;
		uint32 type_ :  2;
		int16  bias_;
		uint16 prio_;
	};
	typedef PodVector::type DomVec;
	typedef DomVec::const_iterator     iterator;

	void   add(Var v, DomModType t, int16 bias, uint16 prio, Literal cond);
	uint32 simplify();
	void   reset();
	bool     empty() const;
	uint32   size()  const;
	iterator begin() const;
	iterator end()   const;
	LitVec* domRec;
private:
	static bool cmp(const ValueType& lhs, const ValueType& rhs) {
		return lhs.cond() < rhs.cond() || (lhs.cond() == rhs.cond() && lhs.var() < rhs.var());
	}
	DomVec entries_;
	uint32 seen_;   // size of domain table after last simplify
};

//! Aggregates information to be shared between solver objects.
/*!
 * Among other things, SharedContext objects store
 * static information on variables, an output table, as well as the
 * binary and ternary implication graph of the input problem.
 *
 * Furthermore, a SharedContext object always stores a distinguished
 * master solver that is used to store and simplify problem constraints.
 * Additional solvers can be added via SharedContext::pushSolver().
 * Once initialization is completed, any additional solvers must be attached
 * to this object by calling SharedContext::attach().
 */
class SharedContext {
public:
	typedef PodVector::type       SolverVec;
	typedef SingleOwnerPtr    SccGraph;
	typedef SingleOwnerPtr    ExtGraph;
	typedef Configuration*                 ConfigPtr;
	typedef SingleOwnerPtr    DistrPtr;
	typedef const ProblemStats&            StatsCRef;
	typedef DomainTable                    DomTab;
	typedef OutputTable                    Output;
	typedef LitVec::size_type              size_type;
	typedef ShortImplicationsGraph         ImpGraph;
	typedef const ImpGraph&                ImpGraphRef;
	typedef EventHandler*                  LogPtr;
	typedef SingleOwnerPtrSatPrePtr;
	typedef SharedMinimizeData*            MinPtr;
	enum ResizeMode { resize_reserve = 0u, resize_push = 1u, resize_pop = 2u, resize_resize = 3u};
	enum PreproMode { prepro_preserve_models = 1u, prepro_preserve_shown  = 2u };
	enum ReportMode { report_default = 0u, report_conflict = 1u };
	enum SolveMode  { solve_once = 0u, solve_multi = 1u };
	/*!
	 * \name Configuration
	 * \brief Functions for creating and configuring a shared context.
	 * @{ */
	//! Creates a new object for sharing variables and the binary and ternary implication graph.
	explicit SharedContext();
	~SharedContext();
	//! Resets this object to the state after default construction.
	void       reset();
	//! Enables event reporting via the given event handler.
	void       setEventHandler(LogPtr r, ReportMode m = report_default) { progress_ = r; share_.report = uint32(m); }
	//! Sets solve mode, which can be used by other objects to query whether multi-shot solving is active.
	void       setSolveMode(SolveMode m);
	//! Sets how to handle physical sharing of constraints.
	void       setShareMode(ContextParams::ShareMode m);
	//! Sets whether the short implication graph should be used for storing short learnt constraints.
	void       setShortMode(ContextParams::ShortMode m);
	//! Sets maximal number of solvers sharing this object.
	void       setConcurrency(uint32 numSolver, ResizeMode m = resize_reserve);
	//! If b is true, sets preprocessing mode to model-preserving operations only.
	void       setPreserveModels(bool b = true) { setPreproMode(prepro_preserve_models, b); }
	//! If b is true, excludes all shown variables from variable elimination.
	void       setPreserveShown(bool b = true)  { setPreproMode(prepro_preserve_shown, b); }

	//! Adds an additional solver to this object and returns it.
	Solver&    pushSolver();
	//! Configures the statistic object of attached solvers.
	/*!
	 * The level determines the amount of extra statistics.
	 * \see ExtendedStats
	 * \see JumpStats
   */
	void       enableStats(uint32 level);
	//! Sets the configuration for this object and its attached solvers.
	/*!
	 * \note If ownership is Ownership_t::Acquire, ownership of c is transferred.
	 */
	void       setConfiguration(Configuration* c, Ownership_t::Type ownership);
	SatPrePtr  satPrepro;  /*!< Preprocessor for simplifying the problem.              */
	SccGraph   sccGraph;   /*!< Program dependency graph - only used for ASP-problems. */
	ExtGraph   extGraph;   /*!< External dependency graph - given by user.             */

	//! Returns the current configuration used in this object.
	ConfigPtr  configuration()      const { return config_.get(); }
	//! Returns the active event handler or 0 if none was set.
	LogPtr     eventHandler()       const { return progress_; }
	//! Returns whether this object seeds the RNG of new solvers.
	bool       seedSolvers()        const { return share_.seed != 0; }
	//! Returns the number of solvers that can share this object.
	uint32     concurrency()        const { return share_.count; }
	bool       preserveModels()     const { return (share_.satPreM & prepro_preserve_models) != 0; }
	bool       preserveShown()      const { return (share_.satPreM & prepro_preserve_shown) != 0; }
	//! Returns whether physical sharing is enabled for constraints of type t.
	bool       physicalShare(ConstraintType t) const { return (share_.shareM & (1 + (t != Constraint_t::Static))) != 0; }
	//! Returns whether pyhiscal sharing of problem constraints is enabled.
	bool       physicalShareProblem()          const { return (share_.shareM & ContextParams::share_problem) != 0; }
	//! Returns whether short constraints of type t can be stored in the short implication graph.
	bool       allowImplicit(ConstraintType t) const { return t != Constraint_t::Static ? share_.shortM != ContextParams::short_explicit : !isShared(); }
	//! Returns the configured solve mode.
	SolveMode  solveMode() const { return static_cast(share_.solveM); }
	//@}

	/*!
	 * \name Problem introspection
	 * \brief Functions for querying information about the problem.
	 */
	//@{
	//! Returns true unless the master has an unresolvable top-level conflict.
	bool       ok()                 const;
	//! Returns whether the problem is currently frozen and therefore ready for being solved.
	bool       frozen()             const { return share_.frozen;}
	//! Returns whether more than one solver is actively working on the problem.
	bool       isShared()           const { return frozen() && concurrency() > 1; }
	//! Returns whether the problem is more than a simple CNF.
	bool       isExtended()         const { return stats_.vars.frozen != 0; }
	//! Returns whether this object has a solver associcated with the given id.
	bool       hasSolver(uint32 id) const { return id < solvers_.size(); }
	//! Returns the master solver associated with this object.
	Solver*    master()             const { return solver(0);    }
	//! Returns the solver with the given id.
	Solver*    solver(uint32 id)    const { return solvers_[id]; }

	//! Returns the number of problem variables.
	/*!
	 * \note The special sentinel-var 0 is not counted, i.e. numVars() returns
	 * the number of problem-variables.
	 * To iterate over all problem variables use a loop like:
	 * \code
	 * for (Var i = 1; i <= numVars(); ++i) {...}
	 * \endcode
	 */
	uint32     numVars()            const { return static_cast(varInfo_.size() - 1); }
	//! Returns the number of eliminated vars.
	uint32     numEliminatedVars()  const { return stats_.vars.eliminated; }
	//! Returns true if var represents a valid variable in this problem.
	/*!
	 * \note The range of valid variables is [1..numVars()]. The variable 0
	 * is a special sentinel variable.
	 */
	bool       validVar(Var var)    const { return var < static_cast(varInfo_.size()); }
	//! Returns information about the given variable.
	VarInfo    varInfo(Var v)       const { assert(validVar(v)); return varInfo_[v]; }
	//! Returns true if v is currently eliminated, i.e. no longer part of the problem.
	bool       eliminated(Var v)    const;
	bool       marked(Literal p)    const { return varInfo(p.var()).has(VarInfo::Mark_p + p.sign()); }
	//! Returns the number of problem constraints.
	uint32     numConstraints()     const;
	//! Returns the number of binary constraints.
	uint32     numBinary()          const { return btig_.numBinary();  }
	//! Returns the number of ternary constraints.
	uint32     numTernary()         const { return btig_.numTernary(); }
	//! Returns the number of unary constraints.
	uint32     numUnary()           const { return lastTopLevel_; }
	//! Returns an estimate of the problem complexity based on the number and type of constraints.
	uint32     problemComplexity()  const;
	//! Returns whether the problem contains minimize (i.e. weak) constraints.
	bool       hasMinimize()        const;
	StatsCRef  stats()              const { return stats_; }
	//@}

	/*!
	 * \name Problem setup
	 * \brief Functions for specifying the problem.
	 *
	 * Problem specification is a four-stage process:
	 * -# Add variables to the SharedContext object.
	 * -# Call startAddConstraints().
	 * -# Add problem constraints.
	 * -# Call endInit() to finish the initialization process.
	 * .
	 * \note After endInit() was called, other solvers can be attached to this object.
	 * \note In incremental setting, the process must be repeated for each incremental step.
	 *
	 * \note Problem specification is *not* thread-safe, i.e. during initialization no other thread shall
	 * access the context.
	 *
	 * \note !frozen() is a precondition for all functions in this group!
	 * @{ */
	//! Unfreezes a frozen program and prepares it for updates.
	/*!
	 * The function also triggers forgetting of volatile knowledge and removes
	 * any auxiliary variables.
	 * \see requestStepVar()
	 * \see Solver::popAuxVar()
	 */
	bool    unfreeze();

	//! Adds a new variable and returns its numerical id.
	/*!
	 * \param type  Type of variable.
	 * \param flags Additional information associated with the new variable.
	 * \note Problem variables are numbered from 1 onwards!
	 */
	Var     addVar(VarType type, uint8 flags = VarInfo::Nant | VarInfo::Input) { return addVars(1, type, flags); }
	Var     addVars(uint32 nVars, VarType type, uint8 flags = VarInfo::Nant | VarInfo::Input);
	//! Removes the n most recently added problem variables.
	/*!
	 * \pre The variables have either not yet been committed by a call to startAddConstraints()
	 *      or they do not occur in any constraint.
	 */
	void    popVars(uint32 n = 1);
	//! Freezes/defreezes a variable (a frozen var is exempt from Sat-preprocessing).
	void    setFrozen(Var v, bool b);
	//! Marks/unmarks v as input variable.
	void    setInput(Var v, bool b) { set(v, VarInfo::Input, b); }
	//! Marks/unmarks v as output variable.
	void    setOutput(Var v, bool b) { set(v, VarInfo::Output, b); }
	//! Marks/unmarks v as part of negative antecedents.
	void    setNant(Var v, bool b)  { set(v, VarInfo::Nant, b); }
	void    setVarEq(Var v, bool b) { set(v, VarInfo::Eq, b); }
	void    set(Var v, VarInfo::Flag f, bool b) { if (b != varInfo(v).has(f)) varInfo_[v].toggle(f); }
	void    mark(Literal p)         { assert(validVar(p.var())); varInfo_[p.var()].rep |= (VarInfo::Mark_p + p.sign()); }
	void    unmark(Var v)           { assert(validVar(v)); varInfo_[v].rep &= ~(VarInfo::Mark_p|VarInfo::Mark_n); }
	//! Eliminates the variable v from the problem.
	/*!
	 * \pre v must not occur in any constraint and frozen(v) == false and value(v) == value_free
	 */
	void    eliminate(Var v);

	//! Prepares the master solver so that constraints can be added.
	/*!
	 * Must be called to publish previously added variables to master solver
	 * and before constraints over these variables can be added.
	 * \return The master solver associated with this object.
	 */
	Solver& startAddConstraints(uint32 constraintGuess = 100);

	//! A convenience method for adding facts to the master.
	bool    addUnary(Literal x);
	//! A convenience method for adding binary clauses.
	bool    addBinary(Literal x, Literal y);
	//! A convenience method for adding ternary clauses.
	bool    addTernary(Literal x, Literal y, Literal z);
	//! A convenience method for adding constraints to the master.
	void    add(Constraint* c);
	//! Add weak constraint :~ x.first \[x.second\@p\].
	void    addMinimize(WeightLiteral x, weight_t p);
	//! Returns a pointer to an optimized representation of all minimize constraints in this problem.
	MinPtr  minimize();
	//! List of output predicates and/or variables.
	Output  output;
	//! Set of heuristic modifications.
	DomTab  heuristic;
	//! Requests a special variable for tagging volatile knowledge in multi-shot solving.
	/*!
	 * The step variable is created on the next call to endInit() and removed on the next
	 * call to unfreeze().
	 * Once the step variable S is set, learnt constraints containing ~S are
	 * considered to be "volatile" and removed on the next call to unfreeze().
	 * For this to work correctly, S shall be a root assumption during search.
	 */
	void    requestStepVar();
	//! Finishes initialization of the master solver.
	/*!
	 * The function must be called once before search is started. After endInit()
	 * was called, previously added solvers can be attached to the
	 * shared context and learnt constraints may be added to solver.
	 * \param attachAll If true, also calls attach() for all solvers that were added to this object.
	 * \return If the constraints are initially conflicting, false. Otherwise, true.
	 * \note
	 * The master solver can't recover from top-level conflicts, i.e. if endInit()
	 * returned false, the solver is in an unusable state.
	 * \post frozen()
	 */
	bool    endInit(bool attachAll = false);
	//@}

	/*!
	 * \name (Parallel) solving
	 * Functions to be called during (parallel) solving.
	 *
	 * \note If not otherwise noted, the functions in this group can be safely called
	 * from multiple threads.
	 * @{ */
	//! Returns the active step literal (see requestStepVar()).
	Literal  stepLiteral() const { return step_; }
	//! Attaches the solver with the given id to this object.
	/*!
	 * \note It is safe to attach multiple solvers concurrently
	 * but the master solver shall not change during the whole operation.
	 *
	 * \pre hasSolver(id)
	 */
	bool     attach(uint32 id) { return attach(*solver(id)); }
	bool     attach(Solver& s);

	//! Detaches the solver with the given id from this object.
	/*!
	 * The function removes any tentative constraints from s.
	 * Shall be called once after search has stopped.
	 * \note The function is concurrency-safe w.r.t to different solver objects,
	 *       i.e. in a parallel search different solvers may call detach()
	 *       concurrently.
	 */
	void     detach(uint32 id, bool reset = false) { return detach(*solver(id), reset); }
	void     detach(Solver& s, bool reset = false);

	DistrPtr distributor;/*!< Distributor object to use for distribution of learnt constraints.*/

	uint32   winner()             const   { return share_.winner; }
	void     setWinner(uint32 sId)        { share_.winner = std::min(sId, concurrency()); }

	//! Simplifies the problem constraints w.r.t the master's assignment.
	void     simplify(bool shuffle);
	//! Removes the constraint with the given idx from the master's db.
	void     removeConstraint(uint32 idx, bool detach);
	//! Removes all minimize constraints from this object.
	void     removeMinimize();

	//! Adds the given short implication to the short implication graph if possible.
	/*!
	 * \return
	 *   - > 0 if implication was added.
	 *   - < 0 if implication can't be added because allowImplicit() is false for ct.
	 *   - = 0 if implication is subsumed by some constraint in the short implication graph.
	 */
	int         addImp(ImpGraph::ImpType t, const Literal* lits, ConstraintType ct);
	//! Returns the number of learnt short implications.
	uint32      numLearntShort()     const { return btig_.numLearnt(); }
	ImpGraphRef shortImplications()  const { return btig_; }
	void        simplifyShort(const Solver& s, Literal p);
	void               report(const Event& ev)                 const { if (progress_) progress_->dispatch(ev);  }
	bool               report(const Solver& s, const Model& m) const { return !progress_ || progress_->onModel(s, m); }
	void               report(const char* what, const Solver* s = 0) const;
	void               report(Event::Subsystem sys)            const;
	void               warn(const char* what)                  const;
	ReportMode         reportMode()                            const { return static_cast(share_.report); }
	void               initStats(Solver& s)                    const;
	SolverStats&       solverStats(uint32 sId)                 const; // stats of solver i
	const SolverStats& accuStats(SolverStats& out)             const; // accumulates all solver stats in out
	//@}
private:
	SharedContext(const SharedContext&);
	SharedContext& operator=(const SharedContext&);
	bool    unfreezeStep();
	Literal addStepLit();
	typedef SingleOwnerPtr Config;
	typedef PodVector::type      VarVec;
	void    setPreproMode(uint32 m, bool b);
	struct Minimize;
	ProblemStats stats_;         // problem statistics
	VarVec       varInfo_;       // varInfo[v] stores info about variable v
	ImpGraph     btig_;          // binary-/ternary implication graph
	Config       config_;        // active configuration
	SolverVec    solvers_;       // solvers associated with this context
	Minimize*    mini_;          // pointer to set of weak constraints
	LogPtr       progress_;      // event handler or 0 if not used
	Literal      step_;          // literal for tagging enumeration/step constraints
	uint32       lastTopLevel_;  // size of master's top-level after last init
	struct Share {               // Additional data
		uint32 count   :10;        //   max number of objects sharing this object
		uint32 winner  :10;        //   id of solver that terminated the search
		uint32 shareM  : 3;        //   physical sharing mode
		uint32 shortM  : 1;        //   short clause mode
		uint32 solveM  : 1;        //   solve mode
		uint32 frozen  : 1;        //   is adding of problem constraints allowed?
		uint32 seed    : 1;        //   set seed of new solvers
		uint32 satPreM : 2;        //   preprocessing mode
		uint32 report  : 2;        //   report mode
		uint32 reserved: 1;
		Share() : count(1), winner(0), shareM((uint32)ContextParams::share_auto), shortM(0), solveM(0), frozen(0), seed(0), satPreM(0), report(0) {}
	}            share_;
};
//@}
}
#endif
clasp-3.2.2/libclasp/clasp/solve_algorithms.h000066400000000000000000000233311304134206100212410ustar00rootroot00000000000000//
// Copyright (c) 2006-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_SOLVE_ALGORITHMS_H_INCLUDED
#define CLASP_SOLVE_ALGORITHMS_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 
/*!
 * \file
 * \brief Defines top-level functions for solving problems.
 */
namespace Clasp {

///! \addtogroup enumerator
//@{

//! Type for holding global solve limits.
struct SolveLimits {
	explicit SolveLimits(uint64 conf = UINT64_MAX, uint64 r = UINT64_MAX)
		: conflicts(conf)
		, restarts(r) {
	}
	bool   reached() const { return conflicts == 0 || restarts == 0; }
	bool   enabled() const { return conflicts != UINT64_MAX || restarts != UINT32_MAX; }
	uint64 conflicts; /*!< Number of conflicts. */
	uint64 restarts;  /*!< Number of restarts.  */
};

///////////////////////////////////////////////////////////////////////////////
// Basic solving
///////////////////////////////////////////////////////////////////////////////
//! Basic (sequential) solving using given solving options.
class BasicSolve {
public:
	//! Creates a new object for solving with the given solver using the given solving options.
	/*!
	 * If an optional solve limit is given, solving stops once this limit is reached.
	 * \pre s is attached to a problem (SharedContext).
	 */
	BasicSolve(Solver& s, const SolveParams& p, const SolveLimits& lim = SolveLimits());
	BasicSolve(Solver& s, const SolveLimits& lim = SolveLimits());
	~BasicSolve();

	bool     hasLimit() const { return limits_.enabled(); }

	//! Enables solving under the given assumptions.
	/*!
	 * The use of assumptions allows for incremental solving. Literals contained
   * in assumptions are assumed to be true during search but can be undone afterwards.
	 *
	 * \param assumptions A list of unit assumptions to be assumed true.
	 * \return false if assumptions are conflicting.
	 */
	bool     assume(const LitVec& assumptions);

	//! Solves the path stored in the given solver using the given solving options.
	/*!
	 * \return
	 *    - value_true  if search stopped on a model.
	 *    - value_false if the search-space was completely examined.
	 *    - value_free  if the given solve limit was hit.
	 *
	 * \note
	 *   The function maintains the current solving state (number of restarts, learnt limits, ...)
	 *   between calls.
	 */
	ValueRep solve();
	//! Returns whether the given problem is satisfiable under the given assumptions.
	/*!
	 * Calls assume(assumptions) followed by solve() but does not maintain any solving state.
	 * \param assumptions Possibly empty set of assumptions to apply before solving.
	 * \param init Call InitParams::randomize() before starting search?
	 */
	bool     satisfiable(const LitVec& assumptions, bool init);

	//! Resets the internal solving state while keeping the solver and the solving options.
	void     reset(bool reinit = false);
	//! Replaces *this with BasicSolve(s, p).
	void     reset(Solver& s, const SolveParams& p, const SolveLimits& lim = SolveLimits());
	Solver&  solver() { return *solver_; }
private:
	BasicSolve(const BasicSolve&);
	BasicSolve& operator=(const BasicSolve&);
	typedef const SolveParams Params;
	typedef SolveLimits       Limits;
	struct State;
	Solver* solver_; // active solver
	Params* params_; // active solving options
	Limits  limits_; // active solving limits
	State*  state_;  // internal solving state
};
//! Event type for reporting basic solve events like restarts or deletion.
struct BasicSolveEvent : SolveEvent {
	//! Type of operation that emitted the event.
	enum EventOp { event_none = 0, event_deletion = 'D', event_exit = 'E', event_grow = 'G', event_restart = 'R' };
	BasicSolveEvent(const Solver& s, EventOp a_op, uint64 cLim, uint32 lLim) : SolveEvent(s, verbosity_max), cLimit(cLim), lLimit(lLim) {
		op = a_op;
	}
	uint64 cLimit; //!< Next conflict limit
	uint32 lLimit; //!< Next learnt limit
};
///////////////////////////////////////////////////////////////////////////////
// General solve
///////////////////////////////////////////////////////////////////////////////
class Enumerator;
//! Interface for complex solve algorithms.
/*!
 * \ingroup enumerator
 * \relates Solver
 * SolveAlgorithms implement complex algorithms like enumeration or optimization.
 */
class SolveAlgorithm {
public:
	/*!
	 * \param limit An optional solve limit applied in solve().
	 */
	explicit SolveAlgorithm(const SolveLimits& limit = SolveLimits());
	virtual ~SolveAlgorithm();

	const Enumerator*   enumerator() const { return enum_.get(); }
	const SolveLimits&  limits()     const { return limits_; }
	virtual bool        interrupted()const = 0;
	const Model&        model()      const;

	void setEnumerator(Enumerator& e);
	void setEnumLimit(uint64 m)          { enumLimit_= m;  }
	void setLimits(const SolveLimits& x) { limits_   = x;  }

	//! Runs the solve algorithm.
	/*!
	 * \param ctx     A context object containing the problem.
	 * \param assume  A list of initial unit-assumptions.
	 * \param onModel Optional handler to be called on each model.
	 *
	 * \return
	 *  - true:  if the search stopped before the search-space was exceeded.
	 *  - false: if the search-space was completely examined.
	 *
	 * \note
	 * The use of assumptions allows for incremental solving. Literals contained
	 * in assumptions are assumed to be true during search but are undone before solve returns.
	 *
	 * \note
	 * Conceptually, solve() behaves as follows:
	 * \code
	 * start(ctx, assume);
	 * while (next()) {
	 *   if (!report(model()) || enum_limit_reached()) { stop(); }
	 * }
	 * return more();
	 * \endcode
	 * where report() notifies all registered model handlers.
	 */
	bool solve(SharedContext& ctx, const LitVec& assume = LitVec(), ModelHandler* onModel = 0);

	//! Prepares the solve algorithm for enumerating models.
	/*!
	 * \pre The algorithm is not yet active.
	 */
	void start(SharedContext& ctx, const LitVec& assume = LitVec(), ModelHandler* onModel = 0);
	//! Searches for the next model and returns whether such a model was found.
	/*!
	 * \pre start() was called.
	 */
	bool next();
	//! Stops the algorithms.
	void stop();
	//! Returns whether the last search completely exhausted the search-space.
	bool more();

	//! Resets solving state and sticky messages like terminate.
	/*!
	 * \note The function must be called between successive calls to solve().
	 */
	virtual void resetSolve()        = 0;

	//! Prepares the algorithm for handling (asynchronous) calls to SolveAlgorithm::interrupt().
	virtual void enableInterrupts()  = 0;

	//! Tries to terminate the current solve process.
	/*!
	 * \note If enableInterrupts() was not called, SolveAlgorithm::interrupt() may return false
	 * to signal that (asynchronous) termination is not supported.
	 */
	bool         interrupt();
protected:
	SolveAlgorithm(const SolveAlgorithm&);
	SolveAlgorithm& operator=(const SolveAlgorithm&);
	//! The actual solve algorithm.
	virtual bool    doSolve(SharedContext& ctx, const LitVec& assume) = 0;
	//! Shall return true if termination is supported, otherwise false.
	virtual bool    doInterrupt()                                     = 0;

	virtual void    doStart(SharedContext& ctx, const LitVec& assume);
	virtual int     doNext(int last);
	virtual void    doStop();

	bool            reportModel(Solver& s) const;
	bool            reportUnsat(Solver& s) const;
	Enumerator&     enumerator()       { return *enum_;  }
	SharedContext&  ctx()        const { return *ctx_; }
	const LitVec&   path()       const { return *path_; }
	uint64          maxModels() const  { return enumLimit_; }
	bool            moreModels(const Solver& s) const;
private:
	typedef SingleOwnerPtr   EnumPtr;
	typedef SingleOwnerPtr PathPtr;
	enum { value_stop = value_false|value_true };
	bool attach(SharedContext& ctx, ModelHandler* onModel);
	void detach();
	SolveLimits    limits_;
	SharedContext* ctx_;
	EnumPtr        enum_;
	ModelHandler*  onModel_;
	PathPtr        path_;
	uint64         enumLimit_;
	double         time_;
	int            last_;
};
//! A class that implements clasp's sequential solving algorithm.
class SequentialSolve : public SolveAlgorithm {
public:
	explicit SequentialSolve(const SolveLimits& limit = SolveLimits());
	virtual bool interrupted() const;
	virtual void resetSolve();
	virtual void enableInterrupts();
protected:
	virtual bool doSolve(SharedContext& ctx, const LitVec& assume);
	virtual bool doInterrupt();
	virtual void doStart(SharedContext& ctx, const LitVec& assume);
	virtual int  doNext(int last);
	virtual void doStop();
private:
	typedef SingleOwnerPtr SolvePtr;
	SolvePtr     solve_;
	volatile int term_;
};

//! Options for controlling solving.
struct BasicSolveOptions {
	SolveLimits     limit;  //!< Solve limit (disabled by default).
	SolveAlgorithm* createSolveObject() const { return new SequentialSolve(limit); }
	static uint32   supportedSolvers()        { return 1; }
	static uint32   recommendedSolvers()      { return 1; }
	uint32          numSolver() const         { return 1; }
	void            setSolvers(uint32)        {}
	bool            defaultPortfolio() const  { return false; }
};
//@}

}
#endif
clasp-3.2.2/libclasp/clasp/solver.h000066400000000000000000001335231304134206100171770ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_SOLVER_H_INCLUDED
#define CLASP_SOLVER_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
#include 

namespace Clasp {

/**
 * \file
 * \defgroup solver Solver
 * \brief %Solver and related classes.
 */
//@{

//! clasp's Solver class.
/*!
 * A Solver-object maintains the state and provides the functions
 * necessary to implement our CDNL-algorithm.
 *
 * The interface supports incremental solving (search under assumptions) as well as
 * solution enumeration. To make this possible the solver maintains two special
 * decision levels: the root-level and the backtrack-level.
 *
 * The root-level is the lowest decision level to which a search
 * can return. Conflicts on the root-level are non-resolvable and end a search - the
 * root-level therefore acts as an artificial top-level during search.
 * Incremental solving is then implemented by first adding a list of unit assumptions
 * and second initializing the root-level to the current decision level.
 * Once search terminates assumptions can be undone by calling clearAssumptions
 * and a new a search can be started using different assumptions.
 *
 * For model enumeration the solver maintains a backtrack-level that restricts
 * backjumping in order to prevent repeating already enumerated solutions.
 * The solver will never backjump above that level and conflicts on the backtrack-level
 * are resolved by backtracking, i.e. flipping the corresponding decision literal.
 *
 * \see "Conflict-Driven Answer Set Enumeration" for a detailed description of this approach.
 *
 */
class Solver {
public:
	typedef PodVector::type      ConstraintDB;
	typedef const ConstraintDB&               DBRef;
	typedef SingleOwnerPtr HeuristicPtr;
private:
	friend class SharedContext;
	// Creates an empty solver object with all strategies set to their default value.
	Solver(SharedContext* ctx, uint32 id);
	~Solver();
	// Resets a solver object to the state it had after construction.
	void reset();
	void resetConfig();
	void startInit(uint32 constraintGuess, const SolverParams& params);
	void updateVars();
	bool cloneDB(const ConstraintDB& db);
	bool preparePost();
	bool endInit();
	bool endStep(uint32 top, const SolverParams& params);
public:
	typedef SolverStrategies::SearchStrategy SearchMode;
	typedef SolverStrategies::UpdateMode     UpdateMode;
	typedef SolverStrategies::WatchInit      WatchInitMode;
	//! Returns a pointer to the shared context object of this solver.
	const SharedContext*    sharedContext() const { return shared_; }
	//! Returns a pointer to the sat-preprocessor used by this solver.
	SatPreprocessor*        satPrepro()     const;
	//! Returns the solver's solve parameters.
	const SolveParams&      searchConfig()  const;
	SearchMode              searchMode()    const { return static_cast(strategy_.search); }
	UpdateMode              updateMode()    const { return static_cast(strategy_.upMode); }
	WatchInitMode           watchInitMode() const { return static_cast(strategy_.initWatches); }
	uint32                  compressLimit() const { return strategy_.compress ? strategy_.compress : UINT32_MAX; }
	bool                    restartOnModel()const { return strategy_.restartOnModel; }
	DecisionHeuristic*      heuristic()     const { return heuristic_.get();}
	uint32                  id()            const { return strategy_.id; }
	VarInfo                 varInfo(Var v)  const { return shared_->validVar(v) ? shared_->varInfo(v) : VarInfo(); }
	const OutputTable&      outputTable()   const { return shared_->output; }
	Literal                 tagLiteral()    const { return tag_; }
	bool                    isMaster()      const { return this == sharedContext()->master(); }
	/*!
	 * \name Setup functions
	 * Functions in this group are typically used before a search is started.
	 * @{ */
	//! Adds the problem constraint c to the solver.
	/*!
	 * Problem constraints shall only be added to the master solver of
	 * a SharedContext object and only during the setup phase.
	 * \pre this == sharedContext()->master() && !sharedContext()->frozen().
	 */
	void                    add(Constraint* c);
	//! Adds a suitable representation of the given clause to the solver.
	/*!
	 * Depending on the type and size of the given clause, the function
	 * either adds a (learnt) constraint to this solver or an implication
	 * to the shared implication graph.
	 * \note If c is a problem clause, the precondition of add(Constraint* c) applies.
	 */
	bool                    add(const ClauseRep& c, bool isNew = true);
	//! Returns whether c can be stored in the shared short implication graph.
	bool                    allowImplicit(const ClauseRep& c) const {
		return c.isImp()
		  ? shared_->allowImplicit(c.info.type()) && !c.info.aux() && (c.prep == 1 || (!auxVar(c.lits[0].var()) && !auxVar(c.lits[1].var()) && (c.size == 2 || !auxVar(c.lits[2].var()))))
		  : c.size <= 1;
	}
	//! Returns the post propagator with the given priority or 0 if no such post propagator exists.
	PostPropagator*         getPost(uint32 prio) const;
	//! Adds p as post propagator to this solver.
	/*!
	 * \pre p was not added previously and is not part of any other solver.
	 * \note Post propagators are stored and called in priority order.
	 * \see PostPropagator::priority()
	 */
	bool                    addPost(PostPropagator* p);
	//! Removes p from the solver's list of post propagators.
	/*!
	 * \note The function shall not be called during propagation of any other post propagator.
	 */
	void                    removePost(PostPropagator* p);

	//! Adds path to the current root-path and adjusts the root-level accordingly.
	bool pushRoot(const LitVec& path);
	bool pushRoot(Literal p);
	void setEnumerationConstraint(Constraint* c);
	//! Requests a special aux variable for tagging conditional knowledge.
	/*!
	 * Once a tag variable t is set, learnt clauses containing ~t are
	 * tagged as "conditional". Conditional clauses are removed once t becomes
	 * unassigned or Solver::removeConditional() is called. Furthermore, calling
	 * Solver::strengthenConditional() removes ~t from conditional clauses and
	 * transforms them to unconditional knowledge.
	 *
	 * \note Typically, the tag variable is a root assumption and hence true during
	 *       the whole search.
	 */
	Var  pushTagVar(bool pushToRoot);
	//@}

	/*!
	 * \name CDNL functions
	 * Top level functions that are important to the CDNL algorithm.
	 * @{ */

	//! Searches for a model as long as the given limit is not reached.
	/*!
	 * The function searches for a model as long as none of the limits given by limit
	 * is reached. The limits are updated during search.
	 *
	 * \param limit Imposed limit on conflicts and number of learnt constraints.
	 * \param randf Pick next decision variable randomly with a probability of randf.
	 * \return
	 *  - value_true: if a model was found.
	 *  - value_false: if the problem is unsatisfiable (under assumptions, if any).
	 *  - value_free: if search was stopped because limit was reached.
	 *  .
	 *
	 * \note search treats the root level as top-level, i.e. it will never backtrack below that level.
	 */
	ValueRep search(SearchLimits& limit, double randf = 0.0);
	ValueRep search(uint64 maxC, uint32 maxL, bool local = false, double rp  = 0.0);

	//! Moves the root-level i levels down (i.e. away from the top-level).
	/*!
	 * The root-level is similar to the top-level in that it cannot be
	 * undone during search, i.e. the solver will not resolve conflicts that are on or
	 * above the root-level.
	 */
	void pushRootLevel(uint32 i = 1) {
		levels_.root = std::min(decisionLevel(), levels_.root+i);
		levels_.flip = std::max(levels_.flip, levels_.root);
	}

	//! Moves the root-level i levels up (i.e. towards the top-level).
	/*!
	 * The function removes all levels between the new root level and the current decision level,
	 * resets the current backtrack-level, and re-assigns any implied literals.
	 * \param      i      Number of root decisions to pop.
	 * \param[out] popped Optional storage for popped root decisions.
	 * \param      aux    Whether or not aux variables should be added to popped.
	 * \post decisionLevel() == rootLevel()
	 * \note The function first calls clearStopConflict() to remove any stop conflicts.
	 * \note The function *does not* propagate any asserted literals. It is
	 *       the caller's responsibility to call propagate() after the function returned.
	 */
	bool popRootLevel(uint32 i = 1, LitVec* popped = 0, bool aux = true);

	//! Removes a previously set stop conflict and restores the root level.
	void clearStopConflict();

	//! Returns the current root level.
	uint32 rootLevel() const { return levels_.root; }

	//! Removes any implications made between the top-level and the root-level.
	/*!
	 * The function also resets the current backtrack-level and re-assigns learnt facts.
	 * \note
	 *   Equivalent to popRootLevel(rootLevel()) followed by simplify().
	 */
	bool clearAssumptions();

	//! Adds c as a learnt constraint to the solver.
	void addLearnt(Constraint* c, uint32 size, ConstraintType type) {
		learnts_.push_back(c);
		stats.addLearnt(size, type);
	}
	void addLearnt(Constraint* c, uint32 size) { addLearnt(c, size, c->type()); }
	//! Tries to receive at most maxOut clauses.
	/*!
	 * The function queries the distributor object for new clauses to be delivered to
	 * this solver. Clauses are stored in out.
	 * \return The number of clauses received.
	 */
	uint32          receive(SharedLiterals** out, uint32 maxOut) const;
	//! Distributes the clause in lits via the distributor.
	/*!
	 * The function first calls the distribution strategy
	 * to decides whether the clause is a valid candidate for distribution.
	 * If so and a distributor was set, it distributes the clause and returns a handle to the
	 * now shared literals of the clause. Otherwise, it returns 0.
	 *
	 * \param lits  The literals of the clause.
	 * \param size  The number of literals in the clause.
	 * \param extra Additional information about the clause.
	 * \note
	 *   If the return value is not null, it is the caller's
	 *   responsibility to release the returned handle (i.e. by calling release()).
	 * \note If the clause contains aux vars, it is not distributed.
	 */
	SharedLiterals* distribute(const Literal* lits, uint32 size, const ConstraintInfo& extra);


	//! Returns to the maximum of rootLevel() and backtrackLevel() and increases the number of restarts.
	void restart() {
		undoUntil(0);
		++stats.restarts;
		ccInfo_.score().bumpActivity();
	}
	enum UndoMode { undo_default = 0u, undo_pop_bt_level = 1u, undo_pop_proj_level = 2u, undo_save_phases = 4u };
	//! Sets the backtracking level to dl.
	/*!
	 * Depending on mode, the backtracking level either applies
	 * to normal or projective solution enumeration.
	 * \see "Solution Enumeration for Projected Boolean Search Problems".
	 */
	void setBacktrackLevel(uint32 dl, UndoMode mode = undo_pop_bt_level) {
		if (uint32(mode) >= levels_.mode) {
			levels_.flip = std::max(std::min(dl, decisionLevel()), rootLevel());
			levels_.mode = std::max(uint32(mode & 3u), uint32(undo_pop_bt_level));
		}
	}
	//! Returns the current backtracking level.
	uint32 backtrackLevel() const { return levels_.flip; }
	//! Returns the backjump level during an undo operation.
	uint32 jumpLevel()      const { return decisionLevel() - levels_.jump; }

	//! Returns whether the solver can split-off work.
	bool splittable() const;

	//! Tries to split-off disjoint work from the solver's currrent guiding path and returns it in out.
	/*!
	 * \return splittable()
	 */
	bool split(LitVec& out);

	//! Copies the solver's currrent guiding path to gp.
	/*!
	 * \note The solver's guiding path consists of:
	 *   - the decisions from levels [1, rootLevel()]
	 *   - any literals that are implied on a level <= rootLevel() because of newly learnt
	 *     information. This particularly includes literals that were flipped during model enumeration.
	 *
	 * \param[out] out Where to store the guiding path.
	 */
	void copyGuidingPath(LitVec& out);

	//! If called on top-level, removes SAT-clauses + Constraints for which Constraint::simplify returned true.
	/*!
	 * \note If this method is called on a decision-level > 0, it is a noop and will
	 * simply return true.
	 * \return false, if a top-level conflict is detected. Otherwise, true.
	 */
	bool simplify();
	//! Shuffle constraints upon next simplification.
	void shuffleOnNextSimplify(){ shufSimp_ = 1; }


	//! Removes all conditional knowledge, i.e. all previously tagged learnt clauses.
	/*!
	 * \see Solver::pushTagVar()
	 */
	void removeConditional();

	//! Resolves all tagged clauses with the tag literal and thereby strengthens the learnt db.
	/*!
	 * \see Solver::pushTagVar()
	 */
	void strengthenConditional();

	//! Sets the literal p to true and schedules p for propagation.
	/*!
	 * Setting a literal p to true means assigning the appropriate value to
	 * p's variable. That is: value_false if p is a negative literal and value_true
	 * if p is a positive literal.
	 * \param p The literal that should become true.
	 * \param a The reason for the literal to become true or 0 if no reason exists.
	 *
	 * \return
	 *  - false if p is already false
	 *  - otherwise true.
	 *
	 * \pre hasConflict() == false
	 * \pre a.isNull() == false || decisionLevel() <= rootLevel() || searchMode() == no_learning
	 * \post
	 *  p.var() == trueValue(p) || p.var() == falseValue(p) && hasConflict() == true
	 *
	 * \note if setting p to true leads to a conflict, the nogood that caused the
	 * conflict can be requested using the conflict() function.
	 */
	bool force(const Literal& p, const Antecedent& a) {
		assert(!hasConflict() || isTrue(p));
		if (assign_.assign(p, decisionLevel(), a)) return true;
		setConflict(p, a, UINT32_MAX);
		return false;
	}
	/*!
	 * \overload bool Solver::force(const Literal&, const Antecedent&)
	 */
	bool force(const Literal& p, const Antecedent& a, uint32 data) {
		return data != UINT32_MAX
			? assign_.assign(p, decisionLevel(), a.constraint(), data) || (setConflict(p, a, data), false)
			: force(p, a);
	}

	//! Assigns p at dl because of r.
	/*!
	 * \pre dl <= decisionLevel()
	 * \note
	 *   If dl < ul = max(rootLevel(), backtrackLevel()), p is actually assigned
	 *   at ul but the solver stores enough information to reassign
	 *   p on backtracking.
	 */
	bool force(Literal p, uint32 dl, const Antecedent& r, uint32 d = UINT32_MAX) {
		return dl == decisionLevel() ? force(p, r, d) : force(ImpliedLiteral(p, dl, r, d));
	}
	//! Assigns p as a fact at decision level 0.
	bool force(Literal p) { return force(p, 0, Antecedent(lit_true())); }

	//! Assumes the literal p if possible.
	/*!
	 * If p is currently unassigned, sets p to true and starts a new decision level.
	 * \pre validVar(p.var()) == true
	 * \param p The literal to assume.
	 * \return !isFalse(p)
	 */
	bool assume(const Literal& p);

	//! Selects and assumes the next branching literal by calling the installed decision heuristic.
	/*!
	 * \pre queueSize() == 0
	 * \note The next decision literal will be selected randomly with probability f.
	 * \return
	 *  - true if the assignment is not total and a literal was assumed (or forced).
	 *  - false otherwise
	 *  .
	 * \see DecisionHeuristic
	 */
	bool decideNextBranch(double f = 0.0);

	//! Sets a conflict that forces the solver to terminate its search.
	/*!
	 * \pre  !hasConflict()
	 * \post hasConflict()
	 *
	 * \note
	 *   To prevent the solver from resolving the stop conflict, the
	 *   function sets the root level to the current decision level.
	 *   Call clearStopConflict() to remove the conflict and to restore
	 *   the previous root-level.
	 */
	void setStopConflict();

	/*!
	 * Propagates all enqueued literals. If a conflict arises during propagation
	 * propagate returns false and the current conflict (as a set of literals)
	 * is stored in the solver's conflict variable.
	 * \pre !hasConflict()
	 * \see Solver::force
	 * \see Solver::assume
	 * \note Shall not be called recursively.
	 */
	bool propagate();

	/*!
	 * Does unit propagation and calls x->propagateFixpoint(*this)
	 * for all post propagators x up to but not including p.
	 * \note The function is meant to be called only in the context of p.
	 * \pre  p is a post propagator of this solver, i.e. was previously added via addPost().
	 * \pre  Post propagators are active, i.e. the solver is fully initialized.
	 */
	bool propagateUntil(PostPropagator* p);

	//! Executes a one-step lookahead on p.
	/*!
	 * Assumes p and propagates this assumption. If propagations leads to
	 * a conflict, false is returned. Otherwise the assumption is undone and
	 * the function returns true.
	 * \param p The literal to test.
	 * \param c The constraint that wants to test p (can be 0).
	 * \pre p is free
	 * \note If c is not null and testing p does not lead to a conflict,
	 *       c->undoLevel() is called *before* p is undone. Hence, the
	 *       range [s.levelStart(s.decisionLevel()), s.assignment().size())
	 *       contains p followed by all literals that were forced because of p.
	 * \note propagateUntil(c) is used to propagate p.
	 */
	bool test(Literal p, PostPropagator* c);

	//! Estimates the number of assignments following from setting p to true.
	/*!
	 * \note For the estimate only binary clauses are considered.
	 */
	uint32 estimateBCP(const Literal& p, int maxRecursionDepth = 5) const;

	//! Computes the number of in-edges for each assigned literal.
	/*!
	 * \pre  !hasConflict()
	 * \note For a literal p assigned on level level(p), only in-edges from
	 *       levels < level(p) are counted.
	 * \return The maximum number of in-edges.
	 */
	uint32 inDegree(WeightLitVec& out);

	struct DBInfo { uint32 size; uint32 locked; uint32 pinned; };
	//! Removes upto remMax percent of the learnt nogoods.
	/*!
	 * \param remMax  Fraction of nogoods to remove ([0.0,1.0]).
	 * \param rs      Strategy to apply during nogood deletion.
	 * \return        The number of locked and active/glue clauses currently exempt from deletion.
	 * \note
	 *   Nogoods that are the reason for a literal to be in the assignment
	 *   are said to be locked and won't be removed.
	 */
	DBInfo reduceLearnts(float remMax, const ReduceStrategy& rs = ReduceStrategy());

	//! Resolves the active conflict using the selected strategy.
	/*!
	 * If searchMode() is set to learning, resolveConflict implements
	 * First-UIP learning and backjumping. Otherwise, it simply applies
	 * chronological backtracking.
	 * \pre hasConflict()
	 * \return
	 *  - true if the conflict was successfully resolved
	 *  - false otherwise
	 * \note
	 *  If decisionLevel() == rootLevel() false is returned.
	 */
	bool resolveConflict();

	//! Backtracks the last decision and updates the backtrack-level if necessary.
	/*!
	 * \return
	 *  - true if backtracking was possible
	 *  - false if decisionLevel() == rootLevel()
	 */
	bool backtrack();

	//! Undoes all assignments up to (but not including) decision level dl.
	/*!
	 * \post decision level == max(min(decisionLevel(), dl), max(rootLevel(), backtrackLevel()))
	 * \return The decision level after undoing assignments.
	 * \note
	 *   undoUntil() stops at the current backtrack level unless undoMode includes the mode
	 *   that was used when setting the backtrack level.
	 * \note
	 *   If undoMode contains undo_save_phases, the functions saves the values of variables that are undone.
	 *   Otherwise, phases are only saved if indicated by the active strategy.
	 */
	uint32 undoUntil(uint32 dl, uint32 undoMode);
	//! Behaves like undoUntil(dl, undo_default).
	uint32 undoUntil(uint32 dl) { return undoUntilImpl(dl, false); }
	//! Returns whether undoUntil(decisionLevel()-1) is valid and would remove decisionLevel().
	bool   isUndoLevel() const;

	//! Adds a new auxiliary variable to this solver.
	/*!
	 * Auxiliary variables are local to one solver and are not considered
	 * as part of the problem. They shall be added/used only during solving, i.e.
	 * after problem setup is completed.
	 */
	Var  pushAuxVar();
	//! Pops the num most recently added auxiliary variables and destroys all constraints in auxCons.
	void popAuxVar(uint32 num = UINT32_MAX, ConstraintDB* auxCons = 0);
	//@}

	/*!
	 * \name State inspection
	 * Functions for inspecting the state of the solver & search.
	 * \note validVar(v) is a precondition for all functions that take a variable as
	 * parameter.
	 * @{ */
	//! Returns the number of problem variables.
	uint32   numProblemVars()       const { return shared_->numVars(); }
	//! Returns the number of active solver-local aux variables.
	uint32   numAuxVars()           const { return numVars() - numProblemVars(); }
	//! Returns the number of solver variables, i.e. numProblemVars() + numAuxVars()
	uint32   numVars()              const { return assign_.numVars() - 1; }
	//! Returns true if var represents a valid variable in this solver.
	bool     validVar(Var var)      const { return var <= numVars(); }
	//! Returns true if var is a solver-local aux var.
	bool     auxVar(Var var)        const { return shared_->numVars() < var; }
	//! Returns the number of assigned variables.
	uint32   numAssignedVars()      const { return assign_.assigned(); }
	//! Returns the number of free variables.
	/*!
	 * The number of free variables is the number of vars that are neither
	 * assigned nor eliminated.
	 */
	uint32   numFreeVars()          const { return assign_.free()-1; }
	//! Returns the value of v w.r.t the current assignment.
	ValueRep value(Var v)           const { assert(validVar(v)); return assign_.value(v); }
	//! Returns the value of v w.r.t the top level.
	ValueRep topValue(Var v)        const { return level(v) == 0 ? value(v) : value_free; }
	//! Returns the set of preferred values of v.
	ValueSet pref(Var v)            const { assert(validVar(v)); return assign_.pref(v);}
	//! Returns true if p is true w.r.t the current assignment.
	bool     isTrue(Literal p)      const { assert(validVar(p.var())); return assign_.value(p.var()) == trueValue(p); }
	//! Returns true if p is false w.r.t the current assignment.
	bool     isFalse(Literal p)     const { assert(validVar(p.var())); return assign_.value(p.var()) == falseValue(p); }
	//! Returns the literal of v being true in the current assignment.
	/*!
	 * \pre v is assigned a value in the current assignment
	 */
	Literal  trueLit(Var v)         const { assert(value(v) != value_free); return Literal(v, valSign(value(v))); }
	Literal  defaultLit(Var v)      const;
	//! Returns the decision level on which v was assigned.
	/*!
	 * \note The returned value is only meaningful if value(v) != value_free.
	 */
	uint32   level(Var v)           const { assert(validVar(v)); return assign_.level(v); }
	//! Returns true if v is currently marked as seen.
	/*!
	 * Note: variables assigned on level 0 are always marked.
	 */
	bool     seen(Var v)            const { assert(validVar(v)); return assign_.seen(v, 3u); }
	//! Returns true if the literal p is currently marked as seen.
	bool     seen(Literal p)        const { assert(validVar(p.var())); return assign_.seen(p.var(), uint8(1+p.sign())); }
	//! Returns the current decision level.
	uint32   decisionLevel()        const { return (uint32)levels_.size(); }
	bool     validLevel(uint32 dl)  const { return dl != 0 && dl <= decisionLevel(); }
	//! Returns the starting position of decision level dl in the trail.
	/*!
	 * \pre validLevel(dl)
	 */
	uint32   levelStart(uint32 dl)  const { assert(validLevel(dl)); return levels_[dl-1].trailPos; }
	//! Returns the decision literal of the decision level dl.
	/*!
	 * \pre validLevel(dl)
	 */
	Literal  decision(uint32 dl)    const { assert(validLevel(dl)); return assign_.trail[ levels_[dl-1].trailPos ]; }
	//! Returns true, if the current assignment is conflicting.
	bool     hasConflict()          const { return !conflict_.empty(); }
	bool     hasStopConflict()      const { return hasConflict() && conflict_[0] == lit_false(); }
	//! Returns the number of (unprocessed) literals in the propagation queue.
	uint32   queueSize()            const { return (uint32) assign_.qSize(); }
	//! Number of problem constraints in this solver.
	uint32   numConstraints()       const;
	//! Returns the number of constraints that are currently in the solver's learnt database.
	uint32   numLearntConstraints() const { return (uint32)learnts_.size(); }
	//! Returns the reason for p being true.
	/*!
	 * \pre p is true w.r.t the current assignment
	 */
	const Antecedent& reason(Literal p)              const { assert(isTrue(p)); return assign_.reason(p.var()); }
	//! Returns the additional reason data associated with p.
	uint32            reasonData(Literal p)          const { return assign_.data(p.var()); }
	//! Returns the current (partial) assignment as a set of true literals.
	/*!
	 * \note Although the special var 0 always has a value it is not considered to be
	 * part of the assignment.
	 */
	const LitVec&     trail()                        const { return assign_.trail; }
	const Assignment& assignment()                   const { return assign_; }
	//! Returns the current conflict as a set of literals.
	const LitVec&     conflict()                     const { return conflict_; }
	//! Returns the most recently derived conflict clause.
	const LitVec&     conflictClause()               const { return cc_; }
	//! Returns the set of eliminated literals that are unconstraint w.r.t the last model.
	const LitVec&     symmetric()                    const { return temp_; }
	//! Returns the enumeration constraint set by the enumerator used.
	Constraint*       enumerationConstraint()        const { return enum_; }
	DBRef             constraints()                  const { return constraints_; }
	//! Returns the idx'th learnt constraint.
	/*!
	 * \pre idx < numLearntConstraints()
	 */
	Constraint& getLearnt(uint32 idx) const {
		assert(idx < numLearntConstraints());
		return *learnts_[ idx ];
	}

	mutable RNG rng;   //!< Random number generator for this object.
	ValueVec    model; //!< Stores the last model (if any).
	LowerBound  lower; //!< Stores the last lower bound found (if any).
	SolverStats stats; //!< Stores statistics about the solving process.
	//@}

	/*!
	 * \name Watch management
	 * Functions for setting/removing watches.
	 * \pre validVar(v)
	 * @{ */
	//! Returns the number of constraints watching the literal p.
	uint32        numWatches(Literal p)              const;
	//! Returns true if the constraint c watches the literal p.
	bool          hasWatch(Literal p, Constraint* c) const;
	bool          hasWatch(Literal p, ClauseHead* c) const;
	//! Returns c's watch-structure associated with p.
	/*!
	 * \note returns 0, if hasWatch(p, c) == false
	 */
	GenericWatch* getWatch(Literal p, Constraint* c) const;
	//! Adds c to the watch-list of p.
	/*!
	 * When p becomes true, c->propagate(p, data, *this) is called.
	 * \post hasWatch(p, c) == true
	 */
	void addWatch(Literal p, Constraint* c, uint32 data = 0) {
		assert(validWatch(p));
		watches_[p.id()].push_right(GenericWatch(c, data));
	}
	//! Adds w to the clause watch-list of p.
	void addWatch(Literal p, const ClauseWatch& w) {
		assert(validWatch(p));
		watches_[p.id()].push_left(w);
	}
	//! Removes c from p's watch-list.
	/*!
	 * \post hasWatch(p, c) == false
	 */
	void removeWatch(const Literal& p, Constraint* c);
	void removeWatch(const Literal& p, ClauseHead* c);
	//! Adds c to the watch-list of decision-level dl.
	/*!
	 * Constraints in the watch-list of a decision level are
	 * notified when that decision level is about to be backtracked.
	 * \pre validLevel(dl)
	 */
	void addUndoWatch(uint32 dl, Constraint* c) {
		assert(validLevel(dl));
		if (levels_[dl-1].undo != 0) {
			levels_[dl-1].undo->push_back(c);
		}
		else {
			levels_[dl-1].undo = allocUndo(c);
		}
	}
	//! Removes c from the watch-list of the decision level dl.
	bool removeUndoWatch(uint32 dl, Constraint* c);
	//@}

	/*!
	 * \name Misc functions
	 * Low-level implementation functions. Use with care and only if you
	 * know what you are doing!
	 * @{ */
	bool addPost(PostPropagator* p, bool init);
	//! Updates the reason for p being true.
	/*!
	 * \pre p is true and x is a valid reason for p
	 */
	bool setReason(Literal p, const Antecedent& x, uint32 data = UINT32_MAX) {
		assert(isTrue(p) || shared_->eliminated(p.var()));
		assign_.setReason(p.var(), x);
		if (data != UINT32_MAX) { assign_.setData(p.var(), data); }
		return true;
	}
	void setPref(Var v, ValueSet::Value which, ValueRep to) {
		assert(validVar(v) && to <= value_false);
		assign_.requestPrefs();
		assign_.setPref(v, which, to);
	}
	void resetPrefs() { assign_.resetPrefs(); }
	void resetLearntActivities();
	//! Returns the reason for p being true as a set of literals.
	void reason(Literal p, LitVec& out) { assert(isTrue(p)); out.clear(); return assign_.reason(p.var()).reason(*this, p, out); }

	//! Helper function for updating antecedent scores during conflict resolution.
	/*!
	 * \param sc   The current score of the active antecedent.
	 * \param p    The literal implied by the active antecedent.
	 * \param lits The literals of the active antecedent.
	 * \return true if a score was updated.
	 *
	 * \note Depending on the active solver strategies, the function
	 *       increases the activity and/or updates the lbd of the given antecedent.
	 *
	 * \note If SolverStrategies::bumpVarAct is active, p's activity
	 *       is increased if the new lbd is smaller than the lbd of the
	 *       conflict clause that is currently being derived.
	 */
	bool updateOnReason(ConstraintScore& sc, Literal p, const LitVec& lits) {
		// update only during conflict resolution
		if (&lits != &conflict_) { return false; }
		sc.bumpActivity();
		uint32 up = strategy_.updateLbd;
		if ((up || !sc.hasLbd()) && !lits.empty()) {
			uint32 lbd  = sc.lbd();
			uint32 inc  = uint32(up != 1u);
			uint32 nLbd = countLevels(&lits[0], &lits[0] + lits.size(), lbd - inc);
			if ((nLbd + inc) < lbd) {
				sc.bumpLbd(nLbd + uint32(up == 2u));
			}
		}
		if (strategy_.bumpVarAct && isTrue(p)) { bumpAct_.push_back(WeightLiteral(p, sc.lbd())); }
		return true;
	}

	//! Helper function for increasing antecedent activities during conflict clause minimization.
	bool updateOnMinimize(ConstraintScore& sc) {
		return !strategy_.ccMinKeepAct && (sc.bumpActivity(), true);
	}

	//! Helper function for antecedents to be called during conflict clause minimization.
	bool ccMinimize(Literal p, CCMinRecursive* rec) const {
		return seen(p.var()) || (rec && hasLevel(level(p.var())) && ccMinRecurse(*rec, p));
	}

	//! Allocates a small block (32-bytes) from the solver's small block pool.
	void* allocSmall()       { return smallAlloc_.allocate(); }
	//! Frees a small block previously allocated from the solver's small block pool.
	void  freeSmall(void* m) { smallAlloc_.free(m);    }

	void  addLearntBytes(uint32 bytes)  { memUse_ += bytes; }
	void  freeLearntBytes(uint64 bytes) { memUse_ -= (bytes < memUse_) ? bytes : memUse_; }

	bool  restartReached(const SearchLimits& limit) const;
	bool  reduceReached(const SearchLimits& limit)  const;

	//! simplifies cc and returns finalizeConflictClause(cc, info);
	uint32 simplifyConflictClause(LitVec& cc, ConstraintInfo& info, ClauseHead* rhs);
	uint32 finalizeConflictClause(LitVec& cc, ConstraintInfo& info, uint32 ccRepMode = 0);
	uint32 countLevels(const Literal* first, const Literal* last, uint32 maxLevels = Clasp::LBD_MAX);
	bool hasLevel(uint32 dl)    const { assert(validLevel(dl)); return levels_[dl-1].marked != 0; }
	bool frozenLevel(uint32 dl) const { assert(validLevel(dl)); return levels_[dl-1].freeze != 0; }
	bool inputVar(Literal p)    const { return varInfo(p.var()).input(); }
	void markLevel(uint32 dl)    { assert(validLevel(dl)); levels_[dl-1].marked = 1; }
	void freezeLevel(uint32 dl)  { assert(validLevel(dl)); levels_[dl-1].freeze = 1; }
	void unmarkLevel(uint32 dl)  { assert(validLevel(dl)); levels_[dl-1].marked = 0; }
	void unfreezeLevel(uint32 dl){ assert(validLevel(dl)); levels_[dl-1].freeze = 0; }
	void markSeen(Var v)         { assert(validVar(v)); assign_.setSeen(v, 3u); }
	void markSeen(Literal p)     { assert(validVar(p.var())); assign_.setSeen(p.var(), uint8(1+p.sign())); }
	void clearSeen(Var v)        { assert(validVar(v)); assign_.clearSeen(v);  }
	void setHeuristic(DecisionHeuristic* h, Ownership_t::Type own);
	void destroyDB(ConstraintDB& db);
	SolverStrategies&  strategies() { return strategy_; }
	bool resolveToFlagged(const LitVec& conflictClause, uint8 vflag, LitVec& out, uint32& lbd) const;
	void resolveToCore(LitVec& out);
	//@}
private:
	struct DLevel {
		explicit DLevel(uint32 pos = 0, ConstraintDB* u = 0)
			: trailPos(pos)
			, marked(0)
			, freeze(0)
			, undo(u) {}
		uint32        trailPos : 30;
		uint32        marked   :  1;
		uint32        freeze   :  1;
		ConstraintDB* undo;
	};
	struct DecisionLevels : public PodVector::type {
		DecisionLevels() : root(0), flip(0), mode(0), jump(0) {}
		uint32 root;      // root level
		uint32 flip : 30; // backtrack level
		uint32 mode :  2; // type of backtrack level
		uint32 jump;      // length of active undo
	};
	typedef PodVector::type ReasonVec;
	typedef PodVector::type  Watches;
	struct  Dirty;
	struct CmpScore {
		typedef std::pair ViewPair;
		CmpScore(const ConstraintDB& learnts, ReduceStrategy::Score sc, uint32 g, uint32 f = 0) : db(learnts), rs(sc), glue(g), freeze(f) {}
		uint32 score(const ConstraintScore& act)                      const { return ReduceStrategy::asScore(rs, act); }
		bool operator()(uint32 lhsId, uint32 rhsId)                   const { return (*this)(db[lhsId], db[rhsId]); }
		bool operator()(const ViewPair& lhs, const ViewPair& rhs)     const { return this->operator()(lhs.second, rhs.second); }
		bool operator()(ConstraintScore lhs, ConstraintScore rhs)     const { return ReduceStrategy::compare(rs, lhs, rhs) < 0;}
		bool operator()(const Constraint* lhs, const Constraint* rhs) const { return this->operator()(lhs->activity(), rhs->activity()); }
		bool isFrozen(const ConstraintScore& a) const { return a.bumped() && a.lbd() <= freeze; }
		bool isGlue(const ConstraintScore& a)   const { return a.lbd() <= glue; }
		const ConstraintDB&   db;
		ReduceStrategy::Score rs;
		uint32                glue;
		uint32                freeze;
	private: CmpScore& operator=(const CmpScore&);
	};
	bool    validWatch(Literal p) const { return p.id() < (uint32)watches_.size(); }
	void    freeMem();
	void    resetHeuristic();
	bool    simplifySAT();
	bool    unitPropagate();
	bool    postPropagate(PostPropagator* stop);
	void    cancelPropagation();
	uint32  undoUntilImpl(uint32 dl, bool sp);
	void    undoLevel(bool sp);
	uint32  analyzeConflict();
	bool    isModel();
	bool    resolveToFlagged(const LitVec& conflictClause, uint8 vf, LitVec& out, uint32& lbd);
	void    otfs(Antecedent& lhs, const Antecedent& rhs, Literal p, bool final);
	ClauseHead* otfsRemove(ClauseHead* c, const LitVec* newC);
	uint32  ccMinimize(LitVec& cc, LitVec& removed, uint32 antes, CCMinRecursive* ccMin);
	void    ccMinRecurseInit(CCMinRecursive& ccMin);
	bool    ccMinRecurse(CCMinRecursive& ccMin, Literal p) const;
	bool    ccRemovable(Literal p, uint32 antes, CCMinRecursive* ccMin);
	Antecedent ccHasReverseArc(Literal p, uint32 maxLevel, uint32 maxNew);
	void    ccResolve(LitVec& cc, uint32 pos, const LitVec& reason);
	void    undoFree(ConstraintDB* x);
	void    setConflict(Literal p, const Antecedent& a, uint32 data);
	bool    force(const ImpliedLiteral& p);
	void    updateBranch(uint32 n);
	uint32  incEpoch(uint32 size, uint32 inc = 1);
	DBInfo  reduceLinear(uint32 maxR, const CmpScore& cmp);
	DBInfo  reduceSort(uint32 maxR, const CmpScore& cmp);
	DBInfo  reduceSortInPlace(uint32 maxR, const CmpScore& cmp, bool onlyPartialSort);
	Literal popVars(uint32 num, bool popLearnt, ConstraintDB* popAux);
	ConstraintDB* allocUndo(Constraint* c);
	SharedContext*    shared_;      // initialized by master thread - otherwise read-only!
	SolverStrategies  strategy_;    // strategies used by this object
	HeuristicPtr      heuristic_;   // active decision heuristic
	CCMinRecursive*   ccMin_;       // additional data for supporting recursive strengthen
	PostPropagator**  postHead_;    // head of post propagator list to propagate
	ConstraintDB*     undoHead_;    // free list of undo DBs
	Constraint*       enum_;        // enumeration constraint - set by enumerator
	uint64            memUse_;      // memory used by learnt constraints (estimate)
	Dirty*            lazyRem_;     // set of watch lists that contain invalid constraints
	SmallClauseAlloc  smallAlloc_;  // allocator object for small clauses
	Assignment        assign_;      // three-valued assignment.
	DecisionLevels    levels_;      // information (e.g. position in trail) on each decision level
	ConstraintDB      constraints_; // problem constraints
	ConstraintDB      learnts_;     // learnt constraints
	PropagatorList    post_;        // (possibly empty) list of post propagators
	Watches           watches_;     // for each literal p: list of constraints watching p
	LitVec            conflict_;    // conflict-literals for later analysis
	LitVec            cc_;          // temporary: conflict clause within analyzeConflict
	LitVec            temp_;        // temporary: redundant literals in simplifyConflictClause
	WeightLitVec      bumpAct_;     // temporary: lits from current dl whose activity might get an extra bump
	VarVec            epoch_;       // temporary vector for computing LBD
	VarVec            cflStamp_;    // temporary vector for computing number of conflicts in branch
	ImpliedList       impliedLits_; // lits that were asserted on current dl but are logically implied earlier
	ConstraintInfo    ccInfo_;      // temporary: information about conflict clause cc_
	Literal           tag_;         // aux literal for tagging learnt constraints
	uint32            dbIdx_;       // position of first new problem constraint in master db
	uint32            lastSimp_ :30;// number of top-level assignments on last call to simplify
	uint32            shufSimp_ : 1;// shuffle db on next simplify?
	uint32            initPost_ : 1;// initialize new post propagators?
};
inline bool isRevLit(const Solver& s, Literal p, uint32 maxL) {
	return s.isFalse(p) && (s.seen(p) || s.level(p.var()) < maxL);
}
//! Simplifies the constraints in db and removes those that are satisfied.
template 
void simplifyDB(Solver& s, C& db, bool shuffle) {
	typename C::size_type j = 0;
	for (typename C::size_type i = j, end = db.size(); i != end; ++i) {
		Constraint* c = db[i];
		if (c->simplify(s, shuffle)){ c->destroy(&s, false); }
		else                        { db[j++] = c;  }
	}
	shrinkVecTo(db, j);
}
//! Destroys (and optionally detaches) all constraints in db.
void destroyDB(Solver::ConstraintDB& db, Solver* s, bool detach);
//! Returns the default decision literal of the given variable.
inline Literal Solver::defaultLit(Var v) const {
	switch(strategy_.signDef) {
		default: //
		case SolverStrategies::sign_atom: return Literal(v, !varInfo(v).has(VarInfo::Body));
		case SolverStrategies::sign_pos : return posLit(v);
		case SolverStrategies::sign_neg : return negLit(v);
		case SolverStrategies::sign_rnd : return Literal(v, rng.drand() < 0.5);
	}
}
//! Event type optionally emitted after a conflict.
struct NewConflictEvent : SolveEvent {
	NewConflictEvent(const Solver& s, const LitVec& c, const ConstraintInfo& i) : SolveEvent(s, verbosity_quiet), learnt(&c), info(i) {}
	const LitVec*  learnt; //!< Learnt conflict clause.
	ConstraintInfo info;   //!< Additional information associated with the conflict clause.
};
//@}

/**
 * \defgroup heuristic Decision Heuristics
 * \brief Decision heuristics and related classes.
 * \ingroup solver
 */
//@{
//! Base class for decision heuristics to be used in a Solver.
/*!
 * During search the decision heuristic is used whenever the DPLL-procedure must pick
 * a new variable to branch on. Each concrete decision heuristic can implement a
 * different algorithm for selecting the next decision variable.
 */
class DecisionHeuristic {
public:
	DecisionHeuristic() {}
	virtual ~DecisionHeuristic();
	/*!
	 * Called once after all problem variables are known to the solver.
	 * The default-implementation is a noop.
	 * \param s The solver in which this heuristic is used.
	 */
	virtual void startInit(const Solver& s) { (void)s; }

	/*!
	 * Called once after all problem constraints are known to the solver
	 * and the problem was simplified.
	 * The default-implementation is a noop.
	 * \param s The solver in which this heuristic is used.
	 */
	virtual void endInit(Solver& s) { (void)s; }

	//! Called once if s switches to a different heuristic.
	virtual void detach(Solver& s) { (void)s; }

	//! Called if configuration has changed.
	virtual void setConfig(const HeuParams& p) { (void)p; }

	/*!
	 * Called if the state of one or more variables changed.
	 * A state change is one of:
	 *   - A previously eliminated variable is resurrected.
	 *   - A new aux variable was added.
	 *   - An aux variable was removed.
	 *   .
	 * \param s Solver in which the state change occurred.
	 * \param v The first variable affected by the change.
	 * \param n The range of variables affected, i.e. [v, v+n).
	 * \note Use s.validVar(v) and s.auxVar(v) to determine the reason for the update.
	 */
	virtual void updateVar(const Solver& s, Var v, uint32 n) = 0;

	/*!
	 * Called on decision level 0. Variables that are assigned on this level
	 * may be removed from any decision heuristic.
	 * \note Whenever the solver returns to dl 0, simplify is only called again
	 * if the solver learnt new facts since the last call to simplify.
	 *
	 * \param s The solver that reached decision level 0.
	 * \param st The position in the trail of the first new learnt fact.
	 */
	virtual void simplify(const Solver& s, LitVec::size_type st) { (void)s; (void)st; }

	/*!
	 * Called whenever the solver backracks.
	 * Literals in the range [s.trail()[st], s.trail().size()) are subject to backtracking.
	 * The default-implementation is a noop.
	 * \param s The solver that is about to backtrack.
	 * \param st Position in the trail of the first literal that will be backtracked.
	 */
	virtual void undoUntil(const Solver& s, LitVec::size_type st) { (void)s; (void)st; }

	/*!
	 * Called whenever a new constraint is added to the solver s.
	 * The default-implementation is a noop.
	 * \param s The solver to which the constraint is added.
	 * \param first First literal of the new constraint.
	 * \param size Size of the new constraint.
	 * \param t Type of the new constraint.
	 * \note first points to an array of size size.
	 */
	virtual void newConstraint(const Solver& s, const Literal* first, LitVec::size_type size, ConstraintType t) { (void)s; (void)first; (void)size; (void)t; }

	/*!
	 * Called for each new reason-set that is traversed during conflict analysis.
	 * The default-implementation is a noop.
	 * \param s The solver in which the conflict is analyzed.
	 * \param lits The current reason-set under inspection.
	 * \param resolveLit The literal that is currently resolved.
	 * \note When a conflict is detected, the solver passes the conflicting literals
	 * in lits during the first call to updateReason. On that first call resolveLit
	 * is the sentinel-literal.
	 */
	virtual void updateReason(const Solver& s, const LitVec& lits, Literal resolveLit) { (void)s; (void)lits; (void)resolveLit; }

	//! Shall bump the activity of literals in lits by lits.second * adj.
	/*!
	 * The default-implementation is a noop and always returns false.
	 * \return true if heuristic supports activities, false otherwise.
	 */
	virtual bool bump(const Solver& s, const WeightLitVec& lits, double adj) { (void)s; (void)lits; (void)adj; return false; }

	/*!
	 * Called whenever the solver must pick a new variable to branch on.
	 * \param s The solver that needs a new decision variable.
	 * \return
	 *  - true  : if the decision heuristic assumed a literal
	 *  - false : if no decision could be made because assignment is total or there is a conflict
	 *  .
	 * \post
	 * If true is returned, the heuristic has asserted a literal.
	 */
	bool select(Solver& s) { return s.numFreeVars() != 0 && s.assume(doSelect(s)); }

	//! Implements the actual selection process.
	/*!
	 * \pre s.numFreeVars() > 0, i.e. there is at least one variable to branch on.
	 * \return
	 *  - a literal that is currently free or
	 *  - a sentinel literal. In that case, the heuristic shall have asserted a literal!
	 */
	virtual Literal doSelect(Solver& s) = 0;

	/*!
	 * Shall select one of the literals in the range [first, last).
	 * \param s     The solver that needs a new decision variable.
	 * \param first Pointer to first literal in range.
	 * \param last  Pointer to the end of the range.
	 * \pre [first, last) is not empty and all literals in the range are currently unassigned.
	 * \note The default implementation returns *first.
	 */
	virtual Literal selectRange(Solver& s, const Literal* first, const Literal* last) {
		(void)s; (void)last;
		return *first;
	}
	static Literal selectLiteral(Solver& s, Var v, int signScore) {
		ValueSet prefs = s.pref(v);
		if (signScore != 0 && !prefs.has(ValueSet::user_value | ValueSet::saved_value | ValueSet::pref_value)) {
			return Literal(v, signScore < 0);
		}
		else if (!prefs.empty()) {
			return Literal(v, prefs.sign());
		}
		return s.defaultLit(v);
	}
private:
	DecisionHeuristic(const DecisionHeuristic&);
	DecisionHeuristic& operator=(const DecisionHeuristic&);
};
//! Selects the first free literal w.r.t to the initial variable order.
class SelectFirst : public DecisionHeuristic {
public:
	void updateVar(const Solver&, Var, uint32) {}
protected:
	Literal doSelect(Solver& s);
};
//@}
}
#endif

clasp-3.2.2/libclasp/clasp/solver_strategies.h000066400000000000000000000621171304134206100214310ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_SOLVER_STRATEGIES_H_INCLUDED
#define CLASP_SOLVER_STRATEGIES_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 

#if !defined(CLASP_ALIGN_BITFIELD)
#	if defined(EMSCRIPTEN)
// Force alignment of bitfield to T in order to prevent
// code-generation bug in emcc
// see: https://github.com/kripken/emscripten/issues/4540
#	define CLASP_ALIGN_BITFIELD(T) T : 0;
#	else
#	define CLASP_ALIGN_BITFIELD(T)
#	endif
#endif

/*!
 * \file
 * \brief Contains strategies and options used to configure solvers and search.
 */
namespace Clasp {
//! Implements clasp's configurable schedule-strategies.
/*!
 * clasp currently supports the following basic strategies:
 *  - geometric sequence  : X = n1 * n2^k   (k >= 0)
 *  - arithmetic sequence : X = n1 + (n2*k) (k >= 0)
 *  - fixed sequence      : X = n1 + (0*k)  (k >= 0)
 *  - luby's sequence     : X = n1 * luby(k)(k >= 0)
 *  .
 * Furthermore, an inner-outer scheme can be applied to the selected sequence.
 * In that case, the sequence is repeated every \+j restarts, where
 * \ is the initial outer-limit and j is the number of times the
 * sequence was already repeated.
 *
 * \note For luby's seqeuence, j is not a repetition counter
 * but the index where the sequence grows to the next power of two.
 *
 * \see Luby et al. "Optimal speedup of las vegas algorithms."
 *
 */
struct ScheduleStrategy {
public:
	//! Supported strategies.
	enum Type { Geometric = 0, Arithmetic = 1, Luby = 2, User = 3 };

	ScheduleStrategy(Type t = Geometric, uint32 b = 100, double g = 1.5, uint32 o = 0);
	//! Creates luby's sequence with unit-length unit and optional outer limit.
	static ScheduleStrategy luby(uint32 unit, uint32 limit = 0)              { return ScheduleStrategy(Luby, unit, 0, limit);  }
	//! Creates geometric sequence base * (grow^k) with optional outer limit.
	static ScheduleStrategy geom(uint32 base, double grow, uint32 limit = 0) { return ScheduleStrategy(Geometric, base, grow, limit);  }
	//! Creates arithmetic sequence base + (add*k) with optional outer limit.
	static ScheduleStrategy arith(uint32 base, double add, uint32 limit = 0) { return ScheduleStrategy(Arithmetic, base, add, limit);  }
	//! Creates fixed sequence with length base.
	static ScheduleStrategy fixed(uint32 base)                               { return ScheduleStrategy(Arithmetic, base, 0, 0);  }
	static ScheduleStrategy none()                                           { return ScheduleStrategy(Geometric, 0); }
	static ScheduleStrategy def()                                            { return ScheduleStrategy(User, 0, 0.0); }
	uint64 current()  const;
	bool   disabled() const { return base == 0; }
	bool   defaulted()const { return base == 0 && type == User; }
	void   reset()          { idx  = 0;         }
	uint64 next();
	void   advanceTo(uint32 idx);
	uint32 base : 30; // base of sequence (n1)
	uint32 type :  2; // type of basic sequence
	uint32 idx;       // current index into sequence
	uint32 len;       // length of sequence (0 if infinite) (once reached, sequence is repeated and len increased)
	float  grow;      // update parameter n2
};
//! Returns the idx'th value of the luby sequence.
uint32 lubyR(uint32 idx);
//! Returns the idx'th value of the geometric sequence with the given growth factor.
double growR(uint32 idx, double g);
//! Returns the idx'th value of the arithmetic sequence with the given addend.
double addR(uint32 idx, double a);

class DecisionHeuristic;
//! Parameter-Object for grouping solver strategies.
struct SolverStrategies {
	//! Clasp's two general search strategies.
	enum SearchStrategy {
		use_learning = 0, //!< Analyze conflicts and learn First-1-UIP-clause.
		no_learning  = 1  //!< Don't analyze conflicts - chronological backtracking.
	};
	//! Default sign heuristic.
	enum SignHeu {
		sign_atom = 0, //!< Prefer negative literal for atoms.
		sign_pos  = 1, //!< Prefer positive literal.
		sign_neg  = 2, //!< Prefer negative literal.
		sign_rnd  = 3, //!< Prefer random literal.
	};
	//! Conflict clause minimization strategy.
	enum CCMinType {
		cc_local     = 0, //!< Basic algorithm.
		cc_recursive = 1, //!< Extended algorithm.
	};
	//! Antecedents to consider during conflict clause minimization.
	enum CCMinAntes {
		no_antes     = 0,  //!< Don't minimize conflict clauses.
		all_antes    = 1,  //!< Consider all antecedents.
		short_antes  = 2,  //!< Consider only short antecedents.
		binary_antes = 3,  //!< Consider only binary antecedents.
	};
	//! Simplifications for long conflict clauses.
	enum CCRepMode {
		cc_no_replace  = 0,//!< Don't replace literals in conflict clauses.
		cc_rep_decision= 1,//!< Replace conflict clause with decision sequence.
		cc_rep_uip     = 2,//!< Replace conflict clause with all uip clause.
		cc_rep_dynamic = 3,//!< Dynamically select between cc_rep_decision and cc_rep_uip.
	};
	//! Strategy for initializing watched literals in clauses.
	enum WatchInit  { watch_first = 0, watch_rand = 1, watch_least = 2 };
	//! Strategy for integrating new information in parallel solving.
	enum UpdateMode { update_on_propagate = 0, update_on_conflict  = 1 };

	SolverStrategies();
	void prepare();
	//----- 32 bit ------------
	uint32    compress      : 16; /*!< If > 0, enable compression for learnt clauses of size > compress. */
	uint32    saveProgress  : 16; /*!< Enable progress saving if > 0. */
	//----- 32 bit ------------
	uint32    heuId         : 3;  /*!< Type of decision heuristic.   */
	uint32    reverseArcs   : 2;  /*!< Use "reverse-arcs" during learning if > 0. */
	uint32    otfs          : 2;  /*!< Enable "on-the-fly" subsumption if > 0. */
	uint32    updateLbd     : 2;  /*!< Update lbds of antecedents during conflict analysis. */
	uint32    ccMinAntes    : 2;  /*!< Antecedents to look at during conflict clause minimization. */
	uint32    ccRepMode     : 2;  /*!< One of CCRepMode. */
	uint32    ccMinRec      : 1;  /*!< If 1, use more expensive recursive nogood minimization.  */
	uint32    ccMinKeepAct  : 1;  /*!< Do not increase nogood activities during nogood minimization? */
	uint32    initWatches   : 2;  /*!< Initialize watches randomly in clauses. */
	uint32    upMode        : 1;  /*!< One of UpdateMode. */
	uint32    bumpVarAct    : 1;  /*!< Bump activities of vars implied by learnt clauses with small lbd. */
	uint32    search        : 1;  /*!< Current search strategy. */
	uint32    restartOnModel: 1;  /*!< Do a restart after each model. */
	uint32    signDef       : 2;  /*!< Default sign heuristic.        */
	uint32    signFix       : 1;  /*!< Disable all sign heuristics and always use default sign. */
	uint32    reserved      : 1;
	uint32    hasConfig     : 1;  /*!< Config applied to solver? */
	uint32    id            : 6;  /*!< Solver id - SHALL ONLY BE SET BY Shared Context! */
};
//! Parameter-Object for grouping additional heuristic options.
struct HeuParams {
	//! Strategy for scoring clauses not learnt by conflict analysis.
	enum ScoreOther { other_no   = 0u, other_loop = 1u, other_all = 2u, other_auto = 3u };
	//! Strategy for scoring during conflict analysis.
	enum Score      { score_auto = 0u, score_min  = 1u, score_set = 2u, score_multi_set = 3u };
	//! Global preference for domain heuristic.
	enum DomPref    { pref_atom  = 0u, pref_scc   = 1u, pref_hcc  = 2u, pref_disj = 4u, pref_min  = 8u, pref_show = 16u };
	//! Global modification for domain heuristic.
	enum DomMod     { mod_none   = 0u, mod_level  = 1u, mod_spos  = 2u, mod_true  = 3u, mod_sneg  = 4u, mod_false = 5u, mod_init = 6u, mod_factor = 7u };
	//! Values for dynamic decaying scheme.
	struct VsidsDecay {
		uint32 init: 10; /*!< Starting decay factor: 1/0.\. */
		uint32 bump:  7; /*!< Decay decrease value : \/100. */
		uint32 freq: 15; /*!< Update decay factor every \ conflicts. */
	};
	HeuParams();
	uint32 param    : 16; /*!< Extra parameter for heuristic with meaning depending on type. */
	uint32 score    : 2;  /*!< Type of scoring during resolution. */
	uint32 other    : 2;  /*!< Consider other learnt nogoods in heuristic. */
	uint32 moms     : 1;  /*!< Use MOMS-score as top-level heuristic. */
	uint32 nant     : 1;  /*!< Prefer elements in NegAnte(P).      */
	uint32 huang    : 1;  /*!< Only for Berkmin.   */
	uint32 acids    : 1;  /*!< Only for Vsids/Dom. */
	uint32 domPref  : 5;  /*!< Default pref for doamin heuristic (set of DomPref). */
	uint32 domMod   : 3;  /*!< Default mod for domain heuristic (one of DomMod). */
	union {
		uint32     extra;
		VsidsDecay decay; /*!< Only for Vsids/Dom. */
	};
};

//! Parameter-Object for configuring a solver.
struct SolverParams : SolverStrategies  {
	SolverParams();
	uint32 prepare();
	inline bool forgetHeuristic() const { return (forgetSet & 1u) != 0; }
	inline bool forgetSigns()     const { return (forgetSet & 2u) != 0; }
	inline bool forgetActivities()const { return (forgetSet & 4u) != 0; }
	inline bool forgetLearnts()   const { return (forgetSet & 8u) != 0; }
	SolverParams& setId(uint32 id)      { this->id = id; return *this; }
	HeuParams heuristic;  /*!< Parameters for decision heuristic.     */
	// 64-bit
	uint32 seed;           /*!< Seed for the random number generator.  */
	uint32 lookOps   : 16; /*!< Max. number of lookahead operations (0: no limit).           */
	uint32 optStrat  : 1;  /*!< Optimization strategy (see MinimizeMode_t::Strategy).*/
	uint32 optParam  : 4;  /*!< Parameter for optimization strategy (see MinimizeMode_t::BBOption / MinimizeMode_t::UscOption). */
	uint32 optHeu    : 2;  /*!< Set of optimize heuristics. */
	uint32 lookType  : 2;  /*!< Type of lookahead operations. */
	uint32 loopRep   : 2;  /*!< How to represent loops? */
	uint32 acycFwd   : 1;  /*!< Disable backward propagation in acyclicity checker. */
	uint32 forgetSet : 4;  /*!< What to forget on (incremental step). */
};

typedef Range Range32;

//! Aggregates restart-parameters to configure restarts during search.
/*!
 * \see ScheduleStrategy
 */
struct RestartParams {
	RestartParams();
	enum SeqUpdate { seq_continue = 0, seq_repeat = 1, seq_disable = 2 };
	uint32    prepare(bool withLookback);
	void      disable();
	bool      dynamic() const { return dynRestart != 0; }
	bool      local()   const { return cntLocal   != 0; }
	SeqUpdate update()  const { return static_cast(upRestart); }
	ScheduleStrategy sched;  /**< Restart schedule to use. */
	float  blockScale;       /**< Scaling factor for blocking restarts. */
	uint32 blockWindow: 16;  /**< Size of moving assignment average for blocking restarts (0: disable). */
	uint32 blockFirst : 16;  /**< Enable blocking restarts after blockFirst conflicts. */
	CLASP_ALIGN_BITFIELD(uint32)
	uint32 counterRestart:16;/**< Apply counter implication bump every counterRestart restarts (0: disable). */
	uint32 counterBump:16;   /**< Bump factor for counter implication restarts. */
	CLASP_ALIGN_BITFIELD(uint32)
	uint32 shuffle    :14;   /**< Shuffle program after shuffle restarts (0: disable). */
	uint32 shuffleNext:14;   /**< Re-Shuffle program every shuffleNext restarts (0: disable). */
	uint32 upRestart  : 2;   /**< How to update restart sequence after a model was found (one of SeqUpdate). */
	uint32 cntLocal   : 1;   /**< Count conflicts globally or relative to current branch? */
	uint32 dynRestart : 1;   /**< Dynamic restarts enabled? */
};

//! Reduce strategy used during solving.
/*!
 * A reduce strategy mainly consists of an algorithm and a scoring scheme
 * for measuring "activity" of learnt constraints.
 */
struct ReduceStrategy {
	//! Reduction algorithm to use during solving.
	enum Algorithm {
		reduce_linear = 0, //!< Linear algorithm from clasp-1.3.x.
		reduce_stable = 1, //!< Sort constraints by score but keep order in learnt db.
		reduce_sort   = 2, //!< Sort learnt db by score and remove fraction with lowest score.
		reduce_heap   = 3  //!< Similar to reduce_sort but only partially sorts learnt db.
	};
	//! Score to measure "activity" of learnt constraints.
	enum Score {
		score_act  = 0, //!< Activity only: how often constraint is used during conflict analysis.
		score_lbd  = 1, //!< Use literal block distance as activity.
		score_both = 2  //!< Use activity and lbd together.
	};
	//! Strategy for estimating size of problem.
	enum EstimateSize {
		est_dynamic         = 0, //!< Dynamically decide whether to use number of variables or constraints.
		est_con_complexity  = 1, //!< Measure size in terms of constraint complexities.
		est_num_constraints = 2, //!< Measure size in terms of number constraints.
		est_num_vars        = 3  //!< Measure size in terms of number variable.
	};
	static uint32 scoreAct(const ConstraintScore& sc)  { return sc.activity(); }
	static uint32 scoreLbd(const ConstraintScore& sc)  { return uint32(LBD_MAX+1)-sc.lbd(); }
	static uint32 scoreBoth(const ConstraintScore& sc) { return (sc.activity()+1) * scoreLbd(sc); }
	static int    compare(Score sc, const ConstraintScore& lhs, const ConstraintScore& rhs) {
		int fs = 0;
		if      (sc == score_act) { fs = ((int)scoreAct(lhs)) - ((int)scoreAct(rhs)); }
		else if (sc == score_lbd) { fs = ((int)scoreLbd(lhs)) - ((int)scoreLbd(rhs)); }
		return fs != 0 ? fs : ((int)scoreBoth(lhs)) - ((int)scoreBoth(rhs));
	}
	static uint32 asScore(Score sc, const Clasp::ConstraintScore& act) {
		if (sc == score_act)  { return scoreAct(act); }
		if (sc == score_lbd)  { return scoreLbd(act); }
		/*  sc == score_both*/{ return scoreBoth(act);}
	}
	ReduceStrategy() : protect(0), glue(0), fReduce(75), fRestart(0), score(0), algo(0), estimate(0), noGlue(0) {
		static_assert(sizeof(ReduceStrategy) == sizeof(uint32), "invalid bitset");
	}
	uint32 protect : 7; /*!< Protect nogoods whose lbd was reduced and is now <= freeze. */
	uint32 glue    : 4; /*!< Don't remove nogoods with lbd <= glue.    */
	uint32 fReduce : 7; /*!< Fraction of nogoods to remove in percent. */
	uint32 fRestart: 7; /*!< Fraction of nogoods to remove on restart. */
	uint32 score   : 2; /*!< One of Score.                             */
	uint32 algo    : 2; /*!< One of Algorithm.                         */
	uint32 estimate: 2; /*!< How to estimate problem size in init.     */
	uint32 noGlue  : 1; /*!< Do not count glue clauses in limit.       */
};

//! Aggregates parameters for the nogood deletion heuristic used during search.
/*!
 * - S:delCond {yes,no}
 * - no:del {0}[0]
 * - no:del | delCond in {no}
 * - deletion | delCond in {yes}
 * - del-* | delCond in {yes}
 * - {delCond=yes, del-grow=no, del-cfl=no}
 * .
 */
struct ReduceParams {
	ReduceParams() : cflSched(ScheduleStrategy::none()), growSched(ScheduleStrategy::def())
		, fInit(1.0f/3.0f)
		, fMax(3.0f)
		, fGrow(1.1f)
		, initRange(10, UINT32_MAX)
		, maxRange(UINT32_MAX)
		, memMax(0) {}
	void    disable();
	uint32  prepare(bool withLookback);
	Range32 sizeInit(const SharedContext& ctx) const;
	uint32  cflInit(const SharedContext& ctx)  const;
	uint32  getBase(const SharedContext& ctx)  const;
	float   fReduce()  const { return strategy.fReduce / 100.0f; }
	float   fRestart() const { return strategy.fRestart/ 100.0f; }
	static uint32 getLimit(uint32 base, double f, const Range& r);
	ScheduleStrategy cflSched;   /**< Conflict-based deletion schedule.               */
	ScheduleStrategy growSched;  /**< Growth-based deletion schedule.                 */
	ReduceStrategy   strategy;   /**< Strategy to apply during nogood deletion.       */
	float            fInit;      /**< Initial limit. X = P*fInit clamped to initRange.*/
	float            fMax;       /**< Maximal limit. X = P*fMax  clamped to maxRange. */
	float            fGrow;      /**< Growth factor for db.                           */
	Range32          initRange;  /**< Allowed range for initial limit.                */
	uint32           maxRange;   /**< Allowed range for maximal limit: [initRange.lo,maxRange]*/
	uint32           memMax;     /**< Memory limit in MB (0 = no limit).              */
};

//! Parameter-Object for grouping solve-related options.
/*!
 * \ingroup enumerator
 */
struct SolveParams {
	//! Creates a default-initialized object.
	/*!
	 * The following parameters are used:
	 * - restart      : quadratic: 100*1.5^k / no restarts after first solution
	 * - deletion     : initial size: vars()/3, grow factor: 1.1, max factor: 3.0, do not reduce on restart
	 * - randomization: disabled
	 * - randomProp   : 0.0 (disabled)
	 * .
	 */
	SolveParams();
	uint32  prepare(bool withLookback);
	bool    randomize(Solver& s) const;
	RestartParams restart;
	ReduceParams  reduce;
	uint32        randRuns:16; /*!< Number of initial randomized-runs. */
	uint32        randConf:16; /*!< Number of conflicts comprising one randomized-run. */
	float         randProb;    /*!< Use random heuristic with given probability ([0,1]) */
	struct FwdCheck {          /*!< Options for (partial checks in) DLP-solving; */
		uint32 highStep : 24;    /*!< Init/inc high level when reached. */
		uint32 highPct  :  7;    /*!< Check on low + (high - low) * highPct/100  */
		uint32 signDef  :  2;    /*!< Default sign heuristic for atoms in disjunctions. */
		FwdCheck() { std::memset(this, 0, sizeof(*this)); }
	}             fwdCheck;
};

class SharedContext;
class SatPreprocessor;

//! Parameters for (optional) Sat-preprocessing.
struct SatPreParams {
	enum Algo {
		sat_pre_no     = 0, /**< Disable sat-preprocessing.                            */
		sat_pre_ve     = 1, /**< Run variable elimination.                             */
		sat_pre_ve_bce = 2, /**< Run variable- and limited blocked clause elimination. */
		sat_pre_full   = 3, /**< Run variable- and full blocked clause elimination.    */
	};
	SatPreParams() : type(0u), limIters(0u), limTime(0u), limFrozen(0u), limClause(4000u), limOcc(0u) {}
	uint32 type     :  2; /**< One of algo. */
	uint32 limIters : 11; /**< Max. number of iterations.                         (0=no limit)*/
	uint32 limTime  : 12; /**< Max. runtime in sec, checked after each iteration. (0=no limit)*/
	uint32 limFrozen:  7; /**< Run only if percent of frozen vars < maxFrozen.    (0=no limit)*/
	uint32 limClause: 16; /**< Run only if \#clauses \< (limClause*1000)          (0=no limit)*/
	uint32 limOcc   : 16; /**< Skip v, if \#occ(v) \>= limOcc && \#occ(~v) \>= limOcc.(0=no limit) */
	bool clauseLimit(uint32 nc)           const { return limClause && nc > (limClause*1000u); }
	bool occLimit(uint32 pos, uint32 neg) const { return limOcc && pos > (limOcc-1u) && neg > (limOcc-1u); }
	uint32 bce()                          const { return type != sat_pre_no ? type - 1 : 0; }
	void   disableBce()                         { type = std::min(type, uint32(sat_pre_ve));}
	static SatPreprocessor* create(const SatPreParams&);
};

//! Parameters for a SharedContext object.
struct ContextParams {
	//! How to handle short learnt clauses.
	enum ShortMode  {
		short_implicit = 0, /*!< Share short learnt clauses via short implication graph. */
		short_explicit = 1, /*!< Do not use short implication graph. */
	};
	//! How to handle physical sharing of (explicit) constraints.
	enum ShareMode  {
		share_no      = 0, /*!< Do not physically share constraints (use copies instead). */
		share_problem = 1, /*!< Share problem constraints but copy learnt constraints.    */
		share_learnt  = 2, /*!< Copy problem constraints but share learnt constraints.    */
		share_all     = 3, /*!< Share all constraints.                                    */
		share_auto    = 4, /*!< Use share_no or share_all depending on number of solvers. */
	};
	ContextParams() : shareMode(share_auto), stats(0), shortMode(short_implicit), seed(1), hasConfig(0), cliConfig(0), cliId(0), cliMode(0) {}
	SatPreParams satPre;        /*!< Preprocessing options.                    */
	uint8        shareMode : 3; /*!< Physical sharing mode (one of ShareMode). */
	uint8        stats     : 2; /*!< See SharedContext::enableStats().         */
	uint8        shortMode : 1; /*!< One of ShortMode.                         */
	uint8        seed      : 1; /*!< Apply new seed when adding solvers.       */
	uint8        hasConfig : 1; /*!< Reserved for command-line interface.      */
	uint8        cliConfig;     /*!< Reserved for command-line interface.      */
	uint8        cliId;         /*!< Reserved for command-line interface.      */
	uint8        cliMode;       /*!< Reserved for command-line interface.      */
};

//! Interface for configuring a SharedContext object and its associated solvers.
class Configuration {
public:
	typedef SolverParams  SolverOpts;
	typedef SolveParams   SearchOpts;
	typedef ContextParams CtxOpts;
	virtual ~Configuration();
	//! Prepares this configuration for the usage in the given context.
	virtual void               prepare(SharedContext&)    = 0;
	//! Returns the options for the shared context.
	virtual const CtxOpts&     context()            const = 0;
	//! Returns the number of solver options in this config.
	virtual uint32             numSolver()          const = 0;
	//! Returns the number of search options in this config.
	virtual uint32             numSearch()          const = 0;
	//! Returns the solver options for the i'th solver to be attached to the SharedContext.
	virtual const SolverOpts&  solver(uint32 i)     const = 0;
	//! Returns the search options for the i'th solver of the SharedContext.
	virtual const SearchOpts&  search(uint32 i)     const = 0;
	//! Returns the heuristic to be used in the i'th solver.
	/*!
	 * The function is called in Solver::startInit().
	 * \note The returned object is owned by the caller.
	 */
	virtual DecisionHeuristic* heuristic(uint32 i)  const = 0;
	//! Adds post propagators to the given solver.
	virtual bool               addPost(Solver& s)   const = 0;
	//! Returns the configuration with the given name or 0 if no such config exists.
	/*!
	 * The default implementation returns this
	 * if n is empty or one of "." or "/".
	 * Otherwise, 0 is returned.
	 */
	virtual Configuration*     config(const char* n);
};

//! Base class for user-provided configurations.
class UserConfiguration : public Configuration {
public:
	//! Adds a lookahead post propagator to the given solver if requested.
	/*!
	 * The function adds a lookahead post propagator if indicated by
	 * the solver's SolverParams.
	 */
	virtual bool            addPost(Solver& s)   const;
	//! Returns the (modifiable) solver options for the i'th solver.
	virtual SolverOpts&     addSolver(uint32 i) = 0;
	//! Returns the (modifiable) search options for the i'th solver.
	virtual SearchOpts&     addSearch(uint32 i) = 0;
};

//! Simple factory for decision heuristics.
struct Heuristic_t {
	enum Type { Default = 0, Berkmin = 1, Vsids = 2, Vmtf = 3, Domain = 4, Unit = 5, None = 6, User = 7  };
	typedef DecisionHeuristic* (*Creator)(Type t, const HeuParams& p);
	static inline bool        isLookback(uint32 type) { return type >= (uint32)Berkmin && type < (uint32)Unit; }
	//! Default callback for creating decision heuristics.
	static DecisionHeuristic* create(Type t, const HeuParams& p);
};

//! Basic configuration for one or more SAT solvers.
class BasicSatConfig : public UserConfiguration, public ContextParams {
public:
	typedef Heuristic_t::Creator HeuristicCreator;
	BasicSatConfig();
	void               prepare(SharedContext&);
	const CtxOpts&     context()            const { return *this; }
	uint32             numSolver()          const { return sizeVec(solver_); }
	uint32             numSearch()          const { return sizeVec(search_); }
	const SolverOpts&  solver(uint32 i)     const { return solver_[i % solver_.size() ]; }
	const SearchOpts&  search(uint32 i)     const { return search_[i % search_.size() ]; }
	DecisionHeuristic* heuristic(uint32 i)  const;
	SolverOpts&        addSolver(uint32 i);
	SearchOpts&        addSearch(uint32 i);

	virtual void       reset();
	virtual void       resize(uint32 numSolver, uint32 numSearch);
	//! Sets callback function for creating heuristics.
	void               setHeuristicCreator(HeuristicCreator hc);
private:
	typedef PodVector::type SolverVec;
	typedef PodVector::type SearchVec;
	SolverVec solver_;
	SearchVec search_;
	HeuristicCreator heu_;
};

//! Base class for solving related events.
template 
struct SolveEvent : Event_t {
	SolveEvent(const Solver& s, Event::Verbosity verb) : Event_t(Event::subsystem_solve, verb), solver(&s) {}
	const Solver* solver;
};
struct Model;
//! Base class for handling results of a solve operation.
class ModelHandler {
public:
	virtual ~ModelHandler();
	virtual bool onModel(const Solver&, const Model&) = 0;
	virtual bool onUnsat(const Solver&, const Model&);
};
//! Type for storing the lower bound of a minimize statement.
struct LowerBound {
	LowerBound() : level(0), bound(0) {}
	void reset() { level = 0; bound = 0; }
	uint32 level;
	wsum_t bound;
};

}
#endif
clasp-3.2.2/libclasp/clasp/solver_types.h000066400000000000000000001066121304134206100204220ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_SOLVER_TYPES_H_INCLUDED
#define CLASP_SOLVER_TYPES_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif

#include 
#include 
#include 
#include 
#include 
#include 
/*!
 * \file
 * \brief Types and functions used by a Solver
 */
namespace Clasp {
class SharedLiterals;

/*!
 * \addtogroup solver
 */
//@{
///////////////////////////////////////////////////////////////////////////////
// SearchLimits
///////////////////////////////////////////////////////////////////////////////
struct DynamicLimit;
struct BlockLimit;

//! Parameter-Object for managing search limits.
struct SearchLimits {
	typedef DynamicLimit* LimitPtr;
	typedef BlockLimit*   BlockPtr;
	SearchLimits();
	uint64 used;
	struct {
		uint64   conflicts; //!< Soft limit on number of conflicts for restart.
		LimitPtr dynamic;   //!< Use dynamic restarts based on lbd or conflict level.
		BlockPtr block;     //!< Optional strategy to increase restart limit.
		bool     local;     //!< Apply conflict limit against active branch.
	} restart;            //!< Restart limits.
	uint64 conflicts; //!< Soft limit on number of conflicts.
	uint64 memory;    //!< Soft memory limit for learnt lemmas (in bytes).
	uint32 learnts;   //!< Limit on number of learnt lemmas.
};

//! Type for implementing Glucose-style dynamic restarts.
/*!
 * \see  G. Audemard, L. Simon. "Refining Restarts Strategies for SAT and UNSAT"
 * \note In contrast to Glucose's dynamic restarts, this class also implements
 * a heuristic for dynamically adjusting the margin ratio K.
 */
struct DynamicLimit {
	enum Type { lbd_limit, level_limit };
	//! Creates new limit with bounded queue of the given window size.
	static DynamicLimit* create(uint32 window);
	//! Destroys this object and its bounded queue.
	void   destroy();
	//! Resets moving average and adjust limit.
	void   init(float k, Type type, uint32 uLimit = 16000);
	//! Resets moving average, i.e. clears the bounded queue.
	void   resetRun();
	//! Resets moving and global average.
	void   reset();
	//! Adds an observation and updates the moving average. Typically called on conflict.
	void   update(uint32 conflictLevel, uint32 lbd);
	//! Notifies this object about a restart.
	/*!
	 * The function checks whether to adjust the active margin ratio and/or
	 * whether to switch from LBD based to conflict level based restarts.
	 *
	 * \param maxLBD Threshold for switching between lbd and conflict level queue.
	 * \param k Lower bound for margin ratio.
	 */
	uint32 restart(uint32 maxLBD, float k);
	//! Returns the number of updates since last restart.
	uint32 runLen()  const { return num_;  }
	//! Returns the maximal size of the bounded queue.
	uint32 window()  const { return cap_; }
	//! Returns whether it is time to restart.
	bool   reached() const { return runLen() >= window() && (sma(adjust.type) * adjust.rk) > global.avg(adjust.type); }
	struct {
		//! Returns the global lbd or conflict level average.
		double avg(Type t) const { return ratio(sum[t], samples); }
		uint64 sum[2]; //!< Sum of lbds/conflict levels since last call to resetGlobal().
		uint64 samples;//!< Samples since last call to resetGlobal().
	} global; //!< Global lbd/conflict level data.
	struct {
		//! Returns the average restart length, i.e. number of conflicts between restarts.
		double avgRestart() const { return ratio(samples, restarts); }
		uint32 limit;   //!< Number of conflicts before an update is forced.
		uint32 restarts;//!< Number of restarts since last update.
		uint32 samples; //!< Number of samples since last update.
		float  rk;      //!< BD/CFL dynamic limit factor (typically < 1.0).
		Type   type;    //!< Dynamic limit based on lbd or confllict level.
	} adjust; //!< Data for dynamically adjusting margin ratio (rk).
private:
	DynamicLimit(uint32 size);
	DynamicLimit(const DynamicLimit&);
	DynamicLimit& operator=(const DynamicLimit&);
	double sma(Type t)  const { return sum_[t] / double(cap_); }
	uint32 smaU(Type t) const { return static_cast(sum_[t] / cap_); }
	uint64 sum_[2];
	uint32 cap_;
	uint32 pos_;
	uint32 num_;
CLASP_WARNING_BEGIN_RELAXED
	uint32 buffer_[0];
CLASP_WARNING_END_RELAXED
};

//! Type for implementing Glucose-style blocking of restarts.
/*!
 * \see G. Audemard, L. Simon "Refining Restarts Strategies for SAT and UNSAT"
 * \see A. Biere, A. Froehlich "Evaluating CDCL Variable Scoring Schemes"
 */
struct BlockLimit {
	explicit BlockLimit(uint32 windowSize, double R = 1.4);
	bool push(uint32 nAssign) {
		ema = n >= span
			? exponentialMovingAverage(ema, nAssign, alpha)
			: cumulativeMovingAverage(ema, nAssign, n);
		return ++n >= next;
	}
	//! Returns the exponential moving average scaled by r.
	double scaled() const { return ema * r; }
	double ema;   //!< Current exponential moving average.
	double alpha; //!< Smoothing factor: 2/(span+1).
	uint64 next;  //!< Enable once n >= next.
	uint64 inc;   //!< Block restart for next inc conflicts.
	uint64 n;     //!< Number of data points seen so far.
	uint32 span;  //!< Minimum observation window.
	float  r;     //!< Scale factor for ema.
};
///////////////////////////////////////////////////////////////////////////////
// Statistics
///////////////////////////////////////////////////////////////////////////////
class StatisticObject;
class StatsMap;
#if !defined(DOXY)
#define DOXY(X)
#endif
#define CLASP_STAT_DEFINE(m, k, a, accu) m
#define NO_ARG
#define CLASP_DECLARE_ISTATS(T) \
	void accu(const T& o);\
	static uint32 size();\
	static const char* key(uint32 i);\
	StatisticObject at(const char* key) const

//! A struct for holding core statistics used by a solver.
/*!
 * Core statistics are always present in a solver and hence
 * can be used by heuristics.
 */
struct CoreStats {
#define CLASP_CORE_STATS(STAT, LHS, RHS)     \
	STAT(uint64 choices;    DOXY(number of choices)     , "choices"           , VALUE(choices)    , LHS.choices    += RHS.choices   )\
	STAT(uint64 conflicts;  DOXY(number of conflicts)   , "conflicts"         , VALUE(conflicts)  , LHS.conflicts  += RHS.conflicts )\
	STAT(uint64 analyzed;   DOXY(number of conflicts analyzed), "conflicts_analyzed", VALUE(analyzed)   , LHS.analyzed   += RHS.analyzed  )\
	STAT(uint64 restarts;   DOXY(number of restarts)    , "restarts"          , VALUE(restarts)   , LHS.restarts   += RHS.restarts  )\
	STAT(uint64 lastRestart;DOXY(length of last restart), "restarts_last"     , VALUE(lastRestart), LHS.lastRestart = std::max(LHS.lastRestart, RHS.lastRestart))

	CoreStats() { reset(); }
	void reset();
	uint64 backtracks() const { return conflicts-analyzed; }
	uint64 backjumps()  const { return analyzed; }
	double avgRestart() const { return ratio(analyzed, restarts); }
	CLASP_DECLARE_ISTATS(CoreStats);
	CLASP_CORE_STATS(CLASP_STAT_DEFINE, NO_ARG, NO_ARG)
};
//! A struct for holding (optional) jump statistics.
struct JumpStats {
#define CLASP_JUMP_STATS(STAT, LHS, RHS)     \
	STAT(uint64 jumps;    DOXY(number of backjumps)                  , "jumps"          , VALUE(jumps)    , LHS.jumps    += RHS.jumps)   \
	STAT(uint64 bounded;  DOXY(backjumps bounded by root level)      , "jumps_bounded"  , VALUE(bounded)  , LHS.bounded  += RHS.bounded)  \
	STAT(uint64 jumpSum;  DOXY(levels removed by jumps)              , "levels"         , VALUE(jumpSum)  , LHS.jumpSum  += RHS.jumpSum)  \
	STAT(uint64 boundSum; DOXY(levels kept because of root level)    , "levels_bounded" , VALUE(boundSum) , LHS.boundSum += RHS.boundSum) \
	STAT(uint32 maxJump;  DOXY(longest backjump)                     , "max"            , VALUE(maxJump)  , MAX_MEM(LHS.maxJump, RHS.maxJump))   \
	STAT(uint32 maxJumpEx;DOXY(longest unbounded backjump)           , "max_executed"   , VALUE(maxJumpEx), MAX_MEM(LHS.maxJumpEx,RHS.maxJumpEx)) \
	STAT(uint32 maxBound; DOXY(max levels kept because of root level), "max_bounded"    , VALUE(maxBound) , MAX_MEM(LHS.maxBound, RHS.maxBound))

	JumpStats() { reset(); }
	void reset();
	void update(uint32 dl, uint32 uipLevel, uint32 bLevel) {
		++jumps;
		jumpSum += dl - uipLevel;
		maxJump = std::max(maxJump, dl - uipLevel);
		if (uipLevel < bLevel) {
			++bounded;
			boundSum += bLevel - uipLevel;
			maxJumpEx = std::max(maxJumpEx, dl - bLevel);
			maxBound = std::max(maxBound, bLevel - uipLevel);
		}
		else { maxJumpEx = maxJump; }
	}
	uint64 jumped()     const { return jumpSum - boundSum; }
	double jumpedRatio()const { return ratio(jumped(), jumpSum); }
	double avgBound()   const { return ratio(boundSum, bounded); }
	double avgJump()    const { return ratio(jumpSum, jumps); }
	double avgJumpEx()  const { return ratio(jumped(), jumps); }
	CLASP_DECLARE_ISTATS(JumpStats);
	CLASP_JUMP_STATS(CLASP_STAT_DEFINE, NO_ARG, NO_ARG)
};

//! A struct for holding (optional) extended statistics.
struct ExtendedStats {
	typedef ConstraintType type_t;
	//! An array for storing a value[t-1] for each learnt Constraint_t::Type t.
	typedef uint64 Array[Constraint_t::Type__max];
#define CLASP_EXTENDED_STATS(STAT, LHS, RHS)     \
	STAT(uint64 domChoices; DOXY(number of domain choices)   , "domain_choices"        , VALUE(domChoices) , LHS.domChoices += RHS.domChoices) \
	STAT(uint64 models;     DOXY(number of models)           , "models"                , VALUE(models)     , LHS.models     += RHS.models)     \
	STAT(uint64 modelLits;  DOXY(decision levels in models)  , "models_level"          , VALUE(modelLits)  , LHS.modelLits  += RHS.modelLits)  \
	STAT(uint64 hccTests;   DOXY(number of stability tests)  , "hcc_tests"             , VALUE(hccTests)   , LHS.hccTests   += RHS.hccTests)   \
	STAT(uint64 hccPartial; DOXY(number of partial tests)    , "hcc_partial"           , VALUE(hccPartial) , LHS.hccPartial += RHS.hccPartial) \
	STAT(uint64 deleted;    DOXY(lemmas deleted )            , "lemmas_deleted"        , VALUE(deleted)    , LHS.deleted    += RHS.deleted)    \
	STAT(uint64 distributed;DOXY(lemmas distributed )        , "distributed"           , VALUE(distributed), LHS.distributed+= RHS.distributed)\
	STAT(uint64 sumDistLbd; DOXY(lbds of distributed lemmas) , "distributed_sum_lbd"   , VALUE(sumDistLbd) , LHS.sumDistLbd += RHS.sumDistLbd) \
	STAT(uint64 integrated; DOXY(lemmas integrated )         , "integrated"            , VALUE(integrated) , LHS.integrated += RHS.integrated) \
	STAT(Array learnts;     DOXY(lemmas of each learnt type) , "lemmas"                , MEM_FUN(lemmas)   , NO_ARG)   \
	STAT(Array lits;        DOXY(lits of each learnt type)   , "lits_learnt"           , MEM_FUN(learntLits), NO_ARG)  \
	STAT(uint32 binary;     DOXY(number of binary lemmas)    , "lemmas_binary"         , VALUE(binary)  , LHS.binary  += RHS.binary)  \
	STAT(uint32 ternary;    DOXY(number of ternary lemmas)   , "lemmas_ternary"        , VALUE(ternary) , LHS.ternary += RHS.ternary) \
	STAT(double cpuTime;    DOXY(cpu time used )             , "cpu_time"              , VALUE(cpuTime) , LHS.cpuTime += RHS.cpuTime) \
	STAT(uint64 intImps;    DOXY(implications on integrating), "integrated_imps"       , VALUE(intImps) , LHS.intImps+= RHS.intImps)  \
	STAT(uint64 intJumps;   DOXY(backjumps on integrating)   , "integrated_jumps"      , VALUE(intJumps), LHS.intJumps+=RHS.intJumps) \
	STAT(uint64 gpLits;     DOXY(lits in received gps)       , "guiding_paths_lits"    , VALUE(gpLits)  , LHS.gpLits  += RHS.gpLits)  \
	STAT(uint32 gps;        DOXY(guiding paths received)     , "guiding_paths"         , VALUE(gps)     , LHS.gps     += RHS.gps)     \
	STAT(uint32 splits;     DOXY(split requests handled)     , "splits"                , VALUE(splits)  , LHS.splits  += RHS.splits)  \
	STAT(NO_ARG       , "lemmas_conflict", VALUE(learnts[0]) , LHS.learnts[0] += RHS.learnts[0]) \
	STAT(NO_ARG       , "lemmas_loop"    , VALUE(learnts[1]) , LHS.learnts[1] += RHS.learnts[1]) \
	STAT(NO_ARG       , "lemmas_other"   , VALUE(learnts[2]) , LHS.learnts[2] += RHS.learnts[2]) \
	STAT(NO_ARG       , "lits_conflict"  , VALUE(lits[0])    , LHS.lits[0]    += RHS.lits[0])    \
	STAT(NO_ARG       , "lits_loop"      , VALUE(lits[1])    , LHS.lits[1]    += RHS.lits[1])    \
	STAT(NO_ARG       , "lits_other"     , VALUE(lits[2])    , LHS.lits[2]    += RHS.lits[2])    \
	STAT(JumpStats jumps;DOXY(backjump statistics)           , "jumps"                 , MAP(jumps)     , LHS.jumps.accu(RHS.jumps))

	ExtendedStats() { reset(); }
	void reset();
	void addLearnt(uint32 size, type_t t) {
		if (t == Constraint_t::Static) return;
		learnts[t-1]+= 1;
		lits[t-1]   += size;
		binary      += (size == 2);
		ternary     += (size == 3);
	}
	//! Total number of lemmas learnt.
	uint64 lemmas()        const { return std::accumulate(learnts, learnts+Constraint_t::Type__max, uint64(0)); }
	//! Total number of literals in all learnt lemmas.
	uint64 learntLits()    const { return std::accumulate(lits, lits+Constraint_t::Type__max, uint64(0)); }
	//! Number of lemmas of learnt type t.
	uint64 lemmas(type_t t)const { return learnts[t-1]; }
	//! Average length of lemmas of learnt type t.
	double avgLen(type_t t)const { return ratio(lits[t-1], lemmas(t)); }
	//! Average decision level on which models were found.
	double avgModel()      const { return ratio(modelLits, models);    }
	//! Ratio of lemmas that were distributed to other threads.
	double distRatio()     const { return ratio(distributed, learnts[0] + learnts[1]);  }
	//! Average lbd of lemmas that were distributed to other threads.
	double avgDistLbd()    const { return ratio(sumDistLbd, distributed); }
	double avgIntJump()    const { return ratio(intJumps, intImps); }
	//! Average length (i.e. number of literals) of guiding paths.
	double avgGp()         const { return ratio(gpLits, gps); }
	//! Ratio of lemmas integrated.
	double intRatio()      const { return ratio(integrated, distributed); }
	CLASP_DECLARE_ISTATS(ExtendedStats);
	CLASP_EXTENDED_STATS(CLASP_STAT_DEFINE,NO_ARG,NO_ARG)
};

//! A struct for aggregating statistics maintained in a solver object.
struct SolverStats : public CoreStats {
	SolverStats();
	SolverStats(const SolverStats& o);
	~SolverStats();
	bool enableExtended();
	bool enable(const SolverStats& o) { return !o.extra || enableExtended(); }
	void enableLimit(uint32 size);
	void reset();
	void accu(const SolverStats& o);
	void accu(const SolverStats& o, bool enableRhs);
	void swapStats(SolverStats& o);
	void flush() const;
	uint32 size() const;
	const char* key(uint32 i) const;
	StatisticObject at(const char* key) const;
	void addTo(const char* key, StatsMap& solving, StatsMap* accu) const;
	inline void addLearnt(uint32 size, ConstraintType t);
	inline void addConflict(uint32 dl, uint32 uipLevel, uint32 bLevel, uint32 lbd);
	inline void addDeleted(uint32 num);
	inline void addDistributed(uint32 lbd, ConstraintType t);
	inline void addTest(bool partial);
	inline void addModel(uint32 decisionLevel);
	inline void addCpuTime(double t);
	inline void addSplit(uint32 num = 1);
	inline void addDomChoice(uint32 num = 1);
	inline void addIntegratedAsserting(uint32 receivedDL, uint32 jumpDL);
	inline void addIntegrated(uint32 num = 1);
	inline void removeIntegrated(uint32 num = 1);
	inline void addPath(const LitVec::size_type& sz);
	DynamicLimit*  limit; /**< Optional dynamic limit.       */
	ExtendedStats* extra; /**< Optional extended statistics. */
	SolverStats*   multi; /**< Not owned: set to accu stats in multishot solving. */
private: SolverStats& operator=(const SolverStats&);
};
inline void SolverStats::addLearnt(uint32 size, ConstraintType t)  { if (extra) { extra->addLearnt(size, t); } }
inline void SolverStats::addDeleted(uint32 num)                    { if (extra) { extra->deleted += num; }  }
inline void SolverStats::addDistributed(uint32 lbd, ConstraintType){ if (extra) { ++extra->distributed; extra->sumDistLbd += lbd; } }
inline void SolverStats::addIntegrated(uint32 n)                   { if (extra) { extra->integrated += n;} }
inline void SolverStats::removeIntegrated(uint32 n)                { if (extra) { extra->integrated -= n;} }
inline void SolverStats::addCpuTime(double t)                      { if (extra) { extra->cpuTime += t; }    }
inline void SolverStats::addSplit(uint32 num)                      { if (extra) { extra->splits += num; }  }
inline void SolverStats::addPath(const LitVec::size_type& sz)      { if (extra) { ++extra->gps; extra->gpLits += sz; } }
inline void SolverStats::addTest(bool partial)                     { if (extra) { ++extra->hccTests; extra->hccPartial += (uint32)partial; } }
inline void SolverStats::addModel(uint32 DL)                       { if (extra) { ++extra->models; extra->modelLits += DL; } }
inline void SolverStats::addDomChoice(uint32 n)                    { if (extra) { extra->domChoices += n; } }
inline void SolverStats::addIntegratedAsserting(uint32 rDL, uint32 jDL) {
	if (extra) { ++extra->intImps; extra->intJumps += (rDL - jDL); }
}
inline void SolverStats::addConflict(uint32 dl, uint32 uipLevel, uint32 bLevel, uint32 lbd) {
	++analyzed;
	if (limit) { limit->update(dl, lbd); }
	if (extra) { extra->jumps.update(dl, uipLevel, bLevel); }
}
#undef CLASP_STAT_DEFINE
#undef NO_ARG
#undef DOXY
#undef CLASP_DECLARE_ISTATS
///////////////////////////////////////////////////////////////////////////////
// Clauses
///////////////////////////////////////////////////////////////////////////////
//! Primitive representation of a clause.
struct ClauseRep {
	typedef ConstraintInfo Info;
	static ClauseRep create(Literal* cl, uint32 sz, const Info& i = Info())  { return ClauseRep(cl, sz, false, i);}
	static ClauseRep prepared(Literal* cl, uint32 sz, const Info& i = Info()){ return ClauseRep(cl, sz, true, i); }
	ClauseRep(Literal* cl = 0, uint32 sz = 0, bool p = false, const Info& i = Info()) : info(i), size(sz), prep(uint32(p)), lits(cl) {}
	Info     info;    /*!< Additional clause info.    */
	uint32   size:31; /*!< Size of array of literals. */
	uint32   prep: 1; /*!< Whether lits is already prepared. */
	Literal* lits;    /*!< Pointer to array of literals (not owned!). */
	bool isImp() const { return size > 1 && size < 4; }
};

//! (Abstract) base class for clause types.
/*!
 * ClauseHead is used to enforce a common memory-layout for all clauses.
 * It contains the two watched literals and a cache literal to improve
 * propagation performance. A virtual call to Constraint::propagate()
 * is only needed if the other watch is not true and the cache literal
 * is false.
 */
class ClauseHead : public Constraint {
public:
	enum { HEAD_LITS = 3, MAX_SHORT_LEN = 5 };
	explicit ClauseHead(const InfoType& init);
	// base interface
	//! Propagates the head and calls updateWatch() if necessary.
	PropResult propagate(Solver& s, Literal, uint32& data);
	//! Type of clause.
	Type       type()     const { return info_.type(); }
	//! Returns the activity of this clause.
	ScoreType  activity() const { return info_.score(); }
	//! True if this clause currently is the antecedent of an assignment.
	bool       locked(const Solver& s) const;
	//! Halves the activity of this clause.
	void       decreaseActivity() { info_.score().reduce(); }
	void       resetActivity()    { info_.score().reset(); }
	//! Downcast from LearntConstraint.
	ClauseHead* clause() { return this; }

	// clause interface
	typedef std::pair BoolPair;
	//! Adds watches for first two literals in head to solver.
	void attach(Solver& s);
	void resetScore(ScoreType sc);
	//! Returns true if head is satisfied w.r.t current assignment in s.
	bool satisfied(const Solver& s) const;
	//! Conditional clause?
	bool tagged() const { return info_.tagged(); }
	//! Contains aux vars?
	bool aux()    const { return info_.aux(); }
	bool learnt() const { return info_.learnt(); }
	uint32 lbd()  const { return info_.lbd(); }
	//! Removes watches from s.
	virtual void     detach(Solver& s);
	//! Returns the size of this clause.
	virtual uint32   size()              const = 0;
	//! Returns the literals of this clause in out.
	virtual void     toLits(LitVec& out) const = 0;
	//! Returns true if this clause is a valid "reverse antecedent" for p.
	virtual bool     isReverseReason(const Solver& s, Literal p, uint32 maxL, uint32 maxN) = 0;
	//! Removes p from clause if possible.
	/*!
	 * \return
	 *   The first component of the returned pair specifies whether or not
	 *   p was removed from the clause.
	 *   The second component of the returned pair specifies whether
	 *   the clause should be kept (false) or removed (true).
	 */
	virtual BoolPair strengthen(Solver& s, Literal p, bool allowToShort = true) = 0;
protected:
	struct Local {
		void   init(uint32 sz);
		bool   isSmall()     const  { return (mem[0] & 1u) == 0u; }
		bool   contracted()  const  { return (mem[0] & 3u) == 3u; }
		bool   strengthened()const  { return (mem[0] & 5u) == 5u; }
		uint32 size()        const  { return mem[0] >> 3; }
		void   setSize(uint32 size) { mem[0] = (size << 3) | (mem[0] & 7u); }
		void   markContracted()     { mem[0] |= 2u; }
		void   markStrengthened()   { mem[0] |= 4u; }
		void   clearContracted()    { mem[0] &= ~2u; }
		void   clearIdx()           { mem[1] = 0; }
		uint32 mem[2];
	};
	bool toImplication(Solver& s);
	void clearTagged()    { info_.setTagged(false); }
	void setLbd(uint32 x) { info_.setLbd(x); }
	//! Shall replace the watched literal at position pos with a non-false literal.
	/*!
	 * \pre pos in [0,1]
	 * \pre s.isFalse(head_[pos]) && s.isFalse(head_[2])
	 * \pre head_[pos^1] is the other watched literal
	 */
	virtual bool updateWatch(Solver& s, uint32 pos) = 0;
	union {
		Local           local_;
		SharedLiterals* shared_;
	};
	InfoType info_;
	Literal  head_[HEAD_LITS]; // two watched literals and one cache literal
};
//! Allocator for small (at most 32-byte) clauses.
class SmallClauseAlloc {
public:
	SmallClauseAlloc();
	~SmallClauseAlloc();
	void* allocate() {
		if(freeList_ == 0) {
			allocBlock();
		}
		Chunk* r   = freeList_;
		freeList_  = r->next;
		return r;
	}
	void   free(void* mem) {
		Chunk* b = reinterpret_cast(mem);
		b->next  = freeList_;
		freeList_= b;
	}
private:
	SmallClauseAlloc(const SmallClauseAlloc&);
	SmallClauseAlloc& operator=(const SmallClauseAlloc&);
	struct Chunk {
		Chunk*        next; // enforce ptr alignment
		unsigned char mem[32 - sizeof(Chunk*)];
	};
	struct Block {
		enum { num_chunks = 1023 };
		Block* next;
		unsigned char pad[32-sizeof(Block*)];
		Chunk  chunk[num_chunks];
	};
	void allocBlock();
	Block*  blocks_;
	Chunk*  freeList_;
};
///////////////////////////////////////////////////////////////////////////////
// Watches
///////////////////////////////////////////////////////////////////////////////
//! Represents a clause watch in a Solver.
struct ClauseWatch {
	//! Clause watch: clause head
	explicit ClauseWatch(ClauseHead* a_head) : head(a_head) { }
	ClauseHead* head;
	struct EqHead {
		explicit EqHead(ClauseHead* h) : head(h) {}
		bool operator()(const ClauseWatch& w) const { return head == w.head; }
		ClauseHead* head;
	};
};

//! Represents a generic watch in a Solver.
struct GenericWatch {
	//! A constraint and some associated data.
	explicit GenericWatch(Constraint* a_con, uint32 a_data = 0) : con(a_con), data(a_data) {}
	//! Calls propagate on the stored constraint and passes the stored data to that constraint.
	Constraint::PropResult propagate(Solver& s, Literal p) { return con->propagate(s, p, data); }

	Constraint* con;    /**< The constraint watching a certain literal. */
	uint32      data;   /**< Additional data associated with this watch - passed to constraint on update. */

	struct EqConstraint {
		explicit EqConstraint(Constraint* c) : con(c) {}
		bool operator()(const GenericWatch& w) const { return con == w.con; }
		Constraint* con;
	};
};

//! Watch list type.
typedef bk_lib::left_right_sequence WatchList;
inline void releaseVec(WatchList& w) { w.clear(true); }

///////////////////////////////////////////////////////////////////////////////
// Assignment
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//! Type for storing reasons for variable assignments together with additional data.
/*!
 * \note On 32-bit systems additional data is stored in the high-word of antecedents.
 */
struct ReasonStore32 : PodVector::type {
	uint32 data(uint32 v) const { return decode((*this)[v]);}
	void   setData(uint32 v, uint32 data) { encode((*this)[v], data); }
	static void encode(Antecedent& a, uint32 data) {
		a.asUint() = (uint64(data)<<32) | static_cast(a.asUint());
	}
	static uint32 decode(const Antecedent& a) {
		return static_cast(a.asUint()>>32);
	}
	struct value_type {
		value_type(const Antecedent& a, uint32 d) : ante_(a) {
			if (d != UINT32_MAX) { encode(ante_, d); assert(data() == d && ante_.type() == Antecedent::Generic); }
		}
		const Antecedent& ante() const { return ante_;      }
		      uint32      data() const { return ante_.type() == Antecedent::Generic ? decode(ante_) : UINT32_MAX; }
		Antecedent ante_;
	};
};

//! Type for storing reasons for variable assignments together with additional data.
/*
 * \note On 64-bit systems additional data is stored in a separate container.
 */
struct ReasonStore64 : PodVector::type {
	uint32  dataSize() const               { return (uint32)data_.size(); }
	void    dataResize(uint32 nv)          { if (nv > dataSize()) data_.resize(nv, UINT32_MAX); }
	uint32  data(uint32 v) const           { return v < dataSize() ? data_[v] : UINT32_MAX; }
	void    setData(uint32 v, uint32 data) { dataResize(v+1); data_[v] = data; }
	VarVec  data_;
	struct  value_type : std::pair {
		value_type(const Antecedent& a, uint32 d) : std::pair(a, d) {}
		const Antecedent& ante() const { return first;  }
		      uint32      data() const { return second; }
	};
};

//! A set of configurable values for a variable.
/*!
 * Beside its currently assigned value, a variable
 * can also have a user, saved, preferred, and default value.
 * These values are used in sign selection to determine the signed literal
 * of a variable to be assign first.
 * During sign selection, the values form a hierarchy:
 * user > saved > preferred > current sign score of heuristic > default value
 */
struct ValueSet {
	ValueSet() : rep(0) {}
	enum Value { user_value = 0x03u, saved_value = 0x0Cu, pref_value = 0x30u, def_value = 0xC0u };
	bool     sign()       const { return (right_most_bit(rep) & 0xAAu) != 0; }
	bool     empty()      const { return rep == 0; }
	bool     has(Value v) const { return (rep & v) != 0; }
	bool     has(uint32 f)const { return (rep & f) != 0; }
	ValueRep get(Value v) const { return static_cast((rep & v) / right_most_bit(static_cast(v))); }
	void     set(Value which, ValueRep to) { rep &= ~which; rep |= (to * right_most_bit(static_cast(which))); }
	void     save(ValueRep x)   { rep &= ~saved_value; rep |= (x << 2); }
	uint8 rep;
};

//! Stores assignment related information.
/*!
 * For each variable v, the class stores
 *  - v's current value (value_free if unassigned)
 *  - the decision level on which v was assign (only valid if value(v) != value_free)
 *  - the reason why v is in the assignment (only valid if value(v) != value_free)
 *  - (optionally) some additional data associated with the reason
 *  .
 * Furthermore, the class stores the sequences of assignments as a set of
 * true literals in its trail-member.
 */
class Assignment  {
public:
	typedef PodVector::type     AssignVec;
	typedef PodVector::type   PrefVec;
	typedef bk_lib::detail::if_then_else<
		sizeof(Constraint*)==sizeof(uint64)
		, ReasonStore64
		, ReasonStore32>::type            ReasonVec;
	typedef ReasonVec::value_type       ReasonWithData;
	Assignment() : front(0), elims_(0), units_(0) { }
	LitVec  trail;   // assignment sequence
	uint32  front;   // and "propagation queue"
	bool    qEmpty() const { return front == static_cast(trail.size()); }
	uint32  qSize()  const { return static_cast(trail.size() - front); }
	Literal qPop()         { return trail[front++]; }
	void    qReset()       { front  = static_cast(trail.size()); }

	//! Number of variables in the three-valued assignment.
	uint32            numVars()    const { return (uint32)assign_.size(); }
	//! Number of assigned variables.
	uint32            assigned()   const { return (uint32)trail.size();   }
	//! Number of free variables.
	uint32            free()       const { return numVars() - (assigned()+elims_);   }
	//! Returns the largest possible decision level.
	uint32            maxLevel()   const { return (1u<<28)-2; }
	//! Returns v's value in the three-valued assignment.
	ValueRep          value(Var v) const { return ValueRep(assign_[v] & 3u); }
	//! Returns the decision level on which v was assigned if value(v) != value_free.
	uint32            level(Var v) const { return assign_[v] >> 4u; }
	//! Returns true if v was not eliminated from the assignment.
	bool              valid(Var v) const { return (assign_[v] & elim_mask) != elim_mask; }
	//! Returns the set of preferred values of v.
	const ValueSet    pref(Var v)  const { return v < pref_.size() ? pref_[v] : ValueSet(); }
	//! Returns the reason for v being assigned if value(v) != value_free.
	const Antecedent& reason(Var v)const { return reason_[v]; }
	//! Returns the reason data associated with v.
	uint32            data(Var v)  const { return reason_.data(v); }

	void reserve(uint32 n) {
		assign_.reserve(n);
		reason_.reserve(n);
	}
	//! Resize to nv variables.
	void resize(uint32 nv) {
		assign_.resize(nv);
		reason_.resize(nv);
	}
	//! Adds a var to assignment - initially the new var is unassigned.
	Var addVar() {
		assign_.push_back(0);
		reason_.push_back(0);
		return numVars()-1;
	}
	//! Allocates space for storing preferred values for all variables.
	void requestPrefs() {
		if (pref_.size() != assign_.size()) { pref_.resize(assign_.size()); }
	}
	//! Eliminates v from the assignment.
	void eliminate(Var v) {
		assert(value(v) == value_free && "Can not eliminate assigned var!\n");
		if (valid(v)) { assign_[v] = elim_mask|value_true; ++elims_; }
	}
	//! Assigns p.var() on level lev to the value that makes p true and stores x as reason for the assignment.
	/*!
	 * \return true if the assignment is consistent. False, otherwise.
	 * \post If true is returned, p is in trail. Otherwise, ~p is.
	 */
	bool assign(Literal p, uint32 lev, const Antecedent& x) {
		const Var      v   = p.var();
		const ValueRep val = value(v);
		if (val == value_free) {
			assert(valid(v));
			assign_[v] = (lev<<4) + trueValue(p);
			reason_[v] = x;
			trail.push_back(p);
			return true;
		}
		return val == trueValue(p);
	}
	bool assign(Literal p, uint32 lev, Constraint* c, uint32 data) {
		const Var      v   = p.var();
		const ValueRep val = value(v);
		if (val == value_free) {
			assert(valid(v));
			assign_[v] = (lev<<4) + trueValue(p);
			reason_[v] = c;
			reason_.setData(v, data);
			trail.push_back(p);
			return true;
		}
		return val == trueValue(p);
	}
	//! Undos all assignments in the range trail[first, last).
	/*!
	 * \param first First assignment to be undone.
	 * \param save  If true, previous assignment of a var is saved before it is undone.
	 */
	void undoTrail(LitVec::size_type first, bool save) {
		if (!save) { popUntil<&Assignment::clear>(trail[first]); }
		else       { requestPrefs(); popUntil<&Assignment::saveAndClear>(trail[first]); }
		qReset();
	}
	//! Undos the last assignment.
	void undoLast() { clear(trail.back().var()); trail.pop_back(); }
	//! Returns the last assignment as a true literal.
	Literal last() const { return trail.back(); }
	Literal&last()       { return trail.back(); }
	/*!
	 * \name Implementation functions
	 * Low-level implementation functions. Use with care and only if you
	 * know what you are doing!
	 */
	//@{
	uint32 units()              const { return units_; }
	bool   seen(Var v, uint8 m) const { return (assign_[v] & (m<<2)) != 0; }
	void   setSeen(Var v, uint8 m)    { assign_[v] |= (m<<2); }
	void   clearSeen(Var v)           { assign_[v] &= ~uint32(12); }
	void   clearValue(Var v)          { assign_[v] &= ~uint32(3); }
	void   setValue(Var v, ValueRep val) {
		assert(value(v) == val || value(v) == value_free);
		assign_[v] |= val;
	}
	void   setReason(Var v, const Antecedent& a) { reason_[v] = a;  }
	void   setData(Var v, uint32 data) { reason_.setData(v, data); }
	void   setPref(Var v, ValueSet::Value which, ValueRep to) { pref_[v].set(which, to); }
	void   copyAssignment(Assignment& o) const { o.assign_ = assign_; }
	bool   markUnits()                 { while (units_ != front) { setSeen(trail[units_++].var(), 3u); }  return true; }
	void   setUnits(uint32 ts)         { units_ = ts; }
	void   resetPrefs()                { pref_.assign(pref_.size(), ValueSet()); }
	void   clear(Var v)                { assign_[v] = 0; }
	void   saveAndClear(Var v)         { pref_[v].save(value(v)); clear(v); }
	//@}
private:
	static const uint32 elim_mask = uint32(0xFFFFFFF0u);
	Assignment(const Assignment&);
	Assignment& operator=(const Assignment&);
	template 
	void popUntil(Literal stop) {
		Literal p;
		do {
			p = trail.back(); trail.pop_back();
			(this->*op)(p.var());
		} while (p != stop);
	}
	AssignVec assign_; // for each var: three-valued assignment
	ReasonVec reason_; // for each var: reason for being assigned (+ optional data)
	PrefVec   pref_;   // for each var: set of preferred values
	uint32    elims_;  // number of variables that were eliminated from the assignment
	uint32    units_;  // number of marked top-level assignments
};

//! Stores information about a literal that is implied on an earlier level than the current decision level.
struct ImpliedLiteral {
	typedef Assignment::ReasonWithData AnteInfo;
	ImpliedLiteral(Literal a_lit, uint32 a_level, const Antecedent& a_ante, uint32 a_data = UINT32_MAX)
		: lit(a_lit)
		, level(a_level)
		, ante(a_ante, a_data) {
	}
	Literal  lit;   /**< The implied literal */
	uint32   level; /**< The earliest decision level on which lit is implied */
	AnteInfo ante;  /**< The reason why lit is implied on decision-level level */
};
//! A type for storing ImpliedLiteral objects.
struct ImpliedList {
	typedef PodVector::type VecType;
	typedef VecType::const_iterator iterator;
	ImpliedList() : level(0), front(0) {}
	//! Searches for an entry 
 in list. Returns 0 if none is found.
	ImpliedLiteral* find(Literal p) {
		for (VecType::size_type i = 0, end = lits.size(); i != end; ++i) {
			if (lits[i].lit == p)  { return &lits[i]; }
		}
		return 0;
	}
	//! Adds a new object to the list.
	void add(uint32 dl, const ImpliedLiteral& n) {
		if (dl > level) { level = dl; }
		lits.push_back(n);
	}
	//! Returns true if list contains entries that must be reassigned on current dl.
	bool active(uint32 dl) const { return dl < level && front != lits.size(); }
	//! Reassigns all literals that are still implied.
	bool assign(Solver& s);
	iterator begin() const { return lits.begin(); }
	iterator end()   const { return lits.end();   }
	VecType lits;  // current set of (out-of-order) implied literals
	uint32  level; // highest dl on which lits must be reassigned
	uint32  front; // current starting position in lits
};
//@}
}
#endif
clasp-3.2.2/libclasp/clasp/statistics.h000066400000000000000000000242401304134206100200520ustar00rootroot00000000000000//
// Copyright (c) 2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
//! \file
//! \brief Types and functions for accessing statistics.
#ifndef CLASP_STATISTICS_H_INCLUDED
#define CLASP_STATISTICS_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
#include 
#include 
namespace Clasp {

template 
double _getValue(const T* v) { return static_cast(*v); }

//! Discriminated union representing either a single statistic value or a composite.
class StatisticObject {
public:
	typedef Potassco::Statistics_t Type;
	struct Hasher { std::size_t operator()(const StatisticObject& o) const { return o.hash(); } };
	//! Creates an empty (invalid) object.
	StatisticObject();
	//! Creates a Value object - static_cast(*obj) shall be valid.
	template 
	static StatisticObject value(const T* obj) {
		return value(obj);
	}
	//! Creates a mapped Value object: f(obj) -> double
	template 
	static StatisticObject value(const T* obj) {
		return StatisticObject(obj, registerValue());
	}
	//! Creates a Map object.
	/*!
	 * The following expression shall be valid:
	 * obj->size(): shall return the number of keys in obj
	 * obj->key(i): shall return the i'th key of this object (i >= 0).
	 * obj->at(const char* k): shall return the StatisticObject under the given key.
	 *  If k is invalid, shall either throw an exception or return an empty object.
	 */
	template 
	static StatisticObject map(const T* obj) {
		return StatisticObject(obj, registerMap());
	}
	//! Creates an Array object.
	/*!
	 * The following expression shall be valid:
	 * obj->size(): shall return the size of the array.
	 * obj->at(i): shall return the StatisticObject under the given key i >= 0.
	 *  If k is invalid, shall either throw an exception or return an empty object.
	 */
	template 
	static StatisticObject array(const T* obj) {
		return StatisticObject(obj, registerArray());
	}
	//! Returns the type of this object.
	Type   type()  const;
	//! Returns whether this object is empty.
	bool   empty() const;
	//! Returns the number of children of this object or 0 if this is not a composite object.
	uint32 size()  const;

	/*!
	 * \name Map
	 * \pre type() == Map
	 */
	//@{
	//! Returns the i'th key of this map.
	/*!
	 * \pre i < size()
	 */
	const char*     key(uint32 i)     const;
	//! Returns the object under the given key.
	/*!
	 * \pre k in key([0..size()))
	 */
	StatisticObject at(const char* k) const;
	//@}

	//! Returns the object at the given index.
	/*!
	 * \pre Type() == Array
	 * \pre i < size()
	 */
	StatisticObject operator[](uint32 i) const;

	//! Returns the value of this object.
	/*!
	 * \pre type() == Value
	 */
	double value() const;

	bool operator==(const StatisticObject& rhs) const {
		return this->handle_ == rhs.handle_;
	}
	bool operator<(const StatisticObject& rhs) const {
		return this->handle_ < rhs.handle_;
	}
	std::size_t hash()  const;
	uint64      toRep() const;
	static StatisticObject fromRep(uint64);
private:
	struct I {
		typedef const void* ObjPtr;
		explicit I(Type t) : type(t) {}
		Type type;
	};
	struct V : I {
		V(double(*v)(ObjPtr)) : I(Potassco::Statistics_t::Value), value(v) {}
		double(*value)(ObjPtr);
	};
	struct A : I {
		A(uint32(*sz)(ObjPtr), StatisticObject(*a)(ObjPtr, uint32)) : I(Potassco::Statistics_t::Array), size(sz), at(a) {}
		uint32(*size)(ObjPtr);
		StatisticObject(*at)(ObjPtr, uint32);
	};
	struct M : I {
		M(uint32(*sz)(ObjPtr), StatisticObject(*a)(ObjPtr, const char*), const char* (*k)(ObjPtr, uint32)) : I(Potassco::Statistics_t::Map), size(sz), at(a), key(k) {}
		uint32(*size)(ObjPtr);
		StatisticObject(*at)(ObjPtr, const char*);
		const char* (*key)(ObjPtr, uint32);
	};
	static uint32 registerType(const I* vtab) {
		types_.push_back(vtab);
		return static_cast(types_.size() - 1);
	}
	template 
	static uint32 registerValue();
	template 
	static uint32 registerMap();
	template 
	static uint32 registerArray();
	StatisticObject(const void* obj, uint32 type);

	typedef PodVector::type RegVec;
	const void* self() const;
	const I*    tid()  const;
	static RegVec types_;
	uint64 handle_;
};

template 
uint32 StatisticObject::registerArray() {
	static struct Array_T : A {
		Array_T() : A(&Array_T::size, &Array_T::at) {}
		static uint32          size(ObjPtr obj)         { return toU32(static_cast(obj)->size()); }
		static StatisticObject at(ObjPtr obj, uint32 i) { return static_cast(obj)->at(i); }
	} vtab_s;
	static uint32 id = registerType(&vtab_s);
	return id;
}
template 
uint32 StatisticObject::registerMap() {
	static struct Map_T : M {
		Map_T() : M(&Map_T::size, &Map_T::at, &Map_T::key) {}
		static inline const T* cast(ObjPtr obj) { return static_cast(obj); }
		static uint32          size(ObjPtr obj) { return cast(obj)->size(); }
		static StatisticObject at(ObjPtr obj, const char* k) { return cast(obj)->at(k); }
		static const char*     key(ObjPtr obj, uint32 i) { return cast(obj)->key(i); }
	} vtab_s;
	static uint32 id = registerType(&vtab_s);
	return id;
}

template 
uint32 StatisticObject::registerValue() {
	static struct Value_T : V {
		Value_T() : V(&Value_T::value) {}
		static double value(ObjPtr obj) { return f(static_cast(obj)); }
	} vtab_s;
	static uint32 id = StatisticObject::registerType(&vtab_s);
	return id;
}
//! A type that maps string keys to statistic objects.
class StatsMap {
public:
	// StatisticObject
	uint32           size()              const { return sizeVec(keys_); }
	const char*      key(uint32 i)       const { return keys_.at(i).first; }
	StatisticObject  at(const char* k)   const;
	// Own interface
	const StatisticObject* find(const char* k) const;
	bool                   add(const char* k, const StatisticObject&);
	StatisticObject        toStats() const { return StatisticObject::map(this); }
private:
	typedef PodVector >::type MapType;
	MapType keys_;
};
//! An array of statistic objects.
template 
class StatsVec : private PodVector::type {
public:
	StatsVec() : own_(true) {}
	~StatsVec() {
		if (own_) { for (iterator it = this->begin(), end = this->end(); it != end; ++it) { delete *it; } }
	}
	typedef typename PodVector::type base_type;
	typedef typename base_type::const_iterator const_iterator;
	typedef typename base_type::iterator iterator;
	using base_type::size;
	using base_type::operator[];
	using base_type::begin;
	using base_type::end;
	void growTo(uint32 newSize) { if (newSize > size()) this->resize(newSize); }
	void reset() { for (iterator it = this->begin(), end = this->end(); it != end; ++it) { (*it)->reset(); } }
	StatisticObject at(uint32 i) const { return get_(this->base_type::at(i), bk_lib::detail::int2type()); }
	StatisticObject toStats()    const { return StatisticObject::array(this); }
	void acquire() { own_ = true; }
	void release() { own_ = false; }
private:
	static StatisticObject get_(const T* ptr, bk_lib::detail::int2type)   { return StatisticObject::map(ptr); }
	static StatisticObject get_(const T* ptr, bk_lib::detail::int2type) { return StatisticObject::array(ptr); }
	static StatisticObject get_(const T* ptr, bk_lib::detail::int2type) { return StatisticObject::value(ptr); }
	StatsVec(const StatsVec&);
	StatsVec& operator=(const StatsVec&);
	bool own_;
};

//! A class for traversing and querying statistics.
/*!
 * \ingroup clingo
 */
class ClaspStatistics : public Potassco::AbstractStatistics {
public:
	typedef Potassco::Statistics_t Type;
	ClaspStatistics();
	~ClaspStatistics();
	// Base interface
	virtual Key_t       root()          const;
	virtual Type        type(Key_t key) const;
	virtual size_t      size(Key_t key) const;
	virtual Key_t       at(Key_t arrK, size_t index) const;
	virtual const char* key(Key_t mapK, size_t i) const;
	virtual Key_t       get(Key_t mapK, const char* key) const;
	virtual double      value(Key_t key) const;

	// Register interface
	Key_t setRoot(const StatisticObject&);
	bool  removeStat(const StatisticObject&, bool recurse);
	bool  removeStat(Key_t k, bool recurse);
	void  update();
	StatisticObject findObject(Key_t root, const char* path, Key_t* track = 0) const;
	StatisticObject getObject(Key_t k) const;
private:
	ClaspStatistics(const ClaspStatistics&);
	ClaspStatistics& operator=(const ClaspStatistics&);
	Key_t root_;
	struct Impl;
	Impl*  impl_;
};

struct SolverStats;
struct JumpStats;
struct ExtendedStats;
struct ProblemStats;

//! Interface for visiting statistics.
/*!
 * \ingroup facade
 */
class StatsVisitor {
public:
	enum Operation { Enter, Leave } ;
	virtual ~StatsVisitor();
	// compound
	virtual bool visitGenerator(Operation op); // default: return true
	virtual bool visitThreads(Operation op);   // default: return true
	virtual bool visitTester(Operation op);    // default: return true
	virtual bool visitHccs(Operation op);      // default: return true

	// leafs
	virtual void visitThread(uint32, const SolverStats& stats);
	virtual void visitHcc(uint32, const ProblemStats& p, const SolverStats& s);
	virtual void visitLogicProgramStats(const Asp::LpStats& stats) = 0;
	virtual void visitProblemStats(const ProblemStats& stats) = 0;
	virtual void visitSolverStats(const SolverStats& stats) = 0;
};

}
#endif
clasp-3.2.2/libclasp/clasp/unfounded_check.h000066400000000000000000000277321304134206100210150ustar00rootroot00000000000000//
// Copyright (c) 2010, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_UNFOUNDED_CHECK_H_INCLUDED
#define CLASP_UNFOUNDED_CHECK_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
#include 
#include 
#include 
#include 
namespace Clasp {
class LoopFormula;

//! Clasp's default unfounded set checker.
/*!
 * \ingroup propagator
 * Searches for unfounded atoms by checking the positive dependency graph (PDG)
 *
 * Basic Idea:
 *  - For each (non-false) atom a, let source(a) be a body B in body(a) that provides an external support for a
 *    - If no such B exists, a must be false
 *  - If source(a) becomes false and a is not false:
 *    - Let Q = {};
 *    - add a to Q
 *    - For each B' s.th B' is not external to Q
 *      - add { a' | source(a') = B } to Q
 *  - Try to find new sources for all atoms a in Q
 */
class DefaultUnfoundedCheck : public PostPropagator {
public:
	typedef Asp::PrgDepGraph           DependencyGraph;
	typedef DependencyGraph::NodeId    NodeId;
	typedef DependencyGraph::BodyNode  BodyNode;
	typedef DependencyGraph::AtomNode  AtomNode;
	typedef const DependencyGraph*     ConstGraphPtr;
	typedef DependencyGraph*           GraphPtr;
	//! Defines the supported reasons for explaining assignments.
	enum ReasonStrategy {
		common_reason = LoopReason_t::Explicit, /*!< one reason for each unfounded set but one clause for each atom */
		only_reason   = LoopReason_t::Implicit, /*!< store only the reason but don't learn a nogood */
		distinct_reason,  /*!< distinct reason and clause for each unfounded atom */
		shared_reason,    /*!< one shared loop formula for each unfounded set */
		no_reason,        /*!< do no compute reasons for unfounded sets (only valid if learning is disabled!) */
	};

	explicit DefaultUnfoundedCheck(DependencyGraph& graph, ReasonStrategy st = common_reason);
	~DefaultUnfoundedCheck();

	ReasonStrategy reasonStrategy() const { return strategy_; }
	void           setReasonStrategy(ReasonStrategy rs);

	ConstGraphPtr graph() const { return graph_; }
	uint32        nodes() const { return static_cast(atoms_.size() + bodies_.size()); }

	// base interface
	uint32 priority() const { return uint32(priority_reserved_ufs); }
	bool   init(Solver&);
	void   reset();
	bool   propagateFixpoint(Solver& s, PostPropagator* ctx);
	bool   isModel(Solver& s);
	bool   valid(Solver& s);
	bool   simplify(Solver& s, bool);
	void   destroy(Solver* s, bool detach);
private:
	DefaultUnfoundedCheck(const DefaultUnfoundedCheck&);
	DefaultUnfoundedCheck& operator=(const DefaultUnfoundedCheck&);
	enum UfsType {
		ufs_none,
		ufs_poly,
		ufs_non_poly
	};
	enum WatchType {
		watch_source_false = 0,
		watch_head_false   = 1,
		watch_head_true    = 2,
		watch_subgoal_false= 3,
	};
	// data for each body
	struct BodyData {
		BodyData() : watches(0), picked(0) {}
		uint32 watches : 31; // how many atoms watch this body as source?
		uint32 picked  :  1; // flag used in computeReason()
		uint32 lower_or_ext; // unsourced preds or index of extended body
	};
	struct BodyPtr {
		BodyPtr(const BodyNode* n, uint32 i) : node(n), id(i) {}
		const BodyNode* node;
		uint32          id;
	};
	// data for extended bodies
	struct ExtData {
		ExtData(weight_t bound, uint32 preds) : lower(bound), slack(-bound) {
			for (uint32 i = 0; i != flagSize(preds); ++i) { flags[i] = 0; }
		}
		bool addToWs(uint32 idx, weight_t w) {
			const uint32 fIdx = (idx / 32);
			const uint32 m    = (1u << (idx & 31));
			assert((flags[fIdx] & m) == 0);
			flags[fIdx]      |= m;
			return (lower -= w) <= 0;
		}
		bool inWs(uint32 idx) const {
			const uint32 fIdx = (idx / 32);
			const uint32 m    = (1u << (idx & 31));
			return (flags[fIdx] & m) != 0;
		}
		void removeFromWs(uint32 idx, weight_t w) {
			if (inWs(idx)) {
				lower += w;
				flags[(idx / 32)] &= ~(uint32(1) << (idx & 31));
			}
		}
		static   uint32 flagSize(uint32 preds) { return (preds+31)/32; }
		weight_t lower;
		weight_t slack;
CLASP_WARNING_BEGIN_RELAXED
		uint32   flags[0];
CLASP_WARNING_END_RELAXED
	};
	// data for each atom
	struct AtomData {
		AtomData() : source(nill_source), todo(0), ufs(0), validS(0) {}
		// returns the body that is currently watched as possible source
		NodeId watch()     const   { return source; }
		// returns true if atom has currently a source, i.e. a body that can still define it
		bool   hasSource() const   { return validS; }
		// mark source as invalid but keep the watch
		void   markSourceInvalid() { validS = 0; }
		// restore validity of source
		void   resurrectSource()   { validS = 1; }
		// sets b as source for this atom
		void   setSource(NodeId b) {
			source = b;
			validS = 1;
		}
		static const uint32 nill_source = (uint32(1) << 29)-1;
		uint32 source : 29; // id of body currently watched as source
		uint32 todo   :  1; // in todo-queue?
		uint32 ufs    :  1; // in ufs-queue?
		uint32 validS :  1; // is source valid?
	};
	// Watch-structure used to update extended bodies affected by literal assignments
	struct ExtWatch {
		NodeId bodyId;
		uint32 data;
	};
	// Minimality checker for disjunctive logic programs.
	struct MinimalityCheck {
		typedef SolveParams::FwdCheck FwdCheck;
		explicit MinimalityCheck(const FwdCheck& fwd);
		bool     partialCheck(uint32 level);
		void     schedNext(uint32 level, bool ok);
		FwdCheck fwd;
		uint32   high;
		uint32   low;
		uint32   next;
		uint32   scc;
	};
	// -------------------------------------------------------------------------------------------
	// constraint interface
	PropResult propagate(Solver&, Literal, uint32& data) {
		uint32 index = data >> 2;
		uint32 type  = (data & 3u);
		if (type != watch_source_false || bodies_[index].watches) {
			invalidQ_.push_back(data);
		}
		return PropResult(true, true);
	}
	void reason(Solver& s, Literal, LitVec&);
	// -------------------------------------------------------------------------------------------
	// initialization
	BodyPtr getBody(NodeId bId) const { return BodyPtr(&graph_->getBody(bId), bId); }
	void    initBody(const BodyPtr& n);
	void    initExtBody(const BodyPtr& n);
	void    initSuccessors(const BodyPtr& n, weight_t lower);
	void    addWatch(Literal, uint32 data, WatchType type);
	void    addExtWatch(Literal p, const BodyPtr& n, uint32 data);
	struct  InitExtWatches {
		void operator()(Literal p, uint32 idx, bool ext) const {
			extra->slack += B->node->pred_weight(idx, ext);
			self->addExtWatch(~p, *B, (idx<<1)+uint32(ext));
			if (ext && !self->solver_->isFalse(p)) {
				extra->addToWs(idx, B->node->pred_weight(idx, true));
			}
		}
		DefaultUnfoundedCheck* self;
		const BodyPtr*         B;
		ExtData*               extra;
	};
	struct RemExtWatches {
		void operator()(Literal p, uint32, bool) const { s->removeWatch(~p, self); }
		Constraint* self;
		Solver*     s;
	};
	// -------------------------------------------------------------------------------------------
	// propagating source pointers
	void propagateSource();
	struct AddSource { // an atom in a body has a new source, check if body is now a valid source
		explicit AddSource(DefaultUnfoundedCheck* u) : self(u) {}
		// normal body
		void operator()(NodeId bId) const {
			BodyPtr n(self->getBody(bId));
			if (--self->bodies_[bId].lower_or_ext == 0 && !self->solver_->isFalse(n.node->lit)) { self->forwardSource(n); }
		}
		// extended body
		void operator()(NodeId bId, uint32 idx) const;
		DefaultUnfoundedCheck* self;
	};
	struct RemoveSource {// an atom in a body has lost its source, check if body is no longer a valid source
		explicit RemoveSource(DefaultUnfoundedCheck* u, bool add = false) : self(u), addTodo(add) {}
		// normal body
		void operator()(NodeId bId) const {
			if (++self->bodies_[bId].lower_or_ext == 1 && self->bodies_[bId].watches != 0) {
				self->forwardUnsource(self->getBody(bId), addTodo);
			}
		}
		// extended body
		void operator()(NodeId bId, uint32 idx) const;
		DefaultUnfoundedCheck* self;
		bool                   addTodo;
	};
	void setSource(NodeId atom, const BodyPtr& b);
	void removeSource(NodeId bodyId);
	void forwardSource(const BodyPtr& n);
	void forwardUnsource(const BodyPtr& n, bool add);
	void updateSource(AtomData& atom, const BodyPtr& n);
	// -------------------------------------------------------------------------------------------
	// finding & propagating unfounded sets
	void updateAssignment(Solver& s);
	bool findSource(NodeId atom);
	bool isValidSource(const BodyPtr&);
	void addUnsourced(const BodyPtr&);
	bool falsifyUfs(UfsType t);
	bool assertAtom(Literal a, UfsType t);
	void computeReason(UfsType t);
	void addIfReason(const BodyPtr&, uint32 uScc);
	bool isExternal(const BodyPtr&, weight_t& slack) const;
	void addDeltaReason(const BodyPtr& body, uint32 uScc);
	void addReasonLit(Literal);
	void createLoopFormula();
	struct  AddReasonLit {
		void operator()(Literal p, NodeId id, bool ext) const {
			if (self->solver_->isFalse(p) && slack >= 0) {
				slack -= node->pred_weight(id, ext);
				self->addReasonLit(p);
			}
		}
		DefaultUnfoundedCheck* self;
		const BodyNode*        node;
		mutable weight_t       slack;
	};
	UfsType findUfs(Solver& s, bool checkNonHcf);
	UfsType findNonHcfUfs(Solver& s);
	// -------------------------------------------------------------------------------------------
	bool pushTodo(NodeId at) { return (atoms_[at].todo == 0 && (todo_.push(at), atoms_[at].todo = 1) != 0); }
	bool pushUfs(NodeId at)  { return (atoms_[at].ufs  == 0 && (ufs_.push(at),  atoms_[at].ufs  = 1) != 0); }
	void resetTodo()         { while (!todo_.empty()){ atoms_[todo_.pop_ret()].todo = 0; } todo_.clear();   }
	void resetUfs()          { while (!ufs_.empty()) { atoms_[ufs_.pop_ret()].ufs   = 0; } ufs_.clear();    }
	// -------------------------------------------------------------------------------------------
	typedef PodVector::type       AtomVec;
	typedef PodVector::type       BodyVec;
	typedef PodVector::type       ExtVec;
	typedef PodVector::type       WatchVec;
	typedef PodQueue                IdQueue;
	typedef SingleOwnerPtr MiniPtr;
	// -------------------------------------------------------------------------------------------
	Solver*          solver_;      // my solver
	GraphPtr         graph_;       // PBADG
	MiniPtr          mini_;        // minimality checker (only for DLPs)
	AtomVec          atoms_;       // data for each atom
	BodyVec          bodies_;      // data for each body
	IdQueue          todo_;        // ids of atoms that recently lost their source
	IdQueue          ufs_;         // ids of atoms that are unfounded wrt the current assignment (limited to one scc)
	VarVec           invalidQ_;    // ids of invalid elements to be processed
	VarVec           sourceQ_;     // source-pointer propagation queue
	ExtVec           extended_;    // data for each extended body
	WatchVec         watches_;     // watches for handling choice-, cardinality- and weight rules
	VarVec           pickedExt_;   // extended bodies visited during reason computation
	LitVec           loopAtoms_;   // only used if strategy_ == shared_reason
	LitVec           activeClause_;// activeClause_[0] is the current unfounded atom
	LitVec*          reasons_;     // only used if strategy_ == only_reason. reasons_[v] reason why v is unfounded
	ConstraintInfo   info_;        // info on active clause
	ReasonStrategy   strategy_;    // what kind of reasons to compute?
};
}
#endif
clasp-3.2.2/libclasp/clasp/util/000077500000000000000000000000001304134206100164625ustar00rootroot00000000000000clasp-3.2.2/libclasp/clasp/util/atomic.h000066400000000000000000000073621304134206100201170ustar00rootroot00000000000000//
// Copyright (c) 2010-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_UTIL_ATOMIC_H_INCLUDED
#define CLASP_UTIL_ATOMIC_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif
/*!
 * \file
 * \brief Atomic types suitable for the active thread configuration.
 *
 * \note If libclasp is not configured with thread support,
 * types from this file are not necessarily atomic and must not be accessed
 * from multiple threads.
 */

namespace Clasp {
	//! Possible libclasp thread configurations.
	enum ThreadConfig {
		clasp_single_threaded = 0,
		clasp_multi_threaded  = 1
	};
	//! Type selector for selecting atomic type based on active thread configuration.
	template (WITH_THREADS)>
	struct Atomic_t;

	//! Selects a type that is not necessarily atomic and therefore not thread-safe.
	template 
	struct Atomic_t {
		typedef struct Plain {
			T operator=(T nv)   { return (val = nv); }
			operator T () const { return val; }
			operator T&()       { return val; }
			T compare_and_swap(T nVal, T eVal) {
				if (val == eVal) { val = nVal; } else { eVal = val; }
				return eVal;
			}
			T fetch_and_store(T nVal) {
				T p = val;
				val = nVal;
				return p;
			}
			T val;
		} type;
	};
}

#if WITH_THREADS
/*!
 * \def NS_ATOMIC
 * Namespace containing the underlying atomic type.
 * Can be either std or tbb depending on whether support for
 * C++11 threads is enabled.
 */
#if !defined(CLASP_USE_STD_THREAD)
#include 
#define NS_ATOMIC tbb
#else
#include 
#define NS_ATOMIC std
#endif
namespace Clasp { namespace mt {
	//! Atomic type with sequentially consistent loads and stores.
	template 
	class atomic : private NS_ATOMIC::atomic {
	public:
		typedef NS_ATOMIC::atomic native_type;
		native_type& native() { return *this; }

		T operator=(T value) { return native_type::operator=(value); }
			operator T() const { return native_type::operator T(); }

		using native_type::operator+=;
		using native_type::operator-=;
		using native_type::operator++;
		using native_type::operator--;
#if defined(CLASP_USE_STD_THREAD)
		T compare_and_swap(T new_value, T comparand) {
			native_type::compare_exchange_strong(comparand, new_value);
			return comparand;
		}
		T fetch_and_store(T value) { return native_type::exchange(value); }
		T fetch_and_or(T value)    { return native_type::fetch_or(value); }
		T fetch_and_and(T value)   { return native_type::fetch_and(value); }
#else
		using native_type::compare_and_swap;
		using native_type::fetch_and_store;
		T fetch_and_or(T value) {
			T x;
			do { x = this->load(); } while (this->compare_and_swap(x|value, x) != x);
			return x;
		}
		T fetch_and_and(T value) {
			T x;
			do { x = this->load(); } while (this->compare_and_swap(x&value, x) != x);
			return x;
		}
#endif
	};
}}
namespace Clasp {
	//! Selects an atomic ype suitable for multi-threading.
	template 
	struct Atomic_t {
		typedef Clasp::mt::atomic type;
	};
}
#undef NS_ATOMIC
#endif
#endif
clasp-3.2.2/libclasp/clasp/util/hash_map.h000066400000000000000000000052061304134206100204160ustar00rootroot00000000000000// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_HASH_MAP_H_INCLUDED
#define CLASP_HASH_MAP_H_INCLUDED
#include 
#include 
#if (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER > 1500) || (defined(_LIBCPP_VERSION))
#include 
#include 
#define HASH_NS std
#else
#if defined(_MSC_VER)
#include 
#include 
#else
#include 
#include 
#endif
#define HASH_NS std::tr1
#endif

namespace Clasp {
	//! Selector for a hash (multi) map.
	/*!
	 * \tparam K Key type of the hash map.
	 * \tparam V Value type of the hash map.
	 * \tparam H Hash function for hashing keys.
	 * \tparam E Comparison function for checking equality of keys.
	 * \note Can be replaced with std::unordered_map/unordered_multimap once we switch to C++11
	 */
	template, class E = std::equal_to, class A = std::allocator< std::pair > >
	struct HashMap_t { 
		typedef HASH_NS::unordered_map      map_type; 
		typedef HASH_NS::unordered_multimap multi_map_type; 
	};
	//! Selector for a hash (multi) set.
	template, class E = std::equal_to, class A = std::allocator< K > >
	struct HashSet_t { 
		typedef HASH_NS::unordered_set      set_type; 
		typedef HASH_NS::unordered_multiset multi_set_type; 
	};

//! Hasher for strings.
/*!
 * \see http://research.microsoft.com/en-us/people/palarson/
 */
struct StrHash {
	std::size_t operator()(const char* str) const {
		std::size_t h = 0;
		for (const char* s = str; *s; ++s) {
			h = h * 101 + static_cast(*s);
		}
		return h;
	}
};
//! Comparison function for C-strings to be used with hash map/set.
struct StrEq {
	bool operator()(const char* lhs, const char* rhs) const { return std::strcmp(lhs, rhs) == 0; }
};

}
#undef HASH_NS
#endif
clasp-3.2.2/libclasp/clasp/util/indexed_priority_queue.h000066400000000000000000000123251304134206100234230ustar00rootroot00000000000000// 
// Copyright (c) 2006-2007, Benjamin Kaufmann
// 
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef BK_LIB_INDEXED_PRIORITY_QUEUE_H_INCLUDED
#define BK_LIB_INDEXED_PRIORITY_QUEUE_H_INCLUDED

#ifdef _MSC_VER
#pragma warning (disable : 4267)
#pragma warning (disable : 4244)
#pragma once
#endif

#include 
#include "pod_vector.h"
namespace bk_lib { namespace detail {

typedef std::size_t key_type;
const key_type noKey = static_cast(-1);
inline key_type heap_root() { return 0; }
inline key_type heap_left(std::size_t i) { return (i<<1)+1; }
inline key_type heap_right(std::size_t i) { return (i+1)<<1; }
inline key_type heap_parent(std::size_t i) { return (i-1)>>1; }

}

// Note: Uses a Max-Heap!
template <
	class Cmp // sort-predicate - if Cmp(k1, k2) == true, n1 has higher priority than n2
>
class indexed_priority_queue {
public:
	typedef detail::key_type key_type;
	typedef pod_vector index_container_type;
	typedef std::size_t     size_type;
	typedef Cmp             compare_type;
	
	explicit indexed_priority_queue( const compare_type& c = compare_type() );
	indexed_priority_queue(const indexed_priority_queue& other);
	
	indexed_priority_queue& operator=(const indexed_priority_queue& other) {
		indices_  = other.indices_;
		heap_     = other.heap_;
		compare_  = other.compare_;
		return *this;
	}

	const compare_type& key_compare() const {
		return compare_;
	}

	bool empty() const {
		return heap_.empty();
	}
	void reserve(size_type n) {
		indices_.reserve(n);
	}

	void push(key_type k) {
		assert( !is_in_queue(k) );
		if ((key_type)indices_.size() <= k) {
			if (indices_.capacity() <= k) { indices_.reserve(((k+1)*3)>>1); }
			indices_.resize(k+1, detail::noKey);
		}
		indices_[k] = (key_type)heap_.size();
		heap_.push_back(k);
		siftup(indices_[k]);
	}

	void pop() {
		assert(!empty());
		key_type x  = heap_[0];
		heap_[0]    = heap_.back();
		indices_[heap_[0]] = 0;
		indices_[x]   = detail::noKey;
		heap_.pop_back();
		if (heap_.size() > 1) {siftdown(0);}
	}

	void clear() {
		heap_.clear();
		indices_.clear();
	}

	template 
	void swapMem(indexed_priority_queue& o) {
		clear();
		o.clear();
		heap_.swap(o.heap_);
		indices_.swap(o.indices_);
	}
	size_type size( ) const {
		return heap_.size();
	}

	key_type top() const {
		assert(!empty());
		return heap_[0];
	}
	
	void update(key_type k) {
		if (!is_in_queue(k)) {
			push(k);
		}
		else {
			siftup(indices_[k]);
			siftdown(indices_[k]);
		}
	}
	// call if priority of k has increased
	void increase(key_type k) {
		assert(is_in_queue(k));
		siftup(indices_[k]);
	}
	// call if priority of k has decreased
	void decrease(key_type k) {
		assert(is_in_queue(k));
		siftdown(indices_[k]);
	}

	bool is_in_queue(key_type k) const {
		assert(valid_key(k));
		return k < (key_type)indices_.size() && indices_[k] != detail::noKey;
	}
	
	void remove(key_type k) {
		if (is_in_queue(k)) {
			key_type kInHeap  = indices_[k];
			heap_[kInHeap]    = heap_.back();
			indices_[heap_.back()]  = kInHeap;
			heap_.pop_back();
			indices_[k] = detail::noKey;
			if (heap_.size() > 1 && kInHeap != (key_type)heap_.size()) {
				siftup(kInHeap);
				siftdown(kInHeap);
			}
		}
	}
private:
	template 
	friend class indexed_priority_queue;
	bool valid_key(key_type k) const {
		return k != detail::noKey;
	}
	index_container_type  indices_;
	index_container_type  heap_;
	compare_type          compare_;
	void siftup(key_type n) {
		using namespace detail;
		key_type x = heap_[n];
		key_type p = heap_parent(n);
		while (n != 0 && compare_(x, heap_[p])){
			heap_[n] = heap_[p];
			indices_[heap_[n]] = n;
			n = p;
			p = heap_parent(n);
		}
		heap_[n] = x;
		indices_[x] = n;
	}

	void siftdown(key_type n) {
		using namespace detail;
		key_type x = heap_[n];
		while (heap_left(n) < (key_type)heap_.size()){
			key_type child = smaller_child(n);
			if (!compare_(heap_[child], x)) {
				break;
			}
			heap_[n] = heap_[child];
			indices_[heap_[n]] = n;
			n = child;
		}
		heap_[n] = x;
		indices_[x] = n;
	}

	key_type smaller_child(size_type n) const {
		using namespace detail;
		return heap_right(n) < (key_type)heap_.size() && compare_(heap_[heap_right(n)], heap_[heap_left(n)])
			? heap_right(n)
			: heap_left(n);
	}
};

template 
indexed_priority_queue::indexed_priority_queue( const compare_type& c ) 
	: indices_()
	, heap_()
	, compare_(c) {
}

template 
indexed_priority_queue::indexed_priority_queue(const indexed_priority_queue& other)
	: indices_(other.indices_) 
	, heap_(other.heap_)
	, compare_(other.compare_) {
}

}
#endif
clasp-3.2.2/libclasp/clasp/util/left_right_sequence.h000066400000000000000000000277401304134206100226640ustar00rootroot00000000000000// 
// Copyright (c) 2010, Benjamin Kaufmann
// 
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef BK_LIB_LEFT_RIGHT_SEQUENCE_INCLUDED
#define BK_LIB_LEFT_RIGHT_SEQUENCE_INCLUDED
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning (disable : 4200)
#endif
#include "type_manip.h"
#include 
#include 
#include 
namespace bk_lib { namespace detail {

// base class for left_right_sequence
// see below
template 
class left_right_rep {
public:	
	typedef L left_type;
	typedef R right_type;
	typedef unsigned int size_type;
	typedef L*       left_iterator;
	typedef const L* const_left_iterator;
	typedef std::reverse_iterator       right_iterator;
	typedef std::reverse_iterator const_right_iterator;

	typedef typename bk_lib::detail::align_of::type  left_align_type;
	typedef typename bk_lib::detail::align_of::type right_align_type;
///@cond
	typedef typename bk_lib::detail::if_then_else<
		sizeof(left_type) >= sizeof(right_type), 
		left_type,
		right_type>::type max_type;
	typedef typename bk_lib::detail::if_then_else<
		sizeof(left_align_type) >= sizeof(right_align_type), 
		left_align_type,
		right_align_type>::type align_type;
///@endcond
	left_right_rep() : buf_(0), cap_(0), free_(0), left_(0), right_(0) {}
	
	bool      empty()         const { return left_ == 0 && right_ == cap_; }
	size_type left_size()     const { return left_/sizeof(left_type); }
	size_type right_size()    const { return (cap_-right_)/sizeof(right_type); }
	size_type size()          const { return left_size() + right_size(); }
	size_type left_capacity() const { return (cap_ / sizeof(left_type)); }
	size_type right_capacity()const { return (cap_ / sizeof(right_type)); }
	const_left_iterator  left_begin() const { return const_left_iterator(reinterpret_cast(begin())); }
	const_left_iterator  left_end()   const { return const_left_iterator(reinterpret_cast(buf_+left_)); }
	      left_iterator  left_begin()       { return left_iterator(reinterpret_cast(begin())); }
	      left_iterator  left_end()         { return left_iterator(reinterpret_cast(buf_+left_)); }
	const_right_iterator right_begin()const { return const_right_iterator(reinterpret_cast(end())); }
	const_right_iterator right_end()  const { return const_right_iterator(reinterpret_cast(buf_+right_)); }
	      right_iterator right_begin()      { return right_iterator(reinterpret_cast(end())); }
	      right_iterator right_end()        { return right_iterator(reinterpret_cast(buf_+right_)); }
	const left_type&     left(size_type i)const { return *(left_begin()+i); }
	      left_type&     left(size_type i)      { return *(left_begin()+i); }

	void clear(bool releaseMem = false) {
		if (releaseMem) {
			release();
			buf_  = 0; 
			cap_  = 0;
			free_ = 0;
		}
		left_ = 0;
		right_= cap_;
	}
	void push_left(const left_type& x) {
		if ((left_ + sizeof(left_type)) > right_) {
			realloc();
		}
		new (left())left_type(x);
		left_ += sizeof(left_type);
	}

	void push_right(const right_type& x) {
		if ( (left_ + sizeof(right_type)) > right_ ) {
			realloc();
		}
		right_ -= sizeof(right_type);
		new (right()) right_type(x);
	}
	void pop_left() {
		assert(left_size() != 0);
		left_ -= sizeof(left_type);
	}
	void pop_right() {
		assert(right_size() != 0);
		right_ += sizeof(right_type);
	}

	void erase_left(left_iterator it) {
		if (it != left_end()) {
			left_iterator x = it++;
			std::memmove(x, it, (left_end()-it)*sizeof(left_type));
			left_ -= sizeof(left_type);
		}
	}
	void erase_left_unordered(left_iterator it) {
		if (it != left_end()) {
			left_ -= sizeof(left_type);
			*it    = *reinterpret_cast(left());
		}
	}
	void erase_right(right_iterator it) {
		if (it != right_end()) {
			right_type* r = (++it).base();
			right_type* b = reinterpret_cast(right());
			assert(r >= b);
			std::memmove(b+1, b, (r-b)*sizeof(right_type));
			right_ += sizeof(right_type);
		}
	}
	void erase_right_unordered(right_iterator it) {
		if (it != right_end()) {
			*it    = *reinterpret_cast(right());
			right_+= sizeof(right_type);
		}
	}
	void shrink_left(left_iterator it) {
		left_ = static_cast((it - left_begin())*sizeof(left_type));
	}
	void shrink_right(right_iterator it) {
		buf_type* x = reinterpret_cast(it.base());
		right_ = static_cast(x - begin());
	}
	enum { block_size      = ((sizeof(max_type)+(sizeof(align_type)-1)) / sizeof(align_type)) * sizeof(align_type) };
protected:
	left_right_rep(const left_right_rep&) { }
	left_right_rep& operator=(const left_right_rep&) { return *this; }
	typedef unsigned char buf_type;
	buf_type*       begin()      { return buf_; }
	const buf_type* begin()const { return buf_; }
	buf_type*       end()        { return buf_+cap_; }
	const buf_type* end()  const { return buf_+cap_; }
	buf_type*       left()       { return buf_+left_; }
	buf_type*       right()      { return buf_+right_; }
	size_type    capacity()const { return cap_ / block_size; }
	size_type    raw_size()const { return left_ + (cap_-right_); }
	void release()               { if (free_ != 0) { ::operator delete(buf_); } }
	void realloc();
	buf_type* buf_;
	size_type cap_ : 31;
	size_type free_:  1;
	size_type left_;
	size_type right_;
};

template 
void left_right_rep::realloc() {
	size_type new_cap = ((capacity()*3)>>1) * block_size;
	size_type min_cap = 4 * block_size;
	if (new_cap < min_cap) new_cap = min_cap;
	buf_type* temp = (buf_type*)::operator new(new_cap*sizeof(buf_type));
	// copy left
	std::memcpy(temp, begin(), left_size()*sizeof(L));
	// copy right
	size_type r = cap_ - right_;
	std::memcpy(temp+(new_cap-r), right(), right_size() * sizeof(R));
	// swap
	release();
	buf_   = temp;
	cap_   = new_cap;
	free_  = 1;
	right_ = new_cap - r;
}

// always store sequence in heap-allocated buffer
template 
struct no_inline_buffer : public left_right_rep {
	typedef typename left_right_rep::buf_type buf_type;
	enum { inline_raw_cap = 0 };
	buf_type* extra()           { return 0; }
};

// store small sequences directly inside of object
template 
struct with_inline_buffer : public left_right_rep {
	typedef typename left_right_rep::buf_type   buf_type;
	typedef typename left_right_rep::align_type align_type;
	enum { inline_raw_cap = cap };
	buf_type* extra()           { return rep_.mem; }
	union X {
		align_type align;
		buf_type   mem[inline_raw_cap];
	} rep_;
};

// select proper base class for left_right_sequence based
// on parameter i
template 
struct select_base {
private:
	typedef unsigned char        buf_type;
	typedef left_right_rep base_type;
	typedef typename base_type::size_type size_type;
	typedef typename base_type::align_type align_type;
	typedef no_inline_buffer no_extra_type;
	typedef with_inline_buffer with_extra_type;
	
	enum { padding         = sizeof(with_extra_type) - (sizeof(no_extra_type)+sizeof(align_type)) };
	enum { size_with_pad   = sizeof(no_extra_type) + padding };
	enum { store_extra     = (i > size_with_pad) && (i - size_with_pad) >= base_type::block_size };
	enum { inline_raw_cap  = store_extra ? ((i - size_with_pad)/base_type::block_size)*base_type::block_size : 0 };
public:
	typedef typename if_then_else<
		store_extra!=0, 
		with_inline_buffer,
		no_inline_buffer >::type type;
};


} // bk_lib::detail

//! Stores two sequences in one contiguous memory block
/*!
 * The left sequence grows from left to right, while the
 * right sequence grows from right to left. On overlap, the
 * memory block is automatically extended.
 *
 * \param L value type of left sequence
 * \param R value type of right sequence
 * \param i max size on stack
 * \pre L and R can be copied with memcpy (i.e. have trivial copy constructor and trivial destructor)
 */
template 
class left_right_sequence : public bk_lib::detail::select_base::type {
public:
	typedef typename bk_lib::detail::select_base::type base_type;
	typedef typename base_type::left_type  left_type;
	typedef typename base_type::right_type right_type;
	typedef typename base_type::size_type  size_type;
	typedef typename base_type::align_type align_type;
	typedef typename base_type::max_type   max_type;
	typedef typename base_type::buf_type   buf_type;

	typedef typename base_type::left_iterator       left_iterator;
	typedef typename base_type::const_left_iterator const_left_iterator;
	typedef typename base_type::right_iterator       right_iterator;
	typedef typename base_type::const_right_iterator const_right_iterator;
	    
	left_right_sequence() {
		this->buf_  = this->extra();
		this->cap_  = base_type::inline_raw_cap;
		this->free_ = 0;
		this->left_ = 0;
		this->right_= base_type::inline_raw_cap;
	}
	left_right_sequence(const left_right_sequence& other);
	~left_right_sequence() { this->release(); }
	left_right_sequence& operator=(const left_right_sequence&);

	void try_shrink() {
		if (this->raw_size() <= base_type::inline_raw_cap && this->buf_ != this->extra()) {
			buf_type* e = this->extra();
			size_type c = base_type::inline_raw_cap;
			size_type r = c - (this->right_size()*sizeof(right_type));
			std::memcpy(e,   this->begin(), this->left_size() * sizeof(left_type));
			std::memcpy(e+r, this->right(), this->right_size()* sizeof(right_type));
			this->release();
			this->buf_  = e;
			this->cap_  = c;
			this->free_ = 0;
			this->right_= r;
		}
	}
	void move(left_right_sequence& other) {
		this->clear(true);
		if (other.raw_size() <= base_type::inline_raw_cap) {
			copy(other);
			other.clear(true);
		}
		else {
			this->buf_   = other.buf_;
			this->cap_   = other.cap_;
			this->free_  = other.free_;
			this->left_  = other.left_;
			this->right_ = other.right_;
			other.buf_  = other.extra();
			other.cap_  = base_type::inline_raw_cap;
			other.free_ = 0;
			other.left_ = 0;
			other.right_= base_type::inline_raw_cap;
		}
	}
private:
	void      copy(const left_right_sequence&);
};

template 
void left_right_sequence::copy(const left_right_sequence& other) {
	size_type os = other.raw_size();
	if ( os <= base_type::inline_raw_cap ) {
		this->buf_ = this->extra();
		this->cap_ = base_type::inline_raw_cap;
		this->free_= 0;
	}
	else {
		os         = ((os + (base_type::block_size-1)) / base_type::block_size) * base_type::block_size;
		this->buf_ = (buf_type*)::operator new(os*sizeof(buf_type));
		this->cap_ = os;
		this->free_= 1;
	}
	this->left_ = other.left_;
	this->right_= this->cap_ - (other.right_size()*sizeof(right_type));
	std::memcpy(this->begin(), other.begin(), other.left_size()*sizeof(left_type));
	std::memcpy(this->right(), const_cast(other).right(), other.right_size()*sizeof(right_type));
}

template 
left_right_sequence::left_right_sequence(const left_right_sequence& other) : base_type(other) {
	copy(other);
}

template 
left_right_sequence& left_right_sequence::operator=(const left_right_sequence& other) {
	if (this != &other) {
		this->release();
		copy(other);
	}
	return *this;
}


} // namespace bk_lib


#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif

clasp-3.2.2/libclasp/clasp/util/misc_types.h000066400000000000000000000362101304134206100210140ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_UTIL_MISC_TYPES_H_INCLUDED
#define CLASP_UTIL_MISC_TYPES_H_INCLUDED

#include 
#include     // std::pair
#include  // std::unary_function, std::binary_function
#include 
#include 
/*!
 * \file
 * \brief Some utility types and functions.
 */
namespace Clasp {

/*!
 * \defgroup misc Miscellaneous
 * \brief Miscellaneous and Internal Stuff not specific to clasp.
 */
//@{

template 
inline T bit_mask(unsigned n) { return static_cast(1) << n; }
//! Returns whether bit n is set in x.
template 
inline bool test_bit(T x, unsigned n) { return (x & bit_mask(n)) != 0; }
template 
inline T clear_bit(T x, unsigned n)   { return x & ~bit_mask(n); }
template 
inline T set_bit(T x, unsigned n)     { return x | bit_mask(n); }
template 
inline T toggle_bit(T x, unsigned n)  { return x ^ bit_mask(n); }
template 
inline T& store_clear_bit(T& x, unsigned n)  { return (x &= ~bit_mask(n)); }
template 
inline T& store_set_bit(T& x, unsigned n)  { return (x |= bit_mask(n)); }
template 
inline T& store_toggle_bit(T& x, unsigned n)  { return (x ^= bit_mask(n)); }
template 
inline T right_most_bit(T x) { return x & (-x); }

inline uint32 log2(uint32 x) {
	uint32 ln = 0;
	if (x & 0xFFFF0000u) { x >>= 16; ln |= 16; }
	if (x & 0xFF00u    ) { x >>=  8; ln |=  8; }
	if (x & 0xF0u      ) { x >>=  4; ln |=  4; }
	if (x & 0xCu       ) { x >>=  2; ln |=  2; }
	if (x & 0x2u       ) {/*x>>=1*/; ln |=  1; }
	return ln;
}

//! Computes n choose k.
inline uint64 choose(unsigned n, unsigned k) {
	if (k == 0) return 1;
	if (k > n) return 0;
	if (2 * k > n) { return choose(n, n-k);}
	uint64 res = n;
	for (unsigned i = 2 ; i <= k; ++i) {
		res *= (n + 1 - i);
		res /= i;
	}
	return res;
}
inline double ratio(uint64 x, uint64 y)   { return y ? static_cast(x) / static_cast(y) : 0; }
inline double percent(uint64 x, uint64 y) {	return ratio(x, y) * 100.0; }

//! A very simple but fast Pseudo-random number generator.
/*!
 * \note This class is a replacement for the standard rand-function. It is provided
 * in order to get reproducible random numbers among different compilers.
 */
class RNG {
public:
	explicit RNG(uint32 seed = 1) : seed_(seed) {}

	//! Sets the starting point for random-number generation.
	/*!
	 * The function sets the starting point for generating a series of pseudorandom integers.
	 * To reinitialize the generator, use 1 as the seed argument. Any other value for seed
	 * sets the generator to a random starting point. Calling rand() before any call to srand()
	 * generates the same sequence as calling srand() with seed passed as 1.
	 */
	void srand(uint32 seed) { seed_ = seed; }

	//! Generates a pseudorandom number
	/*!
	 * The rand function returns a pseudorandom integer in the range 0 to 32767
	 * Use the srand function to seed the pseudorandom-number generator before calling rand.
	 */
	uint32 rand() {
		return( ((seed_ = seed_ * 214013L + 2531011L) >> 16) & 0x7fff );
	}

	//! random floating point number in the range [0, 1.0)
	double drand() {
		return this->rand()/static_cast(0x8000u);
	}

	//! random number in the range [0, max)
	unsigned irand(unsigned max) {
		return static_cast(drand() * max);
	}

	uint32 seed() const { return seed_; }

	uint32 operator()(unsigned max) { return irand(max); }
	uint32 operator()()             { return rand(); }
private:
	uint32 seed_;
};

//! Updates the given exponential moving average with the given sample.
/*!
 * Computes ema = currentEma + ((double(sample) - currentEma)*alpha);
 */
template 
inline double exponentialMovingAverage(double currentEma, T sample, double alpha) {
	return (static_cast(sample) * alpha) + (currentEma * (1.0 - alpha));
}
//! Updates the given moving average with the given sample.
template 
inline double cumulativeMovingAverage(double currentAvg, T sample, uint64 numSeen) {
	return (static_cast(sample) + (currentAvg * numSeen)) / static_cast(numSeen + 1);
}

//! An unary operator function that calls p->destroy().
struct DestroyObject {
	template  void operator()(T* p) const { if (p) p->destroy(); }
};
//! An unary operator function that calls delete p.
struct DeleteObject {
	template  void operator()(T* p) const { delete p; }
};
//! An unary operator function that calls p->release().
struct ReleaseObject {
	template  void operator()(T* p) const { if (p) p->release(); }
};
//! An unary operator function that returns whether its argument is 0.
struct IsNull {
	template  bool operator()(const T& p) const { return p == 0; }
};

//! A predicate that checks whether a std::pair contains a certain value.
template 
struct PairContains {
	PairContains(const T& p) : p_(p) {}
	bool operator()(const std::pair& s) const {
		return s.first == p_ || s.second == p_;
	}
	T p_;
};

//! Removes from the container c the first occurrence of a value v for which p(v) returns true.
/*!
 * \pre C is a container that provides back() and pop_back()
 * \note Removal is implemented by replacing the element to be removed with
 * the back()-element followed by a call to pop_back().
 */
template 
void remove_first_if(C& cont, const P& p) {
	for (typename C::iterator it = cont.begin(), end = cont.end(); it != end; ++it) {
		if (p(*it)) {
			*it = cont.back();
			cont.pop_back();
			return;
		}
	}
}

//! An unary operator function that simply returns its argument.
template 
struct identity : std::unary_function{
	T&        operator()(T& x)      const { return x; }
	const T&  operator()(const T& x)  const { return x; }
};


//! An unary operator function that returns the first value of a std::pair.
template 
struct select1st : std::unary_function {
	typename P::first_type& operator()(P& x) const {
		return x.first;
	}
	const typename P::first_type& operator()(const P& x) const {
		return x.first;
	}
};

//! An unary operator function that returns the second value of a std::pair.
template 
struct select2nd : std::unary_function {
	typename P::second_type& operator()(P& x) const {
		return x.second;
	}
	const typename P::second_type& operator()(const P& x) const {
		return x.second;
	}
};

//! An unary operator function that returns Op1(Op2(x)).
template 
struct compose_1 : public std::unary_function<
                            typename OP2::argument_type,
                            typename OP1::result_type> {
	compose_1(const OP1& op1, const OP2& op2)
		: op1_(op1)
		, op2_(op2) {}

	typename OP1::result_type operator()(const typename OP2::argument_type& x) const {
		return op1_(op2_(x));
	}
protected:
	OP1 op1_;
	OP2 op2_;
};

/*!
 * A template helper function used to construct objects of type compose_1,
 * where the component types are based on the data types passed as parameters.
 */
template 
inline compose_1 compose1(const OP1& op1, const OP2& op2) {
	return compose_1(op1, op2);
}

//! An unary operator function that returns OP1(OP2(x), OP3(x)).
template 
struct compose_2_1 : public std::unary_function<
                            typename OP2::argument_type,
                            typename OP1::result_type> {
	compose_2_1(const OP1& op1, const OP2& op2, const OP3& op3)
		: op1_(op1)
		, op2_(op2)
		, op3_(op3) {}

	typename OP1::result_type operator()(const typename OP2::argument_type& x) const {
		return op1_(op2_(x), op3_(x));
	}
protected:
	OP1 op1_;
	OP2 op2_;
	OP3 op3_;
};

/*!
 * A template helper function used to construct objects of type compose_2_1,
 * where the component types are based on the data types passed as parameters.
 */
template 
inline compose_2_1 compose2(const OP1& op1, const OP2& op2, const OP3& op3) {
	return compose_2_1(op1, op2, op3);
}


//! A binary operator function that returns OP1(OP2(x), OP3(y)).
template 
struct compose_2_2 : public std::binary_function<
                            typename OP2::argument_type,
                            typename OP3::argument_type,
                            typename OP1::result_type> {
	compose_2_2(const OP1& op1 = OP1(), const OP2& op2 = OP2(), const OP3& op3 = OP3())
		: op1_(op1)
		, op2_(op2)
		, op3_(op3) {}

	typename OP1::result_type operator()(const typename OP2::argument_type& x, const typename OP3::argument_type& y) const {
		return op1_(op2_(x), op3_(y));
	}
protected:
	OP1 op1_;
	OP2 op2_;
	OP3 op3_;
};

/*!
 * A template helper function used to construct objects of type compose_2_2,
 * where the component types are based on the data types passed as parameters.
 */
template 
inline compose_2_2 compose22(const OP1& op1, const OP2& op2, const OP3& op3) {
	return compose_2_2(op1, op2, op3);
}

//! TODO: replace with std::is_sorted once we switch to C++11
template 
bool isSorted(ForwardIterator first, ForwardIterator last, Compare comp) {
	if (first != last) {
		for (ForwardIterator n = first; ++n != last; ++first) {
			if (comp(*n, *first)) return false;
		}
	}
	return true;
}

//! Possible ownership operations.
struct Ownership_t {
	enum Type { Retain = 0, Acquire = 1 };
};
//! A smart pointer that optionally owns its pointee.
template 
class SingleOwnerPtr {
public:
	SingleOwnerPtr() : ptr_(0) {}
	explicit SingleOwnerPtr(T* ptr, Ownership_t::Type t = Ownership_t::Acquire)
		: ptr_(uintp(ptr) | uintp(t == Ownership_t::Acquire)) {
	}
	~SingleOwnerPtr()       { *this = 0; }
	bool is_owner()   const { return test_bit(ptr_, 0); }
	T*   get()        const { return (T*)clear_bit(ptr_, 0); }
	T&   operator*()  const { return *get(); }
	T*   operator->() const { return  get(); }
	SingleOwnerPtr& operator=(T* ptr) { reset(ptr); return *this; }
	void swap(SingleOwnerPtr& o) { std::swap(ptr_, o.ptr_); }
	T*   release()               { store_clear_bit(ptr_, 0); return get();  }
	T*   acquire()               { store_set_bit(ptr_, 0);   return get();  }
	void reset(T* x)             {
		if (x != get() && is_owner()) { D deleter; deleter(release()); }
		ptr_ = set_bit(uintp(x),0);
	}
private:
	SingleOwnerPtr(const SingleOwnerPtr&);
	SingleOwnerPtr& operator=(const SingleOwnerPtr&);
	uintp ptr_;
};
template 
class FlaggedPtr {
public:
	FlaggedPtr() : ptr_(0) {}
	explicit FlaggedPtr(T* ptr, bool sf = false) : ptr_(uintp(ptr)) { if (sf) flag(); }
	bool flagged()    const  { return test_bit(ptr_, 0); }
	T*   get()        const  { return (T*)clear_bit(ptr_, 0); }
	T&   operator*()  const  { return *get(); }
	T*   operator->() const  { return  get(); }
	void swap(FlaggedPtr& o) { std::swap(ptr_, o.ptr_); }
	void flag()   { store_set_bit(ptr_, 0); }
	void unflag() { store_clear_bit(ptr_, 0); }
private:
	uintp ptr_;
};
template 
inline FlaggedPtr make_flagged(T* ptr, bool setFlag) { return FlaggedPtr(ptr, setFlag); }

//! A (numerical) range represented by a low and a high value.
template 
struct Range {
	Range(T x, T y) : lo(x), hi(y) { if (x > y)  { hi = x;  lo = y; } }
	T clamp(T val) const {
		if (val < lo) return lo;
		if (val > hi) return hi;
		return val;
	}
	T lo;
	T hi;
};
template 
inline bool operator==(const Range& lhs, const Range& rhs) {
	return lhs.lo == rhs.lo && lhs.hi == rhs.hi;
}
//! An iterator type for iterating over a range of numerical values.
template 
struct num_iterator : std::iterator {
	explicit num_iterator(const T& val) : val_(val) {}
	typedef typename std::iterator::value_type      value_type;
	typedef typename std::iterator::difference_type difference_type;
	bool operator==(const num_iterator& rhs) const { return val_ == rhs.val_; }
	bool operator!=(const num_iterator& rhs) const { return val_ != rhs.val_; }
	bool operator<=(const num_iterator& rhs) const { return val_ <= rhs.val_; }
	bool operator< (const num_iterator& rhs) const { return val_  < rhs.val_; }
	bool operator>=(const num_iterator& rhs) const { return val_ >= rhs.val_; }
	bool operator> (const num_iterator& rhs) const { return val_  > rhs.val_; }
	value_type    operator*()  const { return val_; }
	T const*      operator->() const { return &val_; }
	num_iterator& operator++()       { ++val_; return *this; }
	num_iterator& operator++(int)    { num_iterator t(*this); ++*this; return t; }
	num_iterator& operator--()       { --val_; return *this; }
	num_iterator& operator--(int)    { num_iterator t(*this); --*this; return t; }
	num_iterator& operator+=(difference_type n) { val_ += n; return *this; }
	num_iterator& operator-=(difference_type n) { val_ -= n; return *this; }
	num_iterator  operator+(difference_type n) const { return num_iterator(static_cast(val_ + n)); }
	num_iterator  operator-(difference_type n) const { return num_iterator(static_cast(val_ - n)); }
	value_type    operator[](difference_type n)const { return val_ + n; }
	friend num_iterator operator+(difference_type n, num_iterator it) { return num_iterator(it.val_ + n); }
private:
	T val_;
};
//@}

//! Base class for library events.
struct Event {
	//! Set of known event sources.
	enum Subsystem { subsystem_facade = 0, subsystem_load = 1, subsystem_prepare = 2, subsystem_solve = 3 };
	//! Possible verbosity levels.
	enum Verbosity { verbosity_quiet  = 0, verbosity_low  = 1, verbosity_high    = 2, verbosity_max   = 3 };
	explicit Event(Subsystem sys, uint32 evId, Verbosity verbosity) : system(sys), verb(verbosity), op(0), id(evId) {}
	uint32 system : 2; //!< One of Event::Subsystem - subsystem that produced the event.
	uint32 verb   : 2; //!< One of Event::Verbosity - the verbosity level of this event.
	uint32 op     : 8; //!< Operation that triggered the event.
	uint32 id     : 16;//!< Type id of event.
	static uint32 nextId();
};
//! CRTP-base class for events of type T that registers an id for type T.
template 
struct Event_t : Event {
	Event_t(Subsystem sys, Verbosity verb) : Event(sys, id_s, verb) {}
	static const uint32 id_s;
};
template  const uint32 Event_t::id_s = Event::nextId();

template  const ToType* event_cast(const EvType& ev) { return ev.id == ToType::id_s ? static_cast(&ev) : 0; }

}
#endif
clasp-3.2.2/libclasp/clasp/util/multi_queue.h000066400000000000000000000166061304134206100212020ustar00rootroot00000000000000//
// Copyright (c) 2010-2012, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_MULIT_QUEUE_H_INCLUDED
#define CLASP_MULIT_QUEUE_H_INCLUDED

#include 
#include 

namespace Clasp { namespace mt { namespace Detail {

struct RawNode;
typedef Clasp::Atomic_t::type SafeNodePtr;
struct RawNode {
	SafeNodePtr next;
};
// Lock-free stack that is NOT ABA-safe by itself
struct RawStack {
	RawStack() { top = static_cast(0); }
	RawNode* tryPop() {
		RawNode* n = 0, *next = 0;
		do {
			if ((n = top) == 0) { return 0; }
			// NOTE:
			// it is the caller's job to guarantee that n is safe
			// and n->next is ABA-safe at this point.
			next = n->next;
		} while (top.compare_and_swap(next, n) != n);
		return n;
	}
	void     push(RawNode* n) {
		RawNode* assumedTop;
		do {
			assumedTop = top;
			n->next    = assumedTop;
		} while (top.compare_and_swap(n, assumedTop) != assumedTop);
	}
	SafeNodePtr top;
};
struct DefaultDeleter {
	template 
	void operator()(T& obj) const {
		(void)obj;
		obj.~T();
	}
};
}

//! A (base) class for distributing items between n different threads.
/*!
 * Logically, the class maintains n queues, one for each
 * involved thread. Threads must register themselves by
 * calling addThread(). The returned handle has then
 * to be used for publishing and consuming items.
 */
template 
class MultiQueue {
protected:
	typedef Detail::RawNode RawNode;
	typedef Clasp::Atomic_t::type SafeInt;
	struct Node : Detail::RawNode {
		explicit Node(uint32 rc, const T& d) : data(d) { next = 0; refs = rc; }
		SafeInt refs;
		T       data;
	};
public:
	typedef Detail::RawNode* ThreadId;
	//! creates a new object for at most m threads
	explicit MultiQueue(uint32 m, const Deleter& d = Deleter()) : maxQ_(m), deleter_(d) {
		head_.next = 0;
		tail_      = &head_;
	}
	uint32 maxThreads() const { return maxQ_; }
	void reserve(uint32 c) {
		struct NodeHead : RawNode { SafeInt refs; };
		for (uint32 i = 0; i != c; ++i) {
			free_.push(new (::operator new(sizeof(Node))) NodeHead());
		}
	}
	//! destroys the object and all unconsumed items
	~MultiQueue() {
		for (Detail::RawNode* x = head_.next; x ; ) {
			Node* n = toNode(x);
			x = x->next;
			deleter_(n->data);
			::operator delete(n);
		}
		for (Detail::RawNode* x; (x = free_.tryPop()) != 0; ) {
			::operator delete(toNode(x));
		}
	}
	//! adds a new thread to the object
	/*!
	 * \note Shall be called at most m times
	 * \return A handle identifying the new thread
	 */
	ThreadId addThread() {
		return &head_;
	}
	bool hasItems(ThreadId& cId) const { return cId != tail_; }

	//! tries to consume an item
	/*!
	 * \pre cId was initially obtained via a call to addThread()
	 * \note tryConsume() is thread-safe w.r.t different ThreadIds
	 */
	bool tryConsume(ThreadId& cId, T& out) {
		if (cId != tail_) {
			RawNode* n = cId;
			cId        = cId->next;
			assert(cId != 0 && "MultiQueue is corrupted!");
			release(n);
			out = toNode(cId)->data;
			return true;
		}
		return false;
	}
	//! pops an item from the queue associated with the given thread
	/*!
	 * \pre hasItems(cId) == true
	 */
	void pop(ThreadId& cId) {
		assert(hasItems(cId) && "Cannot pop from empty queue!");
		RawNode* n = cId;
		cId        = cId->next;
		release(n);
	}
protected:
	//! publishes a new item
	/*!
	 * \note the function is *not* thread-safe, i.e.
	 * it must not be called concurrently
	 */
	void unsafePublish(const T& in, const ThreadId&) { unsafePublish(in); }
	void unsafePublish(const T& in) { publishRelaxed(allocate(maxQ_, in)); }

	//! concurrency-safe version of unsafePublish
	void publish(const T& in, const ThreadId&) {
		Node* newNode = allocate(maxQ_, in);
		RawNode* assumedTail, *assumedNext;
		do {
			assumedTail = tail_;
			assumedNext = assumedTail->next;
			if (assumedTail != tail_) {
				// tail has changed - try again
				continue;
			}
			if (assumedNext != 0) {
				// someone has added a new node but has not yet
				// moved the tail - assist him and start over
				tail_.compare_and_swap(assumedNext, assumedTail);
				continue;
			}
		} while (assumedTail->next.compare_and_swap(newNode, 0) != 0);
		// Now that we managed to link a new node to what we think is the current tail
		// we try to update the tail. If the tail is still what we think it is,
		// it is moved - otherwise some other thread already did that for us.
		tail_.compare_and_swap(newNode, assumedTail);
	}

	//! Non-atomically adds n to the global queue
	void publishRelaxed(Node* n) {
		static_cast(tail_)->next = n;
		tail_ = n;
	}
	uint32 maxQ() const { return maxQ_; }
	Node*  allocate(uint32 maxR, const T& in) {
		// If the queue is used correctly, the raw stack is ABA-safe at this point.
		// The ref-counting in the queue makes sure that a node cannot be added back
		// to the stack while another thread is still in tryPop() - that thread had
		// not yet the chance to decrease the node's ref count.
		if (Node* n = toNode(free_.tryPop())) {
			n->next = 0;
			n->refs = maxR;
			new (&n->data)T(in);
			return n;
		}
		return new (::operator new(sizeof(Node))) Node(maxR, in);
	}
private:
	MultiQueue(const MultiQueue&);
	MultiQueue& operator=(const MultiQueue&);
	Node*toNode(Detail::RawNode* x) const { return static_cast(x); }
	void release(Detail::RawNode* n) {
		if (n != &head_ && --toNode(n)->refs == 0) {
			head_.next = static_cast(n->next);
			deleter_(toNode(n)->data);
			free_.push(n);
		}
	}
	RawNode             head_;
	Detail::SafeNodePtr tail_;
	Detail::RawStack    free_;
	const uint32        maxQ_;
	Deleter             deleter_;
};

//! Unbounded non-intrusive lock-free multi-producer single consumer queue.
/*!
 * Based on Dmitriy Vyukov's MPSC queue:
 * http://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
 */
class MPSCPtrQueue {
public:
	typedef Detail::RawNode RawNode;
	struct Node : RawNode { void* data; };
	typedef Clasp::Atomic_t::type SafeNodePtr;
	Node* toNode(RawNode* n) const { return static_cast(n); }
	MPSCPtrQueue() {}
	void init(Node* sent) {
		sent->next = 0;
		sent->data = 0;
		head_      = sent;
		tail_      = sent;
	}
	bool empty() const { return !static_cast(tail_->next); }
	void push(Node* n) {
		n->next = 0;
		Node* p = head_.fetch_and_store(n);
		p->next = n;
	}
	Node* pop() {
		Node* t = tail_;
		Node* n = toNode(t->next);
		if (!n) { return 0; }
		tail_   = n;
		t->data = n->data;
		n->data = 0;
		return t;
	}
private:
	MPSCPtrQueue(const MPSCPtrQueue&);
	MPSCPtrQueue& operator=(const MPSCPtrQueue&);
	SafeNodePtr head_; // producers
	char        pad_[64 - sizeof(Node*)];
	Node*       tail_; // consumer
};

} } // end namespace Clasp::mt
#endif
clasp-3.2.2/libclasp/clasp/util/mutex.h000066400000000000000000000060421304134206100177770ustar00rootroot00000000000000//
// Copyright (c) 2012, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_UTIL_MUTEX_H_INCLUDED
#define CLASP_UTIL_MUTEX_H_INCLUDED

#if !defined(CLASP_USE_STD_THREAD)
#if _WIN32||_WIN64
#define WIN32_LEAN_AND_MEAN // exclude APIs such as Cryptography, DDE, RPC, Shell, and Windows Sockets.
#define NOMINMAX            // do not let windows.h define macros min and max
#endif
#include 
#include 
#if defined(TBB_IMPLEMENT_CPP0X)
#define RESTORE_TBB_IMPLEMENT_CPP0X TBB_IMPLEMENT_CPP0X
#undef TBB_IMPLEMENT_CPP0X
#endif
#define TBB_IMPLEMENT_CPP0X 0
#include 
#undef TBB_IMPLEMENT_CPP0X
#if defined(RESTORE_TBB_IMPLEMENT_CPP0X)
#define TBB_IMPLEMENT_CPP0X RESTORE_TBB_IMPLEMENT_CPP0X
#undef RESTORE_TBB_IMPLEMENT_CPP0X
#endif
#define NS_MUTEX tbb
#define NS_COMPAT tbb::interface5
#else
#include 
#include 
#define NS_MUTEX  std
#define NS_COMPAT std
#endif
namespace Clasp { namespace mt {
	using NS_MUTEX::mutex;
	using NS_COMPAT::lock_guard;
	using NS_COMPAT::unique_lock;
	using NS_COMPAT::swap;
	using NS_COMPAT::defer_lock_t;
	struct condition_variable : private NS_COMPAT::condition_variable {
		typedef NS_COMPAT::condition_variable base_type;
		using base_type::notify_one;
		using base_type::notify_all;
		using base_type::wait;
		using base_type::native_handle;

		bool wait_for(unique_lock& lock, double timeInSecs);
	};
#if !defined(CLASP_USE_STD_THREAD)
	// Due to a bug in the computation of the wait time in older tbb versions
	// wait_for might fail with eid_condvar_wait_failed.
	// See: http://software.intel.com/en-us/forums/topic/280012
	// Ignore the error and retry the wait - the computed wait time will be valid, eventually.
	inline bool condition_variable::wait_for(unique_lock& lock, double s) {
		if (s < 0) { throw std::logic_error("invalid wait time"); }
		for (;;) {
			try { return base_type::wait_for(lock, tbb::tick_count::interval_t(s)) == NS_COMPAT::no_timeout; }
			catch (const std::runtime_error&) {}
		}
	}
#else
	inline bool condition_variable::wait_for(unique_lock& lock, double s) {
		return base_type::wait_for(lock, std::chrono::duration_cast(std::chrono::duration(s)))
			== std::cv_status::no_timeout;
	}
#endif
}}

#undef NS_MUTEX
#undef NS_COMPAT

#endif
clasp-3.2.2/libclasp/clasp/util/platform.h000066400000000000000000000146541304134206100204710ustar00rootroot00000000000000//
// Copyright (c) 2006-2012, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
//! \file
//! \brief Global and platform-dependent stuff.
#ifndef CLASP_PLATFORM_H_INCLUDED
#define CLASP_PLATFORM_H_INCLUDED
#ifdef _MSC_VER
#pragma once
#endif
#if !defined(WITH_THREADS)
#error Invalid thread configuration - use WITH_THREADS=0 for single-threaded or WITH_THREADS=1 for multi-threaded version of libclasp!
#endif

#define STRING2(x) #x
#define STRING(x) STRING2(x)

#if defined(_MSC_VER) && _MSC_VER >= 1200
#define CLASP_PRAGMA_TODO(X) __pragma(message(__FILE__ "(" STRING(__LINE__) ") : TODO: " X))
#define FUNC_NAME __FUNCTION__
#define CLASP_WARNING_BEGIN_RELAXED \
	__pragma(warning(push))\
	__pragma(warning (disable : 4200))

#define CLASP_WARNING_END_RELAXED \
	__pragma(warning(pop))

#include 
#if _MSC_VER >= 1600
#include 
#endif
typedef UINT8     uint8;
typedef UINT16    uint16;
typedef INT16     int16;
typedef INT32     int32;
typedef UINT32    uint32;
typedef UINT64    uint64;
typedef INT64     int64;
typedef UINT_PTR  uintp;
typedef INT16     int16;
#define PRIu64 "llu"
#define PRId64 "lld"
#elif defined(__GNUC__) && __GNUC__ >= 3
#define FUNC_NAME __PRETTY_FUNCTION__
#if !defined(__STDC_FORMAT_MACROS)
#define __STDC_FORMAT_MACROS
#endif
#include 
typedef uint8_t   uint8;
typedef uint16_t  uint16;
typedef int16_t   int16;
typedef int32_t   int32;
typedef uint32_t  uint32;
typedef uint64_t  uint64;
typedef int64_t   int64;
typedef uintptr_t uintp;
#define APPLY_PRAGMA(x) _Pragma (#x)
#define CLASP_PRAGMA_TODO(x) APPLY_PRAGMA(message ("TODO: " #x))
#else
#error unknown compiler or platform. Please add typedefs manually.
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (~uint32(0))
#endif
#ifndef UINT64_MAX
#define UINT64_MAX (~uint64(0))
#endif
#ifndef INT64_MAX
#define INT64_MAX ((int64)(UINT64_MAX >> 1))
#endif
#ifndef UINTP_MAX
#define UINTP_MAX (~uintp(0))
#endif
#ifndef INT16_MAX
#define INT16_MAX (0x7fff)
#endif
#ifndef INT16_MIN
#define	INT16_MIN (-INT16_MAX - 1)
#endif
#ifndef UINT16_MAX
#define	UINT16_MAX (65535U)
#endif
#ifndef FUNC_NAME
#define FUNC_NAME __FILE__
#endif


template 
bool aligned(void* mem) {
	uintp x = reinterpret_cast(mem);
#if (_MSC_VER >= 1300)
	return (x & (__alignof(T)-1)) == 0;
#elif defined(__GNUC__)
	return (x & (__alignof__(T)-1)) == 0;
#else
	struct AL { char x; T y; };
	return (x & (sizeof(AL)-sizeof(T))) == 0;
#endif
}

#if !defined(CLASP_WARNING_BEGIN_RELAXED)
#	undef CLASP_WARNING_END_RELAXED
#	if defined(__clang__)
#		define CLASP_WARNING_BEGIN_RELAXED \
		_Pragma("clang diagnostic push") \
		_Pragma("clang diagnostic ignored \"-Wzero-length-array\"")
#		define CLASP_WARNING_END_RELAXED _Pragma("clang diagnostic pop")
#	elif defined(__GNUC__)
#		define CLASP_WARNING_BEGIN_RELAXED \
		_Pragma("GCC diagnostic push")\
		_Pragma("GCC diagnostic ignored \"-Wpragmas\"")\
		_Pragma("GCC diagnostic ignored \"-Wpedantic\"")\
		_Pragma("GCC diagnostic ignored \"-pedantic\"")
#		define CLASP_WARNING_END_RELAXED _Pragma("GCC diagnostic pop")
#	else
#		define CLASP_WARNING_BEGIN_RELAXED
#		define CLASP_WARNING_END_RELAXED
#	endif
#endif

#if !defined(CLASP_HAS_STATIC_ASSERT)
#	if defined(__cplusplus) && __cplusplus >= 201103L
#		define CLASP_HAS_STATIC_ASSERT 1
#	elif defined(static_assert)
#		define CLASP_HAS_STATIC_ASSERT 1
#	elif defined(_MSC_VER) && _MSC_VER >= 1600
#		define CLASP_HAS_STATIC_ASSERT 1
#	else
#		define CLASP_HAS_STATIC_ASSERT 0
#	endif
#endif

#if !defined(CLASP_HAS_STATIC_ASSERT) || CLASP_HAS_STATIC_ASSERT == 0
template  struct static_assertion;
template <>     struct static_assertion {};
#ifndef __GNUC__
#define static_assert(x, message) typedef bool clasp_static_assertion[sizeof(static_assertion< (x) >)]
#else
#define static_assert(x, message) typedef bool clasp_static_assertion[sizeof(static_assertion< (x) >)]  __attribute__((__unused__))
#endif
#endif
#include 
#include 
extern const char* clasp_format(char* buf, unsigned size, const char* m, ...);
class ClaspStringBuffer {
public:
	ClaspStringBuffer() { fix_[0] = 0; buf_ = pos_ = fix_; end_ = buf_ + sizeof(fix_); }
	~ClaspStringBuffer();
	const char* c_str() const { return buf_; }
	operator const char*() const { return c_str(); }
	ClaspStringBuffer& appendFormat(const char* fmt, ...);
	ClaspStringBuffer& append(const char* str);
	size_t size() const { return static_cast(pos_ - buf_); }
private:
	ClaspStringBuffer(const ClaspStringBuffer&);
	ClaspStringBuffer& operator=(const ClaspStringBuffer&);
	bool grow(size_t nItems);
	char* buf_;
	char* pos_;
	char* end_;
	char  fix_[512];
};

#define CLASP_FAIL_IF(exp, ...) \
	(void)( (!(exp)) || (throw std::logic_error(ClaspStringBuffer().appendFormat(__VA_ARGS__).c_str()), 0))

#ifndef CLASP_NO_ASSERT_CONTRACT

#define CLASP_ASSERT_CONTRACT_MSG(exp, msg) \
	(void)( (!!(exp)) || (throw std::logic_error(ClaspStringBuffer().appendFormat("%s@%d: contract violated: %s", FUNC_NAME, __LINE__, (msg)).c_str()), 0))

#else
#include 
#define CLASP_ASSERT_CONTRACT_MSG(exp, msg) assert((exp) && ((msg),true))
#endif

#define CLASP_ASSERT_CONTRACT(exp) CLASP_ASSERT_CONTRACT_MSG(exp, #exp)

#if !defined(CLASP_ENABLE_PRAGMA_TODO) || CLASP_ENABLE_PRAGMA_TODO==0
#undef CLASP_PRAGMA_TODO
#define CLASP_PRAGMA_TODO(X)
#endif

#if _WIN32||_WIN64
inline void* alignedAlloc(size_t size, size_t align) { return _aligned_malloc(size, align); }
inline void  alignedFree(void* p)                    { _aligned_free(p); }
#else
inline void* alignedAlloc(size_t size, size_t align) {
#	if !defined(__CYGWIN__)
	void* result = 0;
	return posix_memalign(&result, align, size) == 0 ? result : static_cast(0);
#	else
	return memalign(align, size);
#	endif
}
inline void alignedFree(void* p) { free(p); }
#endif

#endif

clasp-3.2.2/libclasp/clasp/util/pod_vector.h000066400000000000000000000422171304134206100210050ustar00rootroot00000000000000// 
// Copyright (c) 2006-2010, Benjamin Kaufmann
// 
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef BK_LIB_POD_VECTOR_H_INCLUDED
#define BK_LIB_POD_VECTOR_H_INCLUDED
#include "type_manip.h"
#include 
#include 
#include 
#include 
#include 
#include 
namespace bk_lib { namespace detail {
	template 
	void fill(T* first, T* last, const T& x) {
		assert(first <= last);
		switch ((last - first) & 7u)
		{
		case 0:
				while (first != last)
				{
				new(first++) T(x);
		case 7: new(first++) T(x);
		case 6: new(first++) T(x);
		case 5: new(first++) T(x);
		case 4: new(first++) T(x);
		case 3: new(first++) T(x);
		case 2: new(first++) T(x);
		case 1: new(first++) T(x);
				assert(first <= last);
				}
		}
	}
	template 
	void copy(Iter first, Iter last, std::size_t s, T* out) {
		switch (s & 7u)
		{
		case 0:
				while (first != last)
				{
				new(out++) T(*first++);
		case 7: new(out++) T(*first++);
		case 6: new(out++) T(*first++);
		case 5: new(out++) T(*first++);
		case 4: new(out++) T(*first++);
		case 3: new(out++) T(*first++);
		case 2: new(out++) T(*first++);
		case 1: new(out++) T(*first++);
				}
		}
	}
	template 
	struct Fill {
		Fill(const T& val) : val_(val) {}
		void operator()(T* first, std::size_t n) const { detail::fill(first, first + n, val_); }
		const T& val_;
	private: Fill& operator=(const Fill&);
	};
	template 
	struct Copy {
		Copy(Iter first, Iter last) : first_(first), last_(last) {}
		template 
		void operator()(T* out, std::size_t n) const { detail::copy(first_, last_, n, out); }
		Iter first_;
		Iter last_;
	};
	template 
	struct Memcpy {
		Memcpy(const T* first) : first_(first) {}
		void operator()(T* out, std::size_t n) const { 
			std::memcpy(out, first_, n*sizeof(T));
		}
		const T* first_;
	};
	typedef char yes_type;
	typedef char (&no_type)[2];
	template 
	struct IterType {
		static yes_type isPtr(const volatile void*);
		static no_type isPtr(...);
		static yes_type isLong(int64);
		static no_type  isLong(...);
		static T& makeT();
		enum { ptr = sizeof(isPtr(makeT())) == sizeof(yes_type) };
		enum { num = sizeof(isLong(makeT())) == sizeof(yes_type) }; 
		enum { value = ptr ? 1 : num ? 2 : 0 };
	};

} // end namespace bk_lib::detail

//! A std::vector-replacement for POD-Types. 
/*!
 * \pre T is a POD-Type 
 * \see http://www.comeaucomputing.com/techtalk/#pod for a description of POD-Types.
 * \note Does not call any destructors and uses std::memcpy to copy/move elements
 * \note On LP64-machines size and capacity are represented as unsigned integers (instead of e.g. std::size_t)
 */
template  >
class pod_vector {
public:
	// types:
	typedef          pod_vector          this_type;//not standard
	typedef          Allocator                        allocator_type;
	typedef typename Allocator::reference             reference;
	typedef typename Allocator::const_reference       const_reference;
	typedef typename Allocator::pointer               iterator;
	typedef typename Allocator::const_pointer         const_iterator;
	typedef typename Allocator::pointer               pointer;
	typedef typename Allocator::const_pointer         const_pointer;
	typedef std::reverse_iterator           reverse_iterator;
	typedef std::reverse_iterator     const_reverse_iterator;
	typedef          T                                value_type;	
	typedef typename detail::if_then_else<
		sizeof(typename Allocator::size_type)<=sizeof(unsigned int), 
		typename Allocator::size_type, 
		unsigned int>::type                           size_type;
	typedef typename detail::if_then_else<
		sizeof(typename Allocator::difference_type)<=sizeof(int), 
		typename Allocator::difference_type, 
		int>::type                                    difference_type;
	// ctors
	//! constructs an empty pod_vector.
	/*! 
	 * \post size() == capacity() == 0
	 */
	pod_vector() : ebo_(0, allocator_type()) { }
	
	//! constructs an empty pod_vector that uses a copy of a for memory allocations.
	/*!
	 * \post size() == capacity() == 0
	 */
	explicit pod_vector(const allocator_type& a) : ebo_(0, a) { }

	//! constructs a pod_vector containing n copies of value.
	/*!
	 * \post size() == n
	 */
	explicit pod_vector(size_type n, const T& value = T(), const allocator_type& a = allocator_type()) 
		: ebo_(n, a) {
		detail::fill(ebo_.buf, ebo_.buf + n, value);	
		ebo_.size = n;
	}

	//! constructs a pod_vector equal to the range [first, last).
	/*!
	 * \post size() = distance between first and last.
	 */
	template 
	pod_vector(Iter first, Iter last, const allocator_type& a = allocator_type(), typename detail::disable_if::num>::type* = 0) 
		: ebo_(0, a) {
		insert_range(end(), first, last, typename std::iterator_traits::iterator_category());
	}
	
	//! creates a copy of other
	/*!
	 * \post size() == other.size() && capacity() == other.size()
	 */
	pod_vector(const pod_vector& other) : ebo_(other.size(), other.get_allocator()) {
		std::memcpy(ebo_.buf, other.begin(), other.size()*sizeof(T));
		ebo_.size = other.size();
	}

	pod_vector& operator=(const pod_vector& other) {
		if (this != &other) {
			assign(other.begin(), other.end());
		}
		return *this;
	}

	//! frees all memory allocated by this pod_vector.
	/*!
	 * \note Won't call any destructors, because PODs don't have those.
	 */
	~pod_vector() { }

	/** @name inspectors
	 * inspector-functions
	 */
	//@{
	
	//! returns the number of elements currently stored in this pod_vector.
	size_type size()     const { return ebo_.size; }
	//! size of the largest possible pod_vector
	size_type max_size() const { 
		typename allocator_type::size_type x = get_allocator().max_size();
		std::size_t                        y = size_type(-1)/sizeof(T);
		return static_cast(std::min(std::size_t(x), y));
	}
	//! returns the total number of elements this pod_vector can hold without requiring reallocation.
	size_type capacity() const  { return ebo_.cap; }
	//! returns size() == 0
	bool empty() const { return ebo_.size == 0;  }

	const_iterator begin() const { return ebo_.buf; }
	const_iterator end()   const { return ebo_.buf+ebo_.size;}
	const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
	const_reverse_iterator rend()   const { return const_reverse_iterator(begin()); }

	iterator       begin()  { return ebo_.buf; }
	iterator       end()    { return ebo_.buf+ebo_.size; }
	reverse_iterator rbegin() { return reverse_iterator(end()); }
	reverse_iterator rend()   { return reverse_iterator(begin()); }
	
	//! returns a copy of the allocator used by this pod_vector
	allocator_type get_allocator() const { return ebo_; }
	
	//@}
	/** @name elemacc
	 * element access
	 */
	//@{
	
	//! returns a reference to the element at position n
	/*!
	 * \pre n < size()
	 */
	reference operator[](size_type n) {
		assert(n < size());
		return ebo_.buf[n];
	}
	
	//! returns a reference-to-const to the element at position n
	/*!
	 * \pre n < size()
	 */
	const_reference operator[](size_type n) const {
		assert(n < size());
		return ebo_.buf[n];
	}
	
	//! same as operator[] but throws std::out_of_range if pre-condition is not met.
	const_reference at(size_type n) const {
		if (n < size()) return ebo_.buf[n];
		throw std::out_of_range("pod_vector::at");
	}
	//! same as operator[] but throws std::out_of_range if pre-condition is not met.
	reference at(size_type n) {
		if (n < size()) return ebo_.buf[n];
		throw std::out_of_range("pod_vector::at");
	}
	
	//! equivalent to *begin()
	reference front() { assert(!empty()); return *ebo_.buf; }
	//! equivalent to *begin()
	const_reference front() const { assert(!empty()); return *ebo_.buf; }
	
	//! equivalent to *--end()
	reference back() { assert(!empty()); return ebo_.buf[ebo_.size-1]; }
	
	//! equivalent to *--end()
	const_reference back() const { assert(!empty()); return ebo_.buf[ebo_.size-1]; }
	
	//@}
	/** @name mutators
	 * mutator functions
	 */
	//@{
	
	//! erases all elements in the range [begin(), end)
	/*!
	 * \post size() == 0
	 */
	void clear() { ebo_.size = 0; }

	void assign(size_type n, const T& val) {
		clear();
		insert(end(), n, val);
	}
	
	template 
	void assign(Iter first, Iter last) {
		clear();
		insert(end(), first, last);
	}
	
	//! erases the element pointed to by pos.
	/*!
	 * \pre pos != end() && !empty()
	 * \return an iterator pointing to the element following pos (before that element was erased)
	 * of end() if no such element exists.
	 *
	 * \note invalidates all iterators and references referring to elements after pos.
	 */
	iterator erase(iterator pos) {
		assert(!empty() && pos != end());
		erase(pos, pos + 1);
		return pos;
	}

	//! erases the elements in the range [first, last)
	/*!
	 * \pre [first, last) must be a valid range.
	 */
	iterator erase(iterator first, iterator last) {
		if (end() - last > 0) {
			std::memmove(first, last, (end() - last) * sizeof(T));
		}
		ebo_.size -= static_cast(last - first);
		return first;
	}

	//! adjusts the size of this pod_vector to ns.
	/*!
	 * resize is equivalent to:
	 * if ns > size insert(end(), ns - size(), val)
	 * if ns < size erase(begin() + ns, end())
	 *
	 * \post size() == ns
	 */
	void resize(size_type ns, const T& val = T()) {
		if (ns > size()) {
			ns <= capacity() ? detail::fill(end(), end()+(ns-size()), val) : append_realloc(ns-size(), val);
		}
		ebo_.size = ns;
	}

	//! reallocates storage if necessary but never changes the size() of this pod_vector.
	/*!
	 * \note if n is <= capacity() reserve is a noop. Otherwise a reallocation takes place
	 * and capacity() >= n after reserve returned.
	 * \note reallocation invalidates all references, pointers and iterators referring to
	 * elements in this pod_vectror.
	 *
	 * \note when reallocation occurs elements are copied from the old storage using memcpy.
	 */
	void reserve(size_type n) {
		if (n > capacity()) {
			T* temp = ebo_.allocate(n);
			std::memcpy(temp, ebo_.buf, size()*sizeof(T));
			ebo_.release();
			ebo_.buf = temp;
			ebo_.cap = n;
		}
	}

	void swap(pod_vector& other) {
		std::swap(ebo_.buf, other.ebo_.buf);
		std::swap(ebo_.size, other.ebo_.size);
		std::swap(ebo_.cap, other.ebo_.cap);
	}

	//! equivalent to insert(end(), x);
	void push_back(const T& x) {
		if (size() < capacity()) {
			new ((ebo_.buf+ebo_.size++)) T(x);
		}
		else {
			append_realloc(1, x);
		}
	}
	
	//! equivalent to erase(--end());
	/*!
	 * \pre !empty()
	 */
	void pop_back() {
		assert(!empty());
		--ebo_.size;
	}

	//! inserts a copy of val before pos.
	/*!
	 * \pre pos is a valid iterator.
	 * \return an iterator pointing to the copy of val that was inserted.
	 * \note if size() + 1 > capacity() reallocation occurs. Otherwise iterators and
	 * references referring to elements before pos remain valid.
	 * 
	 */
	iterator insert(iterator pos, const T& val) {
		return insert(pos, (size_type)1, val);
	}

	//! inserts n copies of val before pos.
	/*!
	 * \pre pos is a valid iterator.
	 */
	iterator insert(iterator pos, size_type n, const T& val) {
		size_type off = static_cast(pos-begin());
		insert_impl(pos, n, detail::Fill(val));
		return ebo_.buf + off;
	}

	//! inserts copies of elements in the range [first, last) before pos.
	/*!
	 * \pre first and last are not iterators into this pod_vector.
	 * \pre pos is a valid iterator.
	 * \note if first and last are pointers, memcpy is used to insert the elements
	 * in the range [first, last) into this container.
	 * 
	 */
	template 
	void insert(iterator pos, Iter first, Iter last, typename detail::disable_if::num>::type* = 0) {
		insert_range(pos, first, last, typename std::iterator_traits::iterator_category());
	}

	
	/** @name nonstd
	 * Non-standard interface 
	 */
	//@{
	
	//! adjusts the size of this pod_vector to ns.
	/*!
	 * In contrast to pod_vector::resize this function does not
	 * initializes new elements in case ns > size().
	 * This reflects the behaviour of built-in arrays of pod-types.
	 * \note 
	 *  Any access to an unitialized element is illegal unless it is accessed
	 *  in order to assign a new value.
	 */
	void resize_no_init(size_type ns) {
		reserve(ns);
		ebo_.size = ns;
	}
	//@}
private:
	size_type grow_size(size_type n) {
		size_type new_cap = size() + n;
		assert(new_cap > size() && "pod_vector: max size exceeded!");
		assert(new_cap > capacity());
		if (new_cap < 4) new_cap = 1 << (new_cap+1);
		size_type x = (capacity()*3)>>1;
		if (new_cap < x) new_cap = x;
		return new_cap;
	}
	void append_realloc(size_type n, const T& x) {
		size_type new_cap = grow_size(n);
		pointer temp      = ebo_.allocate(new_cap);
		std::memcpy(temp, ebo_.buf, size()*sizeof(T));
		detail::fill(temp+size(), temp+size()+n, x);
		ebo_.release();
		ebo_.buf  = temp;
		ebo_.cap  = new_cap;
		ebo_.size+= n;
	}
	void move_right(iterator pos, size_type n) {
		assert( (pos || n == 0) && (ebo_.eos() - pos) >= (int)n);
		std::memmove(pos + n, pos, (end() - pos) * sizeof(T));
	}
	template 
	void insert_range(iterator pos, It first, It last,  std::random_access_iterator_tag, 
		typename detail::disable_if::value == 0 && detail::same_type::value == 0>::type* = 0) {
		assert( (first < begin() || first >= end()) && "pod_vec::insert(): Precondition violated!");
		typename allocator_type::difference_type diff = std::distance(first, last);
		assert(diff == 0 || (static_cast(size()+diff) > size() && "pod_vector: max size exceeded!"));
		insert_impl(pos, static_cast(diff), detail::Memcpy(first));
	}
	template 
	void insert_range(iterator pos, It first, It last,  std::forward_iterator_tag) {
		typename allocator_type::difference_type diff = std::distance(first, last);
		assert(diff == 0 || (static_cast(size()+diff) > size() && "pod_vector: max size exceeded!"));
		insert_impl(pos, static_cast(diff), detail::Copy(first, last));
	}
	template 
	void insert_range(iterator pos, Iter first, Iter last, std::input_iterator_tag) {
		pod_vector temp;
		while (first != last) temp.push_back(*first++);
		insert(pos, temp.begin(), temp.end());
	}
	
	// NOTE: template parameter ST should always equal size_type
	// and is only needed to workaround an internal compiler error
	// in gcc 3.4.3
	template 
	void insert_impl(iterator pos, ST n, const P& pred) {
		assert(n == 0 || (size()+n) > size() );
		if (size()+n <= capacity()) {
			move_right(pos, n);
			pred(pos, n);
			ebo_.size += n;
		}
		else {
			size_type new_cap = grow_size(n);
			pointer temp      = ebo_.allocate(new_cap);
			size_type prefix  = static_cast(pos-begin());
			// copy prefix
			std::memcpy(temp, begin(), prefix*sizeof(T));
			// insert new stuff
			pred(temp+prefix, n);
			// copy suffix
			std::memcpy(temp+prefix+n, pos, (end()-pos)*sizeof(T));
			ebo_.release();
			ebo_.buf  = temp;
			ebo_.size+= n;
			ebo_.cap  = new_cap;
		}
	}
	struct ebo : public Allocator { // empty-base-optimization
		typedef typename this_type::size_type size_type;
		typedef typename this_type::allocator_type A;
		pointer    buf;  // pointer to array
		size_type  size; // current size (used elements)
		size_type  cap;  // max size before regrow
		ebo(size_type n, const Allocator& a) : Allocator(a), buf(0), size(0), cap(n) {
			if (n > 0) {  buf = A::allocate(n); }
		}
		~ebo()            { release(); }
		void release()    { if (buf) A::deallocate(buf, cap); }
		T*   eos() const  { return buf + cap; }
	}      ebo_;
};

template 
inline bool operator==(const pod_vector& lhs, const pod_vector& rhs) {
	return lhs.size() == rhs.size()
		&& std::equal(lhs.begin(), lhs.end(), rhs.begin());
}

template 
inline bool operator!=(const pod_vector& lhs, const pod_vector& rhs) {
	return ! (lhs == rhs);
}

template 
inline bool operator<(const pod_vector& lhs, const pod_vector& rhs) {
	return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}

template 
inline bool operator>(const pod_vector& lhs, const pod_vector& rhs) {
	return rhs < lhs;
}

template 
inline bool operator<=(const pod_vector& lhs, const pod_vector& rhs) {  
	return !(rhs < lhs);
}

template 
inline bool operator>=(const pod_vector& lhs, const pod_vector& rhs) {
	return !(lhs < rhs);
}

template 
inline void swap(pod_vector& lhs, pod_vector& rhs) { 
	lhs.swap(rhs);
}

}

#endif 

clasp-3.2.2/libclasp/clasp/util/thread.h000066400000000000000000000026571304134206100201140ustar00rootroot00000000000000//
// Copyright (c) 2010-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_UTIL_THREAD_H_INCLUDED
#define CLASP_UTIL_THREAD_H_INCLUDED

#if !defined(CLASP_USE_STD_THREAD)

#if _WIN32||_WIN64
#define WIN32_LEAN_AND_MEAN // exclude APIs such as Cryptography, DDE, RPC, Shell, and Windows Sockets.
#define NOMINMAX            // do not let windows.h define macros min and max
#endif
#include 
namespace Clasp { namespace mt {
	typedef tbb::tbb_thread thread;
	namespace this_thread { using tbb::this_tbb_thread::yield; }
}}

#else
#include 
namespace Clasp { namespace mt {
	using std::thread;
	namespace this_thread { using std::this_thread::yield; }
}}

#endif
#endif
clasp-3.2.2/libclasp/clasp/util/timer.h000066400000000000000000000041561304134206100177610ustar00rootroot00000000000000//
// Copyright (c) 2006-2012, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef CLASP_TIMER_H_INCLUDED
#define CLASP_TIMER_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif
/*!
 * \file
 * \brief Defines various types for getting absolute times.
 */
namespace Clasp {

//! A type for getting the current process time.
struct ProcessTime {
	static double getTime();
};
//! A type for getting the current thread time.
struct ThreadTime {
	static double getTime();
};
//! A tpe for getting the current wall-clock time.
struct RealTime {
	static double getTime();
};
//! A class for measuring elapsed time.
/*!
 * \tparam TimeType must provide a single static function
 * TimeType::getTime() returning an absolute time.
 */
template 
class Timer {
public:
	Timer() : start_(0), split_(0), total_(0) {}

	void   start()   { start_ = TimeType::getTime(); }
	void   stop()    { split(TimeType::getTime()); }
	void   reset()   { *this  = Timer(); }
	//! Same as stop(), start();
	void   lap()     { double t; split(t = TimeType::getTime()); start_ = t; }
	//! Returns the elapsed time (in seconds) for last start-stop cycle.
	double elapsed() const { return split_; }
	//! Returns the total elapsed time for all start-stop cycles.
	double total()   const { return total_; }
private:
	void split(double t) { total_ += (split_ = t-start_); }
	double start_;
	double split_;
	double total_;
};

}
#endif
clasp-3.2.2/libclasp/clasp/util/type_manip.h000066400000000000000000000105721304134206100210050ustar00rootroot00000000000000// 
// Copyright (c) 2010, Benjamin Kaufmann
// 
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef BK_LIB_TYPE_MANIP_H_INCLUDED
#define BK_LIB_TYPE_MANIP_H_INCLUDED
namespace bk_lib { namespace detail {
#if (_MSC_VER >= 1300)
#define ALIGNOF(PARAM) (__alignof(PARAM))
#elif defined(__GNUC__)
#define ALIGNOF(PARAM) (__alignof__(PARAM))
#else
template 
struct align_helper { char x; T  y; };
#define ALIGNOF(T) (sizeof(align_helper)-sizeof(T))
#endif


// if b then if_type else else_type
template 
struct if_then_else;

template 
struct if_then_else  {  typedef if_type type;  };
template 
struct if_then_else { typedef else_type type; };

// 1 if T == U, else 0
template   struct same_type        { enum { value = 0 }; };
template            struct same_type   { enum { value = 1 }; };

template               struct disable_if       { typedef bool type; };
template <>                  struct disable_if {  };

// not in list - marks end of type list
struct nil_type {};

// list of types - terminated by nil_type
template 
struct type_list {
	typedef head head_type;
	typedef tail tail_type;
};

// generates a type lits with up to 18 elements
template <
	typename T1  = nil_type, typename T2  = nil_type, typename T3  = nil_type,
	typename T4  = nil_type, typename T5  = nil_type, typename T6  = nil_type,
	typename T7  = nil_type, typename T8  = nil_type, typename T9  = nil_type,
	typename T10 = nil_type, typename T11 = nil_type, typename T12 = nil_type,
	typename T13 = nil_type, typename T14 = nil_type, typename T15 = nil_type,
	typename T16 = nil_type, typename T17 = nil_type, typename T18 = nil_type
> 
struct generate_type_list {
	typedef typename generate_type_list::type tail_type;
	typedef type_list type;
};

template <> 
struct generate_type_list<> { typedef nil_type type; };

// maps an integer constant to a type
template 
struct int2type { enum { value = i }; };
typedef int2type<0> false_type;
typedef int2type<1> true_type;

// declared but not defined
struct unknown_type;

// finds the element in the type list TList that 
// has the same alignment as X or X if no such element exists
template 
struct max_align;

// IF ALIGNOF(X) == ALIGNOF(H) then H 
// ELSE max_align
template 
struct max_align_aux;

// Base case: ALIGNOF(X) == ALIGNOF(H)
template 
struct max_align_aux {
	typedef H type;
};

// Recursive case
template 
struct max_align_aux {
	typedef typename max_align::type type;
};

template 
struct max_align {
	typedef X type;
};

template 
struct max_align > {
private:
	enum { x_align = ALIGNOF(X) };
	enum { h_align = ALIGNOF(H) };
public:
	typedef typename max_align_aux(x_align) == static_cast(h_align), X, H, T>::type type;
	enum { value = sizeof(type) };
};

// computes alignment size (::value) and type (::type)  of T
template 
struct align_of {
	typedef generate_type_list::type align_list;
	typedef typename max_align::type type;
	enum { value = max_align::value };
};

#undef ALIGNOF

}}
#endif

clasp-3.2.2/libclasp/clasp/weight_constraint.h000066400000000000000000000252421304134206100214160ustar00rootroot00000000000000//
// Copyright (c) 2006-2011, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_SMODELS_CONSTRAINTS_H_INCLUDED
#define CLASP_SMODELS_CONSTRAINTS_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include 

namespace Clasp {

//! Primitive representation of weight constraint literals in normal form.
struct WeightLitsRep {
	//! Transforms the given literals to the normal form expected by WeightConstraint.
	/*!
	 * The function simplifies lits and bound by removing assigned and
	 * merging duplicate/complementary literals. Furthermore, negative weights and
	 * their literals are inverted, bound is updated accordingly, and literals
	 * are sorted by decreasing weight.
	 */
	static WeightLitsRep create(Solver& s, WeightLitVec& lits, weight_t bound);
	//! Propagates the constraint W == *this.
	/*!
	 * If *this is always satisfied (bound <= 0) or unsatisfied (bound > reach),
	 * the function forward propagates W. Otherwise, if W is not free, it assigns
	 * (and removes) literals from *this that must hold.
	 */
	bool propagate(Solver& s, Literal W);
	bool sat()        const { return bound <= 0; }
	bool unsat()      const { return reach < bound; }
	bool open()       const { return bound > 0 && bound <= reach;}
	bool hasWeights() const { return size && lits[0].second > 1;  }
	WeightLiteral* lits;  /*!< Literals sorted by decreasing weight. */
	uint32         size;  /*!< Number of literals in lits.  */
	weight_t       bound; /*!< Rhs of linear constraint.    */
	weight_t       reach; /*!< Sum of weights of lits.      */
};

//! Class implementing smodels-like cardinality- and weight constraints.
/*!
 * \ingroup constraint
 * This class represents a constraint of type W == w1*x1 ... wn*xn >= B,
 * where W and each xi are literals and B and each wi are strictly positive integers.
 *
 * The class is used to represent smodels-like weight constraint, i.e.
 * the body of a basic weight rule. In this case W is the literal associated with the body.
 * A cardinality constraint is handled like a weight constraint where all weights are equal to 1.
 *
 * Given a WeightConstraint with bound \p B and set of literals \p L,
 * -  let \p sumTrue be the sum of the weights of all literals \p l in \p L that are currently true,
 * - \p sumReach be the sum of the weights of all literals \p l in \p L that are currently not false, and
 * - \p U be the set of literals \p l in \p L that are currently unassigned
 * .
 * the class implements the following four inference rules:
 * - \b FTB: If \p sumTrue >= \p B: assign \p W to true.
 * - \b BFB: If \p W is false: set false all literals \p l in \p U for which \p sumTrue + weight(\p l) >= \p B.
 * - \b FFB: If \p sumReach < \p B: assign \p W to false.
 * - \b BTB: If \p W is true: set true all literals \p l in \p U for which \p sumReach - weight(\p l) < \p B.
 * .
 */
class WeightConstraint : public Constraint {
public:
	//! Flags controlling weight constraint creation.
	enum CreationFlags {
		create_explicit  = 1u, //!< Force creation of explicit constraint even if size/bound is small.
		create_no_add    = 3u, //!< Do not add constraint to solver db.
		create_sat       = 4u, //!< Force creation even if constraint is always satisfied.
		create_no_freeze = 8u, //!< Do not freeze variables in constraint.
		create_no_share  =16u, //!< Do not allow sharing of literals between threads.
		create_eq_bound  =32u, //!< Create equality instead of greater-or-equal constraint.
		create_only_btb  =64u, //!< Only create FFB_BTB constraint.
		create_only_bfb  =128u,//!< Only create FTB_BFB constraint.
	};
	//! Type used to communicate result of create().
	class CPair {
	public:
		CPair() { con[0] = con[1] = 0; }
		bool              ok()    const { return con[0] != (WeightConstraint*)0x1 && con[1] != (WeightConstraint*)0x1; }
		WeightConstraint* first() const { return con[0]; }
		WeightConstraint* second()const { return con[1]; }
	private:
		friend class WeightConstraint;
		WeightConstraint* con[2];
	};
	//! Creates a new weight constraint from the given weight literals.
	/*!
	 * If the right hand side of the weight constraint is initially true/false (FTB/FFB),
	 * W is assigned appropriately but no constraint is created. Otherwise,
	 * the new weight constraint is added to s unless creationFlags contains create_no_add.
	 *
	 * \param s Solver in which the new constraint is to be used.
	 * \param W The literal that is associated with the constraint.
	 * \param lits The literals of the weight constraint.
	 * \param bound The lower bound of the weight constraint.
	 * \param creationFlags Set of CreationFlags to apply.
	 * \note Cardinality constraint are represented as weight constraints with all weights equal to 1.
	 * \note If creationFlags contains create_eq_bound, a constraint W == (lits == bound) is created that
	 * is represented by up to two weight constraints.
	 */
	static CPair create(Solver& s, Literal W, WeightLitVec& lits, weight_t bound, uint32 creationFlags = 0);

	//! Low level creation function.
	/*!
	 * \note flag create_eq_bound is ignored by this function, that is, this function always creates
	 * a single >= constraint.
	 */
	static CPair create(Solver& s, Literal W, WeightLitsRep& rep, uint32 flags);
	// constraint interface
	Constraint* cloneAttach(Solver&);
	bool simplify(Solver& s, bool = false);
	void destroy(Solver*, bool);
	PropResult propagate(Solver& s, Literal p, uint32& data);
	void reason(Solver&, Literal p, LitVec& lits);
	bool minimize(Solver& s, Literal p, CCMinRecursive* r);
	void undoLevel(Solver& s);
	uint32 estimateComplexity(const Solver& s) const;
	/*!
	 * Logically, we distinguish two constraints:
	 * - FFB_BTB for handling forward false body and backward true body and
	 * - FTB_BFB for handling forward true body and backward false body.
	 * .
	 * Physically, we store the literals in one array: ~W=1, l0=w0,...,ln-1=wn-1.
	 */
	enum ActiveConstraint {
		FFB_BTB   = 0, //!< (\p SumW - \p B)+1 [~W=1, l0=w0,..., ln-1=wn-1]
		FTB_BFB   = 1, //!< \p B [ W=1,~l0=w0,...,~ln-1=wn-1]
	};
	/*!
	 * Returns the i'th literal of constraint c, i.e.
	 * - li, iff c == FFB_BTB
	 * - ~li, iff c == FTB_BFB.
	 */
	Literal  lit(uint32 i, ActiveConstraint c) const { return Literal::fromId( lits_->lit(i).id() ^ c ); }
	//! Returns the weight of the i'th literal or 1 if constraint is a cardinality constraint.
	weight_t weight(uint32 i)                  const { return lits_->weight(i); }
	//! Returns the number of literals in this constraint (including W).
	uint32   size()                            const { return lits_->size();    }
	//! Returns false if constraint is a cardinality constraint.
	bool     isWeight()                        const { return lits_->weights(); }
	// Returns the index of next literal to look at during backward propagation.
	uint32   getBpIndex()                      const { return !isWeight() ? 1 : undo_[0].data>>1; }
private:
	static WeightConstraint* doCreate(Solver& s, Literal W, WeightLitsRep& rep, uint32 flags);
	bool                     integrateRoot(Solver& s);
	struct WL {
		WL(uint32 s, bool shared, bool w);
		bool     shareable()      const { return rc != 0; }
		bool     unique()         const { return rc == 0 || refCount() == 1; }
		bool     weights()        const { return w != 0; }
		uint32   size()           const { return sz; }
		Literal  lit(uint32 i)    const { return lits[(i<> 2; }
		ActiveConstraint constraint() const { return static_cast((data&2) != 0); }
		uint32 data;
	};
	// Is literal idx contained as reason lit in the undo stack?
	bool litSeen(uint32 idx) const { return (undo_[idx].data & 1) != 0; }
	// Mark/unmark literal idx.
	void toggleLitSeen(uint32 idx) { undo_[idx].data ^= 1; }
	// Add watch for idx'th literal of c to the solver.
	void addWatch(Solver& s, uint32 idx, ActiveConstraint c);
	// Updates bound_[c] and adds an undo watch to the solver if necessary.
	// Then adds the literal at position idx to the reason set (and the undo stack).
	void updateConstraint(Solver& s, uint32 idx, ActiveConstraint c);
	// Returns the starting index of the undo stack.
	uint32   undoStart()       const { return isWeight(); }
	UndoInfo undoTop()         const { assert(up_ != undoStart()); return undo_[up_-1]; }
	// Returns the decision level of the last assigned literal
	// or 0 if no literal was assigned yet.
	uint32   highestUndoLevel(Solver&) const;
	void     setBpIndex(uint32 n);
	WL*      lits_;        // literals of constraint
	uint32   up_     : 27; // undo position; [undoStart(), up_) is the undo stack
	uint32   ownsLit_:  1; // owns lits_?
	uint32   active_ :  2; // which of the two sub-constraints is currently unit?
	uint32   watched_:  2; // which constraint is watched (3 both, 2 ignore, FTB_BFB, FFB_BTB)
	weight_t bound_[2];    // FFB_BTB: (sumW-bound)+1 / FTB_BFB: bound
CLASP_WARNING_BEGIN_RELAXED
	UndoInfo undo_[0];     // undo stack + seen flag for each literal
CLASP_WARNING_END_RELAXED
};
}

#endif
clasp-3.2.2/libclasp/doc/000077500000000000000000000000001304134206100151505ustar00rootroot00000000000000clasp-3.2.2/libclasp/doc/api/000077500000000000000000000000001304134206100157215ustar00rootroot00000000000000clasp-3.2.2/libclasp/doc/api/clasp000066400000000000000000002254721304134206100167620ustar00rootroot00000000000000# Doxyfile 1.8.1.2

# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project.
#
# All text after a hash (#) is considered a comment and will be ignored.
# The format is:
#       TAG = value [value, ...]
# For lists items can also be appended using:
#       TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ").

#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------

# This tag specifies the encoding used for all characters in the config file
# that follow. The default is UTF-8 which is also the encoding used for all
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
# iconv built into libc) for the transcoding. See
# http://www.gnu.org/software/libiconv for the list of possible encodings.

DOXYFILE_ENCODING      = UTF-8

# The PROJECT_NAME tag is a single word (or sequence of words) that should
# identify the project. Note that if you do not use Doxywizard you need
# to put quotes around the project name if it contains spaces.

PROJECT_NAME           = libclasp

# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or
# if some version control system is used.

PROJECT_NUMBER         = 3.2

# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer
# a quick idea about the purpose of the project. Keep the description short.

PROJECT_BRIEF          =

# With the PROJECT_LOGO tag one can specify an logo or icon that is
# included in the documentation. The maximum height of the logo should not
# exceed 55 pixels and the maximum width should not exceed 200 pixels.
# Doxygen will copy the logo to the output directory.

PROJECT_LOGO           =

# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
# If a relative path is entered, it will be relative to the location
# where doxygen was started. If left blank the current directory will be used.

OUTPUT_DIRECTORY       =

# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
# 4096 sub-directories (in 2 levels) under the output directory of each output
# format and will distribute the generated files over these directories.
# Enabling this option can be useful when feeding doxygen a huge amount of
# source files, where putting all generated files in the same directory would
# otherwise cause performance problems for the file system.

CREATE_SUBDIRS         = NO

# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# The default language is English, other supported languages are:
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.

OUTPUT_LANGUAGE        = English

# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
# include brief member descriptions after the members that are listed in
# the file and class documentation (similar to JavaDoc).
# Set to NO to disable this.

BRIEF_MEMBER_DESC      = YES

# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
# the brief description of a member or function before the detailed description.
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.

REPEAT_BRIEF           = YES

# This tag implements a quasi-intelligent brief description abbreviator
# that is used to form the text in various listings. Each string
# in this list, if found as the leading text of the brief description, will be
# stripped from the text and the result after processing the whole list, is
# used as the annotated text. Otherwise, the brief description is used as-is.
# If left blank, the following values are used ("$name" is automatically
# replaced with the name of the entity): "The $name class" "The $name widget"
# "The $name file" "is" "provides" "specifies" "contains"
# "represents" "a" "an" "the"

ABBREVIATE_BRIEF       =

# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# Doxygen will generate a detailed section even if there is only a brief
# description.

ALWAYS_DETAILED_SEC    = NO

# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
# inherited members of a class in the documentation of that class as if those
# members were ordinary class members. Constructors, destructors and assignment
# operators of the base classes will not be shown.

INLINE_INHERITED_MEMB  = NO

# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
# path before files name in the file list and in the header files. If set
# to NO the shortest path that makes the file name unique will be used.

FULL_PATH_NAMES        = YES

# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
# can be used to strip a user-defined part of the path. Stripping is
# only done if one of the specified strings matches the left-hand part of
# the path. The tag can be used to show relative paths in the file list.
# If left blank the directory from which doxygen is run is used as the
# path to strip.

STRIP_FROM_PATH        =

# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
# the path mentioned in the documentation of a class, which tells
# the reader which header file to include in order to use a class.
# If left blank only the name of the header file containing the class
# definition is used. Otherwise one should specify the include paths that
# are normally passed to the compiler using the -I flag.

STRIP_FROM_INC_PATH    =

# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
# (but less readable) file names. This can be useful if your file system
# doesn't support long names like on DOS, Mac, or CD-ROM.

SHORT_NAMES            = NO

# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
# will interpret the first line (until the first dot) of a JavaDoc-style
# comment as the brief description. If set to NO, the JavaDoc
# comments will behave just like regular Qt-style comments
# (thus requiring an explicit @brief command for a brief description.)

JAVADOC_AUTOBRIEF      = NO

# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
# interpret the first line (until the first dot) of a Qt-style
# comment as the brief description. If set to NO, the comments
# will behave just like regular Qt-style comments (thus requiring
# an explicit \brief command for a brief description.)

QT_AUTOBRIEF           = NO

# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
# comments) as a brief description. This used to be the default behaviour.
# The new default is to treat a multi-line C++ comment block as a detailed
# description. Set this tag to YES if you prefer the old behaviour instead.

MULTILINE_CPP_IS_BRIEF = NO

# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# re-implements.

INHERIT_DOCS           = YES

# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
# a new page for each member. If set to NO, the documentation of a member will
# be part of the file/class/namespace that contains it.

SEPARATE_MEMBER_PAGES  = NO

# The TAB_SIZE tag can be used to set the number of spaces in a tab.
# Doxygen uses this value to replace tabs by spaces in code fragments.

TAB_SIZE               = 2

# This tag can be used to specify a number of aliases that acts
# as commands in the documentation. An alias has the form "name=value".
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
# put the command \sideeffect (or @sideeffect) in the documentation, which
# will result in a user-defined paragraph with heading "Side Effects:".
# You can put \n's in the value part of an alias to insert newlines.

ALIASES                =

# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding
# "class=itcl::class" will allow you to use the command class in the
# itcl::class meaning.

TCL_SUBST              =

# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
# sources only. Doxygen will then generate output that is more tailored for C.
# For instance, some of the names that are used will be different. The list
# of all members will be omitted, etc.

OPTIMIZE_OUTPUT_FOR_C  = NO

# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
# sources only. Doxygen will then generate output that is more tailored for
# Java. For instance, namespaces will be presented as packages, qualified
# scopes will look different, etc.

OPTIMIZE_OUTPUT_JAVA   = NO

# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources only. Doxygen will then generate output that is more tailored for
# Fortran.

OPTIMIZE_FOR_FORTRAN   = NO

# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
# sources. Doxygen will then generate output that is tailored for
# VHDL.

OPTIMIZE_OUTPUT_VHDL   = NO

# Doxygen selects the parser to use depending on the extension of the files it
# parses. With this tag you can assign which parser to use for a given extension.
# Doxygen has a built-in mapping, but you can override or extend it using this
# tag. The format is ext=language, where ext is a file extension, and language
# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.

EXTENSION_MAPPING      =

# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
# comments according to the Markdown format, which allows for more readable
# documentation. See http://daringfireball.net/projects/markdown/ for details.
# The output of markdown processing is further processed by doxygen, so you
# can mix doxygen, HTML, and XML commands with Markdown formatting.
# Disable only in case of backward compatibilities issues.

MARKDOWN_SUPPORT       = YES

# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
# to include (a tag file for) the STL sources as input, then you should
# set this tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
# func(std::string) {}). This also makes the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.

BUILTIN_STL_SUPPORT    = YES

# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.

CPP_CLI_SUPPORT        = NO

# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
# Doxygen will parse them like normal C++ but will assume all classes use public
# instead of private inheritance when no explicit protection keyword is present.

SIP_SUPPORT            = NO

# For Microsoft's IDL there are propget and propput attributes to indicate getter
# and setter methods for a property. Setting this option to YES (the default)
# will make doxygen replace the get and set methods by a property in the
# documentation. This will only work if the methods are indeed getting or
# setting a simple type. If this is not the case, or you want to show the
# methods anyway, you should set this option to NO.

IDL_PROPERTY_SUPPORT   = YES

# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.

DISTRIBUTE_GROUP_DOC   = NO

# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
# the same type (for instance a group of public functions) to be put as a
# subgroup of that type (e.g. under the Public Functions section). Set it to
# NO to prevent subgrouping. Alternatively, this can be done per class using
# the \nosubgrouping command.

SUBGROUPING            = YES

# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
# unions are shown inside the group in which they are included (e.g. using
# @ingroup) instead of on a separate page (for HTML and Man pages) or
# section (for LaTeX and RTF).

INLINE_GROUPED_CLASSES = NO

# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
# unions with only public data fields will be shown inline in the documentation
# of the scope in which they are defined (i.e. file, namespace, or group
# documentation), provided this scope is documented. If set to NO (the default),
# structs, classes, and unions are shown on a separate page (for HTML and Man
# pages) or section (for LaTeX and RTF).

INLINE_SIMPLE_STRUCTS  = NO

# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
# is documented as struct, union, or enum with the name of the typedef. So
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
# with name TypeT. When disabled the typedef will appear as a member of a file,
# namespace, or class. And the struct will be named TypeS. This can typically
# be useful for C code in case the coding convention dictates that all compound
# types are typedef'ed and only the typedef is referenced, never the tag name.

TYPEDEF_HIDES_STRUCT   = NO

# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penalty.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will roughly double the
# memory usage. The cache size is given by this formula:
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols.

SYMBOL_CACHE_SIZE      = 0

# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
# their name and scope. Since this can be an expensive process and often the
# same symbol appear multiple times in the code, doxygen keeps a cache of
# pre-resolved symbols. If the cache is too small doxygen will become slower.
# If the cache is too large, memory is wasted. The cache size is given by this
# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols.

LOOKUP_CACHE_SIZE      = 0

#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------

# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
# documentation are documented, even if no documentation was available.
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES

EXTRACT_ALL            = NO

# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.

EXTRACT_PRIVATE        = NO

# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal scope will be included in the documentation.

EXTRACT_PACKAGE        = NO

# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.

EXTRACT_STATIC         = NO

# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
# defined locally in source files will be included in the documentation.
# If set to NO only classes defined in header files are included.

EXTRACT_LOCAL_CLASSES  = NO

# This flag is only useful for Objective-C code. When set to YES local
# methods, which are defined in the implementation section but not in
# the interface are included in the documentation.
# If set to NO (the default) only methods in the interface are included.

EXTRACT_LOCAL_METHODS  = NO

# If this flag is set to YES, the members of anonymous namespaces will be
# extracted and appear in the documentation as a namespace called
# 'anonymous_namespace{file}', where file will be replaced with the base
# name of the file that contains the anonymous namespace. By default
# anonymous namespaces are hidden.

EXTRACT_ANON_NSPACES   = NO

# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
# undocumented members of documented classes, files or namespaces.
# If set to NO (the default) these members will be included in the
# various overviews, but no documentation section is generated.
# This option has no effect if EXTRACT_ALL is enabled.

HIDE_UNDOC_MEMBERS     = NO

# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy.
# If set to NO (the default) these classes will be included in the various
# overviews. This option has no effect if EXTRACT_ALL is enabled.

HIDE_UNDOC_CLASSES     = NO

# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
# friend (class|struct|union) declarations.
# If set to NO (the default) these declarations will be included in the
# documentation.

HIDE_FRIEND_COMPOUNDS  = NO

# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
# documentation blocks found inside the body of a function.
# If set to NO (the default) these blocks will be appended to the
# function's detailed documentation block.

HIDE_IN_BODY_DOCS      = NO

# The INTERNAL_DOCS tag determines if documentation
# that is typed after a \internal command is included. If the tag is set
# to NO (the default) then the documentation will be excluded.
# Set it to YES to include the internal documentation.

INTERNAL_DOCS          = NO

# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
# file names in lower-case letters. If set to YES upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# and Mac users are advised to set this option to NO.

CASE_SENSE_NAMES       = NO

# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
# will show members with their full class and namespace scopes in the
# documentation. If set to YES the scope will be hidden.

HIDE_SCOPE_NAMES       = NO

# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
# will put a list of the files that are included by a file in the documentation
# of that file.

SHOW_INCLUDE_FILES     = YES

# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
# will list include files with double quotes in the documentation
# rather than with sharp brackets.

FORCE_LOCAL_INCLUDES   = NO

# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
# is inserted in the documentation for inline members.

INLINE_INFO            = YES

# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
# will sort the (detailed) documentation of file and class members
# alphabetically by member name. If set to NO the members will appear in
# declaration order.

SORT_MEMBER_DOCS       = NO

# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
# brief documentation of file, namespace and class members alphabetically
# by member name. If set to NO (the default) the members will appear in
# declaration order.

SORT_BRIEF_DOCS        = NO

# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
# will sort the (brief and detailed) documentation of class members so that
# constructors and destructors are listed first. If set to NO (the default)
# the constructors will appear in the respective orders defined by
# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.

SORT_MEMBERS_CTORS_1ST = NO

# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
# hierarchy of group names into alphabetical order. If set to NO (the default)
# the group names will appear in their defined order.

SORT_GROUP_NAMES       = NO

# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
# sorted by fully-qualified names, including namespaces. If set to
# NO (the default), the class list will be sorted only by class name,
# not including the namespace part.
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
# Note: This option applies only to the class list, not to the
# alphabetical list.

SORT_BY_SCOPE_NAME     = NO

# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
# do proper type resolution of all parameters of a function it will reject a
# match between the prototype and the implementation of a member function even
# if there is only one candidate or it is obvious which candidate to choose
# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
# will still accept a match between prototype and implementation in such cases.

STRICT_PROTO_MATCHING  = NO

# The GENERATE_TODOLIST tag can be used to enable (YES) or
# disable (NO) the todo list. This list is created by putting \todo
# commands in the documentation.

GENERATE_TODOLIST      = NO

# The GENERATE_TESTLIST tag can be used to enable (YES) or
# disable (NO) the test list. This list is created by putting \test
# commands in the documentation.

GENERATE_TESTLIST      = NO

# The GENERATE_BUGLIST tag can be used to enable (YES) or
# disable (NO) the bug list. This list is created by putting \bug
# commands in the documentation.

GENERATE_BUGLIST       = NO

# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
# disable (NO) the deprecated list. This list is created by putting
# \deprecated commands in the documentation.

GENERATE_DEPRECATEDLIST= NO

# The ENABLED_SECTIONS tag can be used to enable conditional
# documentation sections, marked by \if sectionname ... \endif.

ENABLED_SECTIONS       =

# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
# the initial value of a variable or macro consists of for it to appear in
# the documentation. If the initializer consists of more lines than specified
# here it will be hidden. Use a value of 0 to hide initializers completely.
# The appearance of the initializer of individual variables and macros in the
# documentation can be controlled using \showinitializer or \hideinitializer
# command in the documentation regardless of this setting.

MAX_INITIALIZER_LINES  = 30

# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
# at the bottom of the documentation of classes and structs. If set to YES the
# list will mention the files that were used to generate the documentation.

SHOW_USED_FILES        = YES

# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
# This will remove the Files entry from the Quick Index and from the
# Folder Tree View (if specified). The default is YES.

SHOW_FILES             = YES

# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
# Namespaces page.
# This will remove the Namespaces entry from the Quick Index
# and from the Folder Tree View (if specified). The default is YES.

SHOW_NAMESPACES        = YES

# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
# popen()) the command  , where  is the value of
# the FILE_VERSION_FILTER tag, and  is the name of an input file
# provided by doxygen. Whatever the program writes to standard output
# is used as the file version. See the manual for examples.

FILE_VERSION_FILTER    =

# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
# by doxygen. The layout file controls the global structure of the generated
# output files in an output format independent way. To create the layout file
# that represents doxygen's defaults, run doxygen with the -l option.
# You can optionally specify a file name after the option, if omitted
# DoxygenLayout.xml will be used as the name of the layout file.

LAYOUT_FILE            =

# The CITE_BIB_FILES tag can be used to specify one or more bib files
# containing the references data. This must be a list of .bib files. The
# .bib extension is automatically appended if omitted. Using this command
# requires the bibtex tool to be installed. See also
# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
# feature you need bibtex and perl available in the search path.

CITE_BIB_FILES         =

#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------

# The QUIET tag can be used to turn on/off the messages that are generated
# by doxygen. Possible values are YES and NO. If left blank NO is used.

QUIET                  = NO

# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated by doxygen. Possible values are YES and NO. If left blank
# NO is used.

WARNINGS               = YES

# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
# automatically be disabled.

WARN_IF_UNDOCUMENTED   = NO

# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some
# parameters in a documented function, or documenting parameters that
# don't exist or using markup commands wrongly.

WARN_IF_DOC_ERROR      = YES

# The WARN_NO_PARAMDOC option can be enabled to get warnings for
# functions that are documented, but have no documentation for their parameters
# or return value. If set to NO (the default) doxygen will only warn about
# wrong or incomplete parameter documentation, but not about the absence of
# documentation.

WARN_NO_PARAMDOC       = NO

# The WARN_FORMAT tag determines the format of the warning messages that
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text. Optionally the format may contain
# $version, which will be replaced by the version of the file (if it could
# be obtained via FILE_VERSION_FILTER)

WARN_FORMAT            = "$file($line): $text"

# The WARN_LOGFILE tag can be used to specify a file to which warning
# and error messages should be written. If left blank the output is written
# to stderr.

WARN_LOGFILE           =

#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------

# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.

INPUT                  = clasp.txt ../../clasp ../../clasp/cli ../../src

# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
# also the default input encoding. Doxygen uses libiconv (or the iconv built
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
# the list of possible encodings.

INPUT_ENCODING         = UTF-8

# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank the following patterns are tested:
# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
# *.f90 *.f *.for *.vhd *.vhdl

FILE_PATTERNS          = 

# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
# If left blank NO is used.

RECURSIVE              = YES

# The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
# Note that relative paths are relative to the directory from which doxygen is
# run.

EXCLUDE                =

# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.

EXCLUDE_SYMLINKS       = NO

# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*

EXCLUDE_PATTERNS       =

# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test

EXCLUDE_SYMBOLS        =

# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see
# the \include command).

EXAMPLE_PATH           = ../../example

# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.

EXAMPLE_PATTERNS       =

# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude
# commands irrespective of the value of the RECURSIVE tag.
# Possible values are YES and NO. If left blank NO is used.

EXAMPLE_RECURSIVE      = NO

# The IMAGE_PATH tag can be used to specify one or more files or
# directories that contain image that are included in the documentation (see
# the \image command).

IMAGE_PATH             =

# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command  , where 
# is the value of the INPUT_FILTER tag, and  is the name of an
# input file. Doxygen will then use the output that the filter program writes
# to standard output.
# If FILTER_PATTERNS is specified, this tag will be
# ignored.

INPUT_FILTER           =

# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis.
# Doxygen will compare the file name with each pattern and apply the
# filter if there is a match.
# The filters are a list of the form:
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
# info on how filters are used. If FILTER_PATTERNS is empty or if
# non of the patterns match the file name, INPUT_FILTER is applied.

FILTER_PATTERNS        =

# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will be used to filter the input files when producing source
# files to browse (i.e. when SOURCE_BROWSER is set to YES).

FILTER_SOURCE_FILES    = NO

# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
# and it is also possible to disable source filtering for a specific pattern
# using *.ext= (so without naming a filter). This option only has effect when
# FILTER_SOURCE_FILES is enabled.

FILTER_SOURCE_PATTERNS =

#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------

# If the SOURCE_BROWSER tag is set to YES then a list of source files will
# be generated. Documented entities will be cross-referenced with these sources.
# Note: To get rid of all source code in the generated output, make sure also
# VERBATIM_HEADERS is set to NO.

SOURCE_BROWSER         = YES

# Setting the INLINE_SOURCES tag to YES will include the body
# of functions and classes directly in the documentation.

INLINE_SOURCES         = NO

# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
# doxygen to hide any special comment blocks from generated source code
# fragments. Normal C, C++ and Fortran comments will always remain visible.

STRIP_CODE_COMMENTS    = YES

# If the REFERENCED_BY_RELATION tag is set to YES
# then for each documented function all documented
# functions referencing it will be listed.

REFERENCED_BY_RELATION = YES

# If the REFERENCES_RELATION tag is set to YES
# then for each documented function all documented entities
# called/used by that function will be listed.

REFERENCES_RELATION    = YES

# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
# link to the source code.
# Otherwise they will link to the documentation.

REFERENCES_LINK_SOURCE = YES

# If the USE_HTAGS tag is set to YES then the references to source code
# will point to the HTML generated by the htags(1) tool instead of doxygen
# built-in source browser. The htags tool is part of GNU's global source
# tagging system (see http://www.gnu.org/software/global/global.html). You
# will need version 4.8.6 or higher.

USE_HTAGS              = NO

# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
# will generate a verbatim copy of the header file for each class for
# which an include is specified. Set to NO to disable this.

VERBATIM_HEADERS       = YES

#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------

# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.

ALPHABETICAL_INDEX     = NO

# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])

COLS_IN_ALPHA_INDEX    = 5

# In case all classes in a project start with a common prefix, all
# classes will be put under the same header in the alphabetical index.
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
# should be ignored while generating the index headers.

IGNORE_PREFIX          =

#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------

# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
# generate HTML output.

GENERATE_HTML          = YES

# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `html' will be used as the default path.

HTML_OUTPUT            = html

# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
# doxygen will generate files with .html extension.

HTML_FILE_EXTENSION    = .html

# The HTML_HEADER tag can be used to specify a personal HTML header for
# each generated HTML page. If it is left blank doxygen will generate a
# standard header. Note that when using a custom header you are responsible
#  for the proper inclusion of any scripts and style sheets that doxygen
# needs, which is dependent on the configuration options used.
# It is advised to generate a default header using "doxygen -w html
# header.html footer.html stylesheet.css YourConfigFile" and then modify
# that header. Note that the header is subject to change so you typically
# have to redo this when upgrading to a newer version of doxygen or when
# changing the value of configuration settings such as GENERATE_TREEVIEW!

HTML_HEADER            =

# The HTML_FOOTER tag can be used to specify a personal HTML footer for
# each generated HTML page. If it is left blank doxygen will generate a
# standard footer.

HTML_FOOTER            =

# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
# style sheet that is used by each HTML page. It can be used to
# fine-tune the look of the HTML output. If the tag is left blank doxygen
# will generate a default style sheet. Note that doxygen will try to copy
# the style sheet file to the HTML output directory, so don't put your own
# style sheet in the HTML output directory as well, or it will be erased!

HTML_STYLESHEET        =

# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
# files. In the HTML_STYLESHEET file, use the file name only. Also note that
# the files will be copied as-is; there are no commands or markers available.

HTML_EXTRA_FILES       =

# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
# Doxygen will adjust the colors in the style sheet and background images
# according to this color. Hue is specified as an angle on a colorwheel,
# see http://en.wikipedia.org/wiki/Hue for more information.
# For instance the value 0 represents red, 60 is yellow, 120 is green,
# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
# The allowed range is 0 to 359.

HTML_COLORSTYLE_HUE    = 220

# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
# the colors in the HTML output. For a value of 0 the output will use
# grayscales only. A value of 255 will produce the most vivid colors.

HTML_COLORSTYLE_SAT    = 100

# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
# the luminance component of the colors in the HTML output. Values below
# 100 gradually make the output lighter, whereas values above 100 make
# the output darker. The value divided by 100 is the actual gamma applied,
# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
# and 100 does not change the gamma.

HTML_COLORSTYLE_GAMMA  = 80

# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
# page will contain the date and time when the page was generated. Setting
# this to NO can help when comparing the output of multiple runs.

HTML_TIMESTAMP         = YES

# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded.

HTML_DYNAMIC_SECTIONS  = NO

# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
# entries shown in the various tree structured indices initially; the user
# can expand and collapse entries dynamically later on. Doxygen will expand
# the tree to such a level that at most the specified number of entries are
# visible (unless a fully collapsed tree already exceeds this amount).
# So setting the number of entries 1 will produce a full collapsed tree by
# default. 0 is a special value representing an infinite number of entries
# and will result in a full expanded tree by default.

HTML_INDEX_NUM_ENTRIES = 100

# If the GENERATE_DOCSET tag is set to YES, additional index files
# will be generated that can be used as input for Apple's Xcode 3
# integrated development environment, introduced with OSX 10.5 (Leopard).
# To create a documentation set, doxygen will generate a Makefile in the
# HTML output directory. Running make will produce the docset in that
# directory and running "make install" will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
# it at startup.
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
# for more information.

GENERATE_DOCSET        = NO

# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
# feed. A documentation feed provides an umbrella under which multiple
# documentation sets from a single provider (such as a company or product suite)
# can be grouped.

DOCSET_FEEDNAME        = "Doxygen generated docs"

# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
# should uniquely identify the documentation set bundle. This should be a
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
# will append .docset to the name.

DOCSET_BUNDLE_ID       = org.doxygen.Project

# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
# the documentation publisher. This should be a reverse domain-name style
# string, e.g. com.mycompany.MyDocSet.documentation.

DOCSET_PUBLISHER_ID    = org.doxygen.Publisher

# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.

DOCSET_PUBLISHER_NAME  = Publisher

# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
# of the generated HTML documentation.

GENERATE_HTMLHELP      = NO

# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
# be used to specify the file name of the resulting .chm file. You
# can add a path in front of the file if the result should not be
# written to the html output directory.

CHM_FILE               =

# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
# be used to specify the location (absolute path including file name) of
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
# the HTML help compiler on the generated index.hhp.

HHC_LOCATION           =

# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
# controls if a separate .chi index file is generated (YES) or that
# it should be included in the master .chm file (NO).

GENERATE_CHI           = NO

# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
# content.

CHM_INDEX_ENCODING     =

# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
# controls whether a binary table of contents is generated (YES) or a
# normal table of contents (NO) in the .chm file.

BINARY_TOC             = NO

# The TOC_EXPAND flag can be set to YES to add extra items for group members
# to the contents of the HTML help documentation and to the tree view.

TOC_EXPAND             = NO

# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
# that can be used as input for Qt's qhelpgenerator to generate a
# Qt Compressed Help (.qch) of the generated HTML documentation.

GENERATE_QHP           = NO

# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
# be used to specify the file name of the resulting .qch file.
# The path specified is relative to the HTML output folder.

QCH_FILE               =

# The QHP_NAMESPACE tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#namespace

QHP_NAMESPACE          = org.doxygen.Project

# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#virtual-folders

QHP_VIRTUAL_FOLDER     = doc

# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
# add. For more information please see
# http://doc.trolltech.com/qthelpproject.html#custom-filters

QHP_CUST_FILTER_NAME   =

# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see
# 
# Qt Help Project / Custom Filters.

QHP_CUST_FILTER_ATTRS  =

# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's
# filter section matches.
# 
# Qt Help Project / Filter Attributes.

QHP_SECT_FILTER_ATTRS  =

# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
# be used to specify the location of Qt's qhelpgenerator.
# If non-empty doxygen will try to run qhelpgenerator on the generated
# .qhp file.

QHG_LOCATION           =

# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
#  will be generated, which together with the HTML files, form an Eclipse help
# plugin. To install this plugin and make it available under the help contents
# menu in Eclipse, the contents of the directory containing the HTML and XML
# files needs to be copied into the plugins directory of eclipse. The name of
# the directory within the plugins directory should be the same as
# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
# the help appears.

GENERATE_ECLIPSEHELP   = NO

# A unique identifier for the eclipse help plugin. When installing the plugin
# the directory name containing the HTML and XML files should also have
# this name.

ECLIPSE_DOC_ID         = org.doxygen.Project

# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
# at top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it. Since the tabs have the same information as the
# navigation tree you can set this option to NO if you already set
# GENERATE_TREEVIEW to YES.

DISABLE_INDEX          = NO

# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information.
# If the tag value is set to YES, a side panel will be generated
# containing a tree-like index structure (just like the one that
# is generated for HTML Help). For this to work a browser that supports
# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
# Windows users are probably better off using the HTML help feature.
# Since the tree basically has the same information as the tab index you
# could consider to set DISABLE_INDEX to NO when enabling this option.

GENERATE_TREEVIEW      = NO

# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
# (range [0,1..20]) that doxygen will group on one line in the generated HTML
# documentation. Note that a value of 0 will completely suppress the enum
# values from appearing in the overview section.

ENUM_VALUES_PER_LINE   = 4

# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
# used to set the initial width (in pixels) of the frame in which the tree
# is shown.

TREEVIEW_WIDTH         = 250

# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
# links to external symbols imported via tag files in a separate window.

EXT_LINKS_IN_WINDOW    = NO

# Use this tag to change the font size of Latex formulas included
# as images in the HTML documentation. The default is 10. Note that
# when you change the font size after a successful doxygen run you need
# to manually remove any form_*.png images from the HTML output directory
# to force them to be regenerated.

FORMULA_FONTSIZE       = 10

# Use the FORMULA_TRANPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are
# not supported properly for IE 6.0, but are supported on all modern browsers.
# Note that when changing this option you need to delete any form_*.png files
# in the HTML output before the changes have effect.

FORMULA_TRANSPARENT    = YES

# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
# (see http://www.mathjax.org) which uses client side Javascript for the
# rendering instead of using prerendered bitmaps. Use this if you do not
# have LaTeX installed or if you want to formulas look prettier in the HTML
# output. When enabled you may also need to install MathJax separately and
# configure the path to it using the MATHJAX_RELPATH option.

USE_MATHJAX            = NO

# When MathJax is enabled you need to specify the location relative to the
# HTML output directory using the MATHJAX_RELPATH option. The destination
# directory should contain the MathJax.js script. For instance, if the mathjax
# directory is located at the same level as the HTML output directory, then
# MATHJAX_RELPATH should be ../mathjax. The default value points to
# the MathJax Content Delivery Network so you can quickly see the result without
# installing MathJax.
# However, it is strongly recommended to install a local
# copy of MathJax from http://www.mathjax.org before deployment.

MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest

# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
# names that should be enabled during MathJax rendering.

MATHJAX_EXTENSIONS     =

# When the SEARCHENGINE tag is enabled doxygen will generate a search box
# for the HTML output. The underlying search engine uses javascript
# and DHTML and should work on any modern browser. Note that when using
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
# (GENERATE_DOCSET) there is already a search function so this one should
# typically be disabled. For large projects the javascript based search engine
# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.

SEARCHENGINE           = NO

# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a PHP enabled web server instead of at the web client
# using Javascript. Doxygen will generate the search PHP script and index
# file to put on the web server. The advantage of the server
# based approach is that it scales better to large projects and allows
# full text search. The disadvantages are that it is more difficult to setup
# and does not have live searching capabilities.

SERVER_BASED_SEARCH    = NO

#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------

# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
# generate Latex output.

GENERATE_LATEX         = NO

# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `latex' will be used as the default path.

LATEX_OUTPUT           = latex

# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked. If left blank `latex' will be used as the default command name.
# Note that when enabling USE_PDFLATEX this option is only used for
# generating bitmaps for formulas in the HTML output, but not in the
# Makefile that is written to the output directory.

LATEX_CMD_NAME         = latex

# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
# generate index for LaTeX. If left blank `makeindex' will be used as the
# default command name.

MAKEINDEX_CMD_NAME     = makeindex

# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
# LaTeX documents. This may be useful for small projects and may help to
# save some trees in general.

COMPACT_LATEX          = NO

# The PAPER_TYPE tag can be used to set the paper type that is used
# by the printer. Possible values are: a4, letter, legal and
# executive. If left blank a4wide will be used.

PAPER_TYPE             = a4wide

# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
# packages that should be included in the LaTeX output.

EXTRA_PACKAGES         =

# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
# the generated latex document. The header should contain everything until
# the first chapter. If it is left blank doxygen will generate a
# standard header. Notice: only use this tag if you know what you are doing!

LATEX_HEADER           =

# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
# the generated latex document. The footer should contain everything after
# the last chapter. If it is left blank doxygen will generate a
# standard footer. Notice: only use this tag if you know what you are doing!

LATEX_FOOTER           =

# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
# contain links (just like the HTML output) instead of page references
# This makes the output suitable for online browsing using a pdf viewer.

PDF_HYPERLINKS         = NO

# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
# plain latex in the generated Makefile. Set this option to YES to get a
# higher quality PDF documentation.

USE_PDFLATEX           = NO

# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
# command to the generated LaTeX files. This will instruct LaTeX to keep
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.

LATEX_BATCHMODE        = NO

# If LATEX_HIDE_INDICES is set to YES then doxygen will not
# include the index chapters (such as File Index, Compound Index, etc.)
# in the output.

LATEX_HIDE_INDICES     = NO

# If LATEX_SOURCE_CODE is set to YES then doxygen will include
# source code with syntax highlighting in the LaTeX output.
# Note that which sources are shown also depends on other settings
# such as SOURCE_BROWSER.

LATEX_SOURCE_CODE      = NO

# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
# http://en.wikipedia.org/wiki/BibTeX for more info.

LATEX_BIB_STYLE        = plain

#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------

# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
# The RTF output is optimized for Word 97 and may not look very pretty with
# other RTF readers or editors.

GENERATE_RTF           = NO

# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `rtf' will be used as the default path.

RTF_OUTPUT             = rtf

# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
# RTF documents. This may be useful for small projects and may help to
# save some trees in general.

COMPACT_RTF            = NO

# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
# will contain hyperlink fields. The RTF file will
# contain links (just like the HTML output) instead of page references.
# This makes the output suitable for online browsing using WORD or other
# programs which support those fields.
# Note: wordpad (write) and others do not support links.

RTF_HYPERLINKS         = NO

# Load style sheet definitions from file. Syntax is similar to doxygen's
# config file, i.e. a series of assignments. You only have to provide
# replacements, missing definitions are set to their default value.

RTF_STYLESHEET_FILE    =

# Set optional variables used in the generation of an rtf document.
# Syntax is similar to doxygen's config file.

RTF_EXTENSIONS_FILE    =

#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------

# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
# generate man pages

GENERATE_MAN           = NO

# The MAN_OUTPUT tag is used to specify where the man pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `man' will be used as the default path.

MAN_OUTPUT             = man

# The MAN_EXTENSION tag determines the extension that is added to
# the generated man pages (default is the subroutine's section .3)

MAN_EXTENSION          = .3

# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
# then it will generate one additional man file for each entity
# documented in the real man page(s). These additional files
# only source the real man page, but without them the man command
# would be unable to find the correct page. The default is NO.

MAN_LINKS              = NO

#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------

# If the GENERATE_XML tag is set to YES Doxygen will
# generate an XML file that captures the structure of
# the code including all documentation.

GENERATE_XML           = NO

# The XML_OUTPUT tag is used to specify where the XML pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `xml' will be used as the default path.

XML_OUTPUT             = xml

# The XML_SCHEMA tag can be used to specify an XML schema,
# which can be used by a validating XML parser to check the
# syntax of the XML files.

XML_SCHEMA             =

# The XML_DTD tag can be used to specify an XML DTD,
# which can be used by a validating XML parser to check the
# syntax of the XML files.

XML_DTD                =

# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
# dump the program listings (including syntax highlighting
# and cross-referencing information) to the XML output. Note that
# enabling this will significantly increase the size of the XML output.

XML_PROGRAMLISTING     = YES

#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------

# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
# generate an AutoGen Definitions (see autogen.sf.net) file
# that captures the structure of the code including all
# documentation. Note that this feature is still experimental
# and incomplete at the moment.

GENERATE_AUTOGEN_DEF   = NO

#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------

# If the GENERATE_PERLMOD tag is set to YES Doxygen will
# generate a Perl module file that captures the structure of
# the code including all documentation. Note that this
# feature is still experimental and incomplete at the
# moment.

GENERATE_PERLMOD       = NO

# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
# to generate PDF and DVI output from the Perl module output.

PERLMOD_LATEX          = NO

# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
# nicely formatted so it can be parsed by a human reader.
# This is useful
# if you want to understand what is going on.
# On the other hand, if this
# tag is set to NO the size of the Perl module output will be much smaller
# and Perl will parse it just the same.

PERLMOD_PRETTY         = YES

# The names of the make variables in the generated doxyrules.make file
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
# This is useful so different doxyrules.make files included by the same
# Makefile don't overwrite each other's variables.

PERLMOD_MAKEVAR_PREFIX =

#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------

# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
# evaluate all C-preprocessor directives found in the sources and include
# files.

ENABLE_PREPROCESSING   = YES

# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
# names in the source code. If set to NO (the default) only conditional
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.

MACRO_EXPANSION        = YES

# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_DEFINED tags.

EXPAND_ONLY_PREDEF     = YES

# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# pointed to by INCLUDE_PATH will be searched when a #include is found.

SEARCH_INCLUDES        = YES

# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by
# the preprocessor.

INCLUDE_PATH           = ../../

# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will
# be used.

INCLUDE_FILE_PATTERNS  =

# The PREDEFINED tag can be used to specify one or more macro names that
# are defined before the preprocessor is started (similar to the -D option of
# gcc). The argument of the tag is a list of macros of the form: name
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed. To prevent a macro definition from being
# undefined via #undef or recursively expanded use the := operator
# instead of the = operator.

PREDEFINED             = WITH_THREADS=1 "DOXY(X)=/*!< \brief X */"

# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition that
# overrules the definition found in the source code.

EXPAND_AS_DEFINED      = CLASP_DECLARE_ISTATS CLASP_STAT_DEFINE CLASP_CORE_STATS CLASP_JUMP_STATS CLASP_EXTENDED_STATS \
                         CLASP_CLI_DEFAULT_CONFIGS CLASP_CLI_AUX_CONFIGS CONFIG

# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all references to function-like macros
# that are alone on a line, have an all uppercase name, and do not end with a
# semicolon, because these will confuse the parser if not removed.

SKIP_FUNCTION_MACROS   = YES

#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------

# The TAGFILES option can be used to specify one or more tagfiles. For each
# tag file the location of the external documentation should be added. The
# format of a tag file without this location is as follows:
#
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
#
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where "loc1" and "loc2" can be relative or absolute paths
# or URLs. Note that each tag file must have a unique name (where the name does
# NOT include the path). If a tag file is not located in the directory in which
# doxygen is run, you must also specify the path to the tagfile here.

TAGFILES               =

# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.

GENERATE_TAGFILE       =

# If the ALLEXTERNALS tag is set to YES all external classes will be listed
# in the class index. If set to NO only the inherited external classes
# will be listed.

ALLEXTERNALS           = NO

# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will
# be listed.

EXTERNAL_GROUPS        = YES

# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of `which perl').

PERL_PATH              = /usr/bin/perl

#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------

# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
# or super classes. Setting the tag to NO turns the diagrams off. Note that
# this option also works with HAVE_DOT disabled, but it is recommended to
# install and use dot, since it yields more powerful graphs.

CLASS_DIAGRAMS         = YES

# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.

MSCGEN_PATH            =

# If set to YES, the inheritance and collaboration graphs will hide
# inheritance and usage relations if the target is undocumented
# or is not a class.

HIDE_UNDOC_RELATIONS   = YES

# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz, a graph visualization
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
# have no effect if this option is set to NO (the default)

HAVE_DOT               = NO

# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
# allowed to run in parallel. When set to 0 (the default) doxygen will
# base this on the number of processors available in the system. You can set it
# explicitly to a value larger than 0 to get control over the balance
# between CPU load and processing speed.

DOT_NUM_THREADS        = 0

# By default doxygen will use the Helvetica font for all dot files that
# doxygen generates. When you want a differently looking font you can specify
# the font name using DOT_FONTNAME. You need to make sure dot is able to find
# the font, which can be done by putting it in a standard location or by setting
# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
# directory containing the font.

DOT_FONTNAME           = Helvetica

# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
# The default size is 10pt.

DOT_FONTSIZE           = 10

# By default doxygen will tell dot to use the Helvetica font.
# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
# set the path where dot can find it.

DOT_FONTPATH           =

# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
# CLASS_DIAGRAMS tag to NO.

CLASS_GRAPH            = YES

# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect implementation dependencies (inheritance, containment, and
# class references variables) of the class with other documented classes.

COLLABORATION_GRAPH    = YES

# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for groups, showing the direct groups dependencies

GROUP_GRAPHS           = YES

# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.

UML_LOOK               = YES

# If the UML_LOOK tag is enabled, the fields and methods are shown inside
# the class node. If there are many fields or methods and many nodes the
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
# threshold limits the number of items for each type to make the size more
# managable. Set this to 0 for no limit. Note that the threshold may be
# exceeded by 50% before the limit is enforced.

UML_LIMIT_NUM_FIELDS   = 10

# If set to YES, the inheritance and collaboration graphs will show the
# relations between templates and their instances.

TEMPLATE_RELATIONS     = NO

# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
# tags are set to YES then doxygen will generate a graph for each documented
# file showing the direct and indirect include dependencies of the file with
# other documented files.

INCLUDE_GRAPH          = YES

# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
# documented header file showing the documented files that directly or
# indirectly include this file.

INCLUDED_BY_GRAPH      = YES

# If the CALL_GRAPH and HAVE_DOT options are set to YES then
# doxygen will generate a call dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable call graphs
# for selected functions only using the \callgraph command.

CALL_GRAPH             = NO

# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
# doxygen will generate a caller dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable caller
# graphs for selected functions only using the \callergraph command.

CALLER_GRAPH           = NO

# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will generate a graphical hierarchy of all classes instead of a textual one.

GRAPHICAL_HIERARCHY    = YES

# If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
# then doxygen will show the dependencies a directory has on other directories
# in a graphical way. The dependency relations are determined by the #include
# relations between the files in the directories.

DIRECTORY_GRAPH        = YES

# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. Possible values are svg, png, jpg, or gif.
# If left blank png will be used. If you choose svg you need to set
# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible in IE 9+ (other browsers do not have this requirement).

DOT_IMAGE_FORMAT       = png

# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.
# Note that this requires a modern browser other than Internet Explorer.
# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible. Older versions of IE do not have SVG support.

INTERACTIVE_SVG        = NO

# The tag DOT_PATH can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.

DOT_PATH               =

# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the
# \dotfile command).

DOTFILE_DIRS           =

# The MSCFILE_DIRS tag can be used to specify one or more directories that
# contain msc files that are included in the documentation (see the
# \mscfile command).

MSCFILE_DIRS           =

# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# nodes that will be shown in the graph. If the number of nodes in a graph
# becomes larger than this value, doxygen will truncate the graph, which is
# visualized by representing a node as a red box. Note that doxygen if the
# number of direct children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.

DOT_GRAPH_MAX_NODES    = 50

# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
# graphs generated by dot. A depth value of 3 means that only nodes reachable
# from the root by following a path via at most 3 edges will be shown. Nodes
# that lay further from the root node will be omitted. Note that setting this
# option to 1 or 2 may greatly reduce the computation time needed for large
# code bases. Also note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.

MAX_DOT_GRAPH_DEPTH    = 0

# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. Warning: Depending on the platform used,
# enabling this option may lead to badly anti-aliased labels on the edges of
# a graph (i.e. they become hard to read).

DOT_TRANSPARENT        = NO

# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10)
# support this, this feature is disabled by default.

DOT_MULTI_TARGETS      = NO

# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
# generate a legend page explaining the meaning of the various boxes and
# arrows in the dot generated graphs.

GENERATE_LEGEND        = YES

# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
# remove the intermediate dot files that are used to generate
# the various graphs.

DOT_CLEANUP            = YES
clasp-3.2.2/libclasp/doc/api/clasp.txt000066400000000000000000000041431304134206100175660ustar00rootroot00000000000000/*!
\mainpage The clasp System
\author Benjamin Kaufmann (kaufmann@cs.uni-potsdam.de)
\version 3.2

clasp - the conflict-driven learning answer set programming system -
is an answer set solver for (extended) normal logic programs. It combines the high-level modeling capacities 
of answer set programming (ASP) with state-of-the-art techniques from the area of Boolean constraint solving. 
The primary clasp algorithm relies on conflict-driven learning, a technique that proved 
very successful for satisfiability checking (SAT). Unlike other ASP solvers that use 
conflict-driven learning, e.g., assat, cmodels, and 
smodels_cc, clasp does not rely on legacy 
software, such as a SAT solver or any other existing ASP solver. Rather, clasp has been genuinely 
developed for answer set solving based on conflict-driven learning.

clasp incorporates many features that are nowadays standard in state-of-the-art SAT solvers, 
like chaff, berkmin, 
minisat, siege, etc., 
but which are unusual in the context of ASP solving. 
Such techniques include:
 - conflict analysis via the FirstUIP scheme and backjumping
 - nogood recording and deletion
 - restarts
 - conflict-driven decision heuristics
 - unit propagation via watched literals
 - dedicated propagation of binary and ternary nogoods
 .

For more information please visit the clasp homepage: http://www.cs.uni-potsdam.de/clasp

  @defgroup facade Facade
  @defgroup cli Cli
  @defgroup clingo Clingo 
  @defgroup problem Input
  @defgroup constraint Constraints
  @defgroup shared SharedContext
  @defgroup solver Solver
  @defgroup heuristic Decision Heuristics
  @defgroup enumerator Solving
*/


clasp-3.2.2/libclasp/example/000077500000000000000000000000001304134206100160365ustar00rootroot00000000000000clasp-3.2.2/libclasp/example/Makefile000066400000000000000000000024141304134206100174770ustar00rootroot00000000000000SHELL        ?= /bin/sh
AR           ?= ar
CXX          ?= g++
BUILD_DIR    ?= .
ROOT_DIR     ?= ..
CXXFLAGS     ?= -O3 -DNDEBUG
FLAGS        ?=
LIBS         ?= $(ROOT_DIR)/lib/libclasp.a
ifneq ($(FLAGS),)
-include $(FLAGS)
endif
INCLUDE      := -I $(ROOT_DIR) 
ALL_CXXFLAGS := -W -Wall $(INCLUDE) $(CXXFLAGS) 
TARGET       := $(BUILD_DIR)/example
SOURCES      := $(patsubst $(ROOT_DIR)/example/%.cpp,%.cpp,$(wildcard $(ROOT_DIR)/example/*.cpp))
DEPS         := $(patsubst %.cpp,$(BUILD_DIR)/%.dep, $(SOURCES))
OBJECTS      := $(patsubst %.cpp,$(BUILD_DIR)/%.o, $(SOURCES))
vpath %.cpp $(ROOT_DIR)/example
vpath %.h   $(ROOT_DIR)/example

$(TARGET):  $(FLAGS) $(LIBS) $(DEPS) $(OBJECTS)
	$(CXX) $(WARNFLAGS) $(CXXFLAGS) $(LDFLAGS) $(OBJECTS) $(LIBS) -o $(TARGET)

$(LIBS):
	$(MAKE) -C $(ROOT_DIR) "BUILD_DIR=lib"

ifneq ($(MAKECMDGOALS),clean)
-include $(DEPS)
endif

$(BUILD_DIR)/%.dep: %.cpp $(FLAGS)
	$(CXX) $(ALL_CXXFLAGS) -MT $(BUILD_DIR)/$*.o -MM $< > $@

$(BUILD_DIR)/%.o: %.cpp $(FLAGS)
	$(CXX) $(ALL_CXXFLAGS) -c $< -o $@


.PHONY:	clean 
ifeq ($(findstring Windows,$(OS)),)
clean:
	@$(RM) $(TARGET)
	@$(RM) $(OBJECTS)
	@$(RM) $(DEPS)
else
RM := del /F /Q
clean:
	@$(RM) $(subst /,\,$(TARGET))  2>nul
	@$(RM) $(subst /,\,$(OBJECTS)) 2>nul
	@$(RM) $(subst /,\,$(DEPS))    2>nul
endif
clasp-3.2.2/libclasp/example/example.h000066400000000000000000000021751304134206100176470ustar00rootroot00000000000000//
// Copyright (c) Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
namespace Clasp {
	struct Model;
	class  OutputTable;
	namespace Asp { class  LogicProgram; }
}
void printModel(const Clasp::OutputTable& out, const Clasp::Model& model);
void addSimpleProgram(Clasp::Asp::LogicProgram& prg);

void example1();
void example2();
#if WITH_THREADS
void example3();
#endif
void example4();
clasp-3.2.2/libclasp/example/example1.cpp000066400000000000000000000105211304134206100202550ustar00rootroot00000000000000//
// Copyright (c) 2009, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "example.h"
// Add the libclasp directory to the list of
// include directoies of your build system.
#include     // for defining logic programs
#include   // unfounded set checkers
#include // for enumerating answer sets
#include  // for enumerating answer sets


// Compute the stable models of the program
//    a :- not b.
//    b :- not a.
void example1(bool basicSolve) {
	// LogicProgram provides the interface for
	// defining logic programs.
	// It also preprocesses the program and converts it
	// to the internal solver format.
	// See logic_program.h for details.
	Clasp::Asp::LogicProgram lp;
	Potassco::RuleBuilder rb;

	// Among other things, SharedContext maintains a Solver object
	// which hosts the data and functions for CDNL answer set solving.
	// See shared_context.h for details.
	Clasp::SharedContext ctx;

	// startProgram must be called once before we can add atoms/rules
	lp.startProgram(ctx);

	// Define the rules of the program.
	Potassco::Atom_t a = lp.newAtom();
	Potassco::Atom_t b = lp.newAtom();
	lp.addRule(rb.start().addHead(a).addGoal(Potassco::neg(b)));
	lp.addRule(rb.start().addHead(b).addGoal(Potassco::neg(a)));

	// Populate output table.
	// The output table defines what is printed for a literal
	// that is part of an answer set.
	lp.addOutput("a", a);
	lp.addOutput("b", b);
	// It is not limited to atoms. For example, the following
	// statement results in the ouput "~b" whenever b is not
	// in a stable model.
	lp.addOutput("~b", Potassco::neg(b));
	// And we always want to have "eureka"...
	lp.addOutput("eureka", Potassco::toSpan());

	// Once all rules are defined, call endProgram() to load the (simplified)
	// program into the context object.
	lp.endProgram();

	// Since we want to compute more than one
	// answer set, we need an enumerator.
	// See enumerator.h for details
	Clasp::ModelEnumerator enumerator;
	enumerator.init(ctx);

	// We are done with problem setup.
	// Prepare for solving.
	ctx.endInit();

	if (basicSolve) {
		std::cout << "With Clasp::BasicSolve" << std::endl;
		// BasicSolve implements a basic search for a model.
		// It handles the various strategies like restarts, deletion, etc.
		Clasp::BasicSolve solve(*ctx.master());
		// Prepare the solver for enumeration.
		enumerator.start(solve.solver());
		while (solve.solve() == Clasp::value_true) {
			// Make the enumerator aware of the new model and
			// let it compute a new constraint and/or backtracking level.
			if (enumerator.commitModel(solve.solver())) { printModel(ctx.output, enumerator.lastModel()); }
			// Integrate the model into the search and thereby prepare
			// the solver for the search for the next model.
			enumerator.update(solve.solver());
		}
		std::cout << "No more models!" << std::endl;
	}
	else {
		std::cout << "With Clasp::SequentialSolve" << std::endl;
		// SequentialSolve combines a BasicSolve object,
		// which implements search for a model and handles
		// various strategies like restarts, deletion, etc.,
		// with an enumerator to provide more complex reasoning,
		// like enumeration or optimization.
		Clasp::SequentialSolve solve;
		solve.setEnumerator(enumerator);
		// Start the solve algorithm and prepare solver for enumeration.
		solve.start(ctx);
		// Extract and print models one by one.
		while (solve.next()) {
			printModel(ctx.output, solve.model());
		}
		if (!solve.more()) {
			std::cout << "No more models!" << std::endl;
		}
	}
}

void example1() {
	example1(true);
	example1(false);
}
clasp-3.2.2/libclasp/example/example2.cpp000066400000000000000000000054521304134206100202650ustar00rootroot00000000000000//
// Copyright (c) 2009, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

// Add the libclasp directory to the list of
// include directoies of your build system.
#include 
#include 
#include "example.h"

// This example uses the ClaspFacade to compute
// the stable models of the program
//    a :- not b.
//    b :- not a.
//
// The ClaspFacade is a convenient wrapper for the services of the clasp library.
// See clasp_facade.h for details.


// In order to get models from the ClaspFacade, we must provide a suitable
// event handler.
class ModelPrinter : public Clasp::EventHandler {
public:
	ModelPrinter() {}
	bool onModel(const Clasp::Solver& s, const Clasp::Model& m) {
		printModel(s.outputTable(), m);
		return true;
	}
};

void addSimpleProgram(Clasp::Asp::LogicProgram& prg) {
	Potassco::Atom_t a = prg.newAtom();
	Potassco::Atom_t b = prg.newAtom();
	Potassco::RuleBuilder rb;
	prg.addRule(rb.start().addHead(a).addGoal(Potassco::neg(b)));
	prg.addRule(rb.start().addHead(b).addGoal(Potassco::neg(a)));
	prg.addOutput("a", a);
	prg.addOutput("b", b);
}

void example2() {
	// Aggregates configuration options.
	// Using config, you can control many parts of the search, e.g.
	// - the amount and kind of preprocessing
	// - the enumerator to use and the number of models to compute
	// - the heuristic used for decision making
	// - the restart strategy
	// - ...
	Clasp::ClaspConfig config;
	// We want to compute all models but
	// otherwise we use the default configuration.
	config.solve.numModels = 0;

	// The "interface" to the clasp library.
	Clasp::ClaspFacade libclasp;

	// LogicProgram provides the interface for defining logic programs.
	// The returned object is already setup and ready to use.
	// See logic_program.h for details.
	Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config);
	addSimpleProgram(asp);
	// We are done with problem setup.
	// Prepare the problem for solving.
	libclasp.prepare();

	// Start the actual solving process.
	ModelPrinter printer;
	libclasp.solve(&printer);
	std::cout << "No more models!" << std::endl;
}
clasp-3.2.2/libclasp/example/example3.cpp000066400000000000000000000036401304134206100202630ustar00rootroot00000000000000//
// Copyright (c) 2014, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#if WITH_THREADS
// Add the libclasp directory to the list of
// include directoies of your build system.
#include 
#include 
#include "example.h"

// This example uses the ClaspFacade to compute
// the stable models of the program
//    a :- not b.
//    b :- not a.
//
// It is similar to example2() but uses the facade's asynchronous
// interface in order to get the models one by one.
void example3() {
	// See example2()
	Clasp::ClaspConfig config;
	config.solve.numModels = 0;

	// The "interface" to the clasp library.
	Clasp::ClaspFacade libclasp;

	// See example2()
	Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config);
	addSimpleProgram(asp);

	// We are done with problem setup.
	// Prepare the problem for solving.
	libclasp.prepare();

	// Start the asynchronous solving process.
	Clasp::ClaspFacade::AsyncResult it = libclasp.startSolveAsync();
	// Get models one by one until iterator is exhausted.
	while (!it.end()) {
		printModel(libclasp.ctx.output, it.model());
		// Advance iterator to next model.
		it.next();
	}
	std::cout << "No more models!" << std::endl;
}
#endif
clasp-3.2.2/libclasp/example/example4.cpp000066400000000000000000000036451304134206100202710ustar00rootroot00000000000000//
// Copyright (c) 2009, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

// Add the libclasp directory to the list of
// include directoies of your build system.
#include 
#include 
#include "example.h"

// This example demonstrates how user code can influence model enumeration.

// Gets models from the ClaspFacade and guides enumeration by adding constraints.
class ModelHandler : public Clasp::EventHandler {
public:
	ModelHandler() {}
	bool onModel(const Clasp::Solver& s, const Clasp::Model& m) {
		printModel(s.outputTable(), m);
		// exclude this model
		Clasp::LitVec clause;
		for (uint32 i = 1; i <= s.decisionLevel(); ++i) {
			clause.push_back( ~s.decision(i) );
		}
		return m.ctx->commitClause(clause);
	}
};

void example4() {
	Clasp::ClaspConfig config;
	config.solve.enumMode  = Clasp::EnumOptions::enum_user;
	config.solve.numModels = 0;

	// The "interface" to the clasp library.
	Clasp::ClaspFacade libclasp;

	Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config);
	addSimpleProgram(asp);

	libclasp.prepare();

	// Start the actual solving process.
	ModelHandler handler;
	libclasp.solve(&handler);
	std::cout << "No more models!" << std::endl;
}
clasp-3.2.2/libclasp/example/main.cpp000066400000000000000000000036611304134206100174740ustar00rootroot00000000000000//
// Copyright (c) 2009, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "example.h"
#include 
#include 
void printModel(const Clasp::OutputTable& out, const Clasp::Model& model) {
	std::cout << "Model " << model.num << ": \n";
	// Always print facts.
	for (Clasp::OutputTable::fact_iterator it = out.fact_begin(), end = out.fact_end(); it != end; ++it) {
		std::cout << *it << " ";
	}
	// Print elements that are true wrt the current model.
	for (Clasp::OutputTable::pred_iterator it = out.pred_begin(), end = out.pred_end(); it != end; ++it) {
		if (model.isTrue(it->cond)) {
			std::cout << it->name << " ";
		}
	}
	// Print additional output variables.
	for (Clasp::OutputTable::range_iterator it = out.vars_begin(), end = out.vars_end(); it != end; ++it) {
		std::cout << (model.isTrue(Clasp::posLit(*it)) ? int(*it) : -int(*it)) << " ";
	}
	std::cout << std::endl;
}

#define RUN(x) try { std::cout << "*** Running " << static_cast(#x) << " ***" << std::endl; x(); } catch (const std::exception& e) { std::cout << " *** ERROR: " << e.what() << std::endl; }

int main() {
	RUN(example1);
	RUN(example2);
#if WITH_THREADS
	RUN(example3);
#endif
	RUN(example4);
}
clasp-3.2.2/libclasp/src/000077500000000000000000000000001304134206100151725ustar00rootroot00000000000000clasp-3.2.2/libclasp/src/asp_preprocessor.cpp000066400000000000000000000457041304134206100213010ustar00rootroot00000000000000//
// Copyright (c) 2006-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
namespace Clasp { namespace Asp {
/////////////////////////////////////////////////////////////////////////////////////////
// simple preprocessing
//
// Simplifies the program by computing max consequences.
// Then assign variables to non-trivial supported bodies and atoms.
/////////////////////////////////////////////////////////////////////////////////////////
bool Preprocessor::preprocessSimple() {
	if (!prg_->propagate(true)) { return false; }
	uint32 startVar = prg_->ctx()->numVars() + 1;
	// start with initially supported bodies
	VarVec& supported = prg_->getSupportedBodies(true);
	VarVec  unitBodies;
	for (VarVec::size_type i = 0; i != supported.size(); ++i) {
		// set up body
		PrgBody* b = prg_->getBody(supported[i]);
		if (!b->simplify(*prg_, false)) { return false; }
		if (b->var() < startVar) {
			if  (b->size() != 1) { b->assignVar(*prg_); }
			else                 { unitBodies.push_back(supported[i]); }
		}
		// add all heads of b to the "upper"-closure and
		// remove any false/removed atoms from head
		if (!addHeadsToUpper(b) || !b->simplifyHeads(*prg_, true)) {
			return false;
		}
	}
	for (VarVec::const_iterator it = unitBodies.begin(), end = unitBodies.end(); it != end; ++it) {
		prg_->getBody(*it)->assignVar(*prg_);
	}
	return prg_->propagate();
}

bool Preprocessor::addHeadToUpper(PrgHead* head, PrgEdge support) {
	assert(head->relevant() && !head->inUpper());
	head->simplifySupports(*prg_, false);
	head->assignVar(*prg_, support, eq());
	head->clearSupports();
	head->setInUpper(true);
	if (head->isAtom()) {
		return propagateAtomVar(static_cast(head), support);
	}
	// add all unseen atoms of disjunction to upper
	PrgDisj* d = static_cast(head);
	support    = PrgEdge::newEdge(*d, PrgEdge::Choice);
	bool ok    = true;
	for (PrgDisj::atom_iterator it = d->begin(), end = d->end(); it != end && ok; ++it) {
		PrgAtom* at = prg_->getAtom(*it);
		if (!at->relevant()) { continue; }
		if (!at->inUpper())  { ok = addHeadToUpper(at, support); }
		at->addSupport(support);
	}
	return ok;
}
/////////////////////////////////////////////////////////////////////////////////////////
// equivalence preprocessing
//
// Computes max consequences and minimizes the number of necessary variables
// by computing equivalence-classes.
/////////////////////////////////////////////////////////////////////////////////////////
bool Preprocessor::preprocessEq(uint32 maxIters) {
	uint32 startVar = prg_->ctx()->numVars();
	ValueRep res    = value_true;
	pass_           = 0;
	maxPass_        = maxIters;
	HeadRange atoms = HeadRange(prg_->atom_begin() + prg_->startAtom(), prg_->atom_end());
	bodyInfo_.resize( prg_->numBodies() + 1 );
	do {
		if (++pass_ > 1) {
			for (HeadIter it = prg_->atom_begin(), end = atoms.second; it != end; ) {
				while (it != atoms.first){ (*it)->setInUpper(false); ++it; }
				while (it != end)        { (*it)->clearLiteral(false); (*it)->setInUpper(false); ++it; }
			}
			for (HeadIter it = prg_->disj_begin(), end = prg_->disj_end(); it != end; ++it) {
				(*it)->clearLiteral(false);
				(*it)->setInUpper(false);
			}
			prg_->ctx()->popVars(prg_->ctx()->numVars() - startVar);
			litToNode_.clear();
		}
		VarVec& supported = prg_->getSupportedBodies(true);
		if (!classifyProgram(supported)) { return false; }
		res = simplifyClassifiedProgram(atoms, pass_ != maxPass_, supported);
	} while (res == value_free && pass_ != maxPass_);
	return res != value_false;
}

// Computes necessary equivalence-classes starting from the supported bodies
// of a program.
bool Preprocessor::classifyProgram(const VarVec& supported) {
	Var bodyId; PrgBody* body;
	VarVec::size_type index = 0;
	follow_.clear();
	if (!prg_->propagate(true)) { return false; }
	for (VarVec::size_type i = 0;;) {
		while ( (bodyId = nextBodyId(index)) != varMax ) {
			body = addBodyVar(bodyId);
			if (prg_->hasConflict())    { return false; }
			if (!addHeadsToUpper(body)) { return false; }
		}
		follow_.clear();
		index = 0;
		// select next unclassified supported body
		for (; i < supported.size(); ++i) {
			bodyId  = supported[i];
			body    = prg_->getBody(bodyId);
			if (bodyInfo_[bodyId].bSeen == 0 && body->relevant()) {
				follow_.push_back(bodyId);
				break;
			}
			else if (!body->relevant() && body->hasVar()) {
				body->clearLiteral(false);
			}
		}
		if (follow_.empty()) break;
	}
	return !prg_->hasConflict();
}

ValueRep Preprocessor::simplifyClassifiedProgram(const HeadRange& atoms, bool more, VarVec& supported) {
	ValueRep res = value_true, simp;
	if (!prg_->propagate()) { return value_false; }
	supported.clear();
	// simplify supports
	for (uint32 i = 0; i != prg_->numBodies(); ++i) {
		PrgBody* b = prg_->getBody(i);
		if (bodyInfo_[i].bSeen == 0 || !b->relevant()) {
			// !bodyInfo_[i].bSeen: body is unsupported
			// !b->relevant()     : body is eq to other body or was derived to false
			// In either case, body is no longer relevant and can be ignored.
			b->clearLiteral(true);
			b->markRemoved();
		}
		else if ( (simp = simplifyBody(b, more, supported)) != value_true ) {
			if (simp == value_false) { return simp; }
			res = value_free;
		}
	}
	if (!prg_->propagate()) { return value_false; }
	PrgEdge noSup = PrgEdge::noEdge();
	for (LogicProgram::VarIter it = prg_->unfreeze_begin(), end = prg_->unfreeze_end(); it != end; ++it) {
		PrgAtom* a = prg_->getAtom(*it);
		ValueRep v = a->value();
		if      (!a->simplifySupports(*prg_, true)){ return value_false; }
		else if (!a->inUpper() && v != value_false){
			if (!prg_->assignValue(a, value_false, noSup)){ return value_false; }
			if (more && a->hasDep(PrgAtom::dep_all))      { res = value_free; }
		}
	}
	if (!prg_->propagate()) { return value_false; }
	bool strong = more && res == value_true;
	HeadRange heads[2] = { HeadRange(prg_->disj_begin(), prg_->disj_end()), atoms };
	for (const HeadRange* range = heads, *endR = heads+2; range != endR; ++range) {
		for (HeadIter it = range->first, end = range->second; it != end; ++it) {
			PrgHead* head = *it;
			if ((simp = simplifyHead(head, strong)) != value_true) {
				if      (simp == value_false){ return simp; }
				else if (strong)             { strong = false; res = value_free; }
			}
		}
	}
	if (!prg_->propagate()) { res = value_false; }
	return res;
}

// associates a variable with the body if necessary
PrgBody* Preprocessor::addBodyVar(Var bodyId) {
	// make sure we don't add an irrelevant body
	PrgBody* body = prg_->getBody(bodyId);
	assert((body->isSupported() && !body->eq()) || body->hasVar());
	body->clearLiteral(false);    // clear var in case we are iterating
	bodyInfo_[bodyId].bSeen = 1;  // mark as seen, so we don't classify the body again
	bool   known = bodyInfo_[bodyId].known == body->size();
	uint32 eqId;
	if (!body->simplifyBody(*prg_, known, &eqId) || !body->simplifyHeads(*prg_, false)) {
		prg_->setConflict();
		return body;
	}
	if (superfluous(body)) {
		body->markRemoved();
		return body;
	}
	if (eqId == bodyId) {
		// The body is unique
		body->assignVar(*prg_);
		PrgAtom* aEq = body->size() == 1 ? prg_->getAtom(body->goal(0).var()) : 0;
		if      (!known)                          { body->markDirty(); }
		else if (aEq && aEq->var() == body->var()){
			// Body is equivalent to an atom or its negation
			// Check if the atom is itself equivalent to a body.
			// If so, the body is equivalent to the atom's body.
			PrgBody* r = 0; // possible eq-body
			uint32 rId = varMax;
			if (body->goal(0).sign()) {
				Var dualAtom = getRootAtom(body->literal());
				aEq = dualAtom != varMax ? prg_->getAtom(dualAtom) : 0;
			}
			if (aEq && aEq->supports() && aEq->supps_begin()->isBody()) {
				rId = aEq->supps_begin()->node();
				r   = prg_->getBody(rId);
				if (r && r->var() == aEq->var()) {
					mergeEqBodies(body, rId, false);
				}
			}
		}
	}
	else {
		// body is eq to eq body
		mergeEqBodies(body, eqId, true);
	}
	return body;
}

// Adds all heads of body to the upper closure if not yet present and
// associates variables with the heads if necessary.
// The body b is the supported body that provides a support for the heads.
// RETURN: true if no conflict
// POST  : the addition of atoms to the closure was propagated
bool Preprocessor::addHeadsToUpper(PrgBody* body) {
	PrgHead* head;
	PrgEdge  support;
	bool ok  = !prg_->hasConflict();
	int dirty= 0;
	for (PrgBody::head_iterator it = body->heads_begin(), end = body->heads_end(); it != end && ok; ++it) {
		head   = prg_->getHead(*it);
		support= PrgEdge::newEdge(*body, it->type());
		if (head->relevant() && head->value() != value_false) {
			if (body->value() == value_true && head->isAtom()) {
				// Since b is true, it is always a valid support for head, head can never become unfounded.
				// So ignore it during SCC check and unfounded set computation.
				head->setIgnoreScc(true);
				if (support.isNormal() && head->isAtom()) {
					ok = propagateAtomValue(static_cast(head), value_true, support);
				}
			}
			if (!head->inUpper()) {
				// first time we see this head - assign var...
				ok = addHeadToUpper(head, support);
			}
			else if (head->supports() && head->supps_begin()->isNormal()) {
				PrgEdge source = *head->supps_begin();
				assert(source.isBody());
				if (prg_->getBody(source.node())->var() == body->var()) {
					// Check if we really need a new variable for head.
					head->markDirty();
				}
			}
			head->addSupport(support, PrgHead::no_simplify);
		}
		dirty += (head->eq() || head->value() == value_false);
	}
	if (dirty) {
		// remove eq atoms from head
		prg_->getBody(body->id())->markHeadsDirty();
	}
	return ok;
}

// Propagates that a was added to the "upper"-closure.
// If atom a has a truth-value or is eq to a', we'll remove
// it from all bodies. If there is an atom x, s.th. a.lit == ~x.lit, we mark all
// bodies containing both a and x for simplification in order to detect
// duplicates/contradictory body-literals.
// In case that a == a', we also mark all bodies containing a
// for head simplification in order to detect rules like: a' :- a,B. and a' :- B,not a.
bool Preprocessor::propagateAtomVar(PrgAtom* a, PrgEdge source) {
	const Var aId   = a->id();
	PrgAtom* comp   = 0;
	ValueRep value  = a->value();
	bool fullEq     = eq();
	bool removeAtom = value == value_true || value == value_false;
	bool removeNeg  = removeAtom  || value == value_weak_true;
	Literal aLit    = a->literal();
	if (fullEq) {
		if (getRootAtom(aLit) == varMax) {
			setRootAtom(aLit, aId);
		}
		else if (prg_->mergeEqAtoms(a, getRootAtom(aLit))) {
			assert(source.isBody());
			removeAtom = true;
			removeNeg  = true;
			value      = a->value();
			PrgBody* B = prg_->getBody(source.node());
			a->setEqGoal(posLit(a->id()));
			// set positive eq goal - replace if a == {not a'}, replace a with not a' in bodies
			if (getRootAtom(~aLit) != varMax && B->literal() == aLit && B->size() == 1 && B->goal(0).sign()) {
				a->setEqGoal(negLit(getRootAtom(~aLit)));
			}
			a->clearLiteral(true); // equivalent atoms don't need vars
		}
		else { return false; }
	}
	if (getRootAtom(~aLit) != varMax) {
		PrgAtom* negA = prg_->getAtom(getRootAtom(~aLit));
		assert(aLit == ~negA->literal());
		// propagate any truth-value to complementary eq-class
		ValueRep cv   = value_free;
		uint32   mark = 0;
		if (value != value_free && (cv = (value_false | (value^value_true))) != negA->value()) {
			mark        = 1;
			if (!propagateAtomValue(negA, cv, PrgEdge::noEdge())) {
				return false;
			}
		}
		if ( !removeAtom ) {
			for (PrgAtom::dep_iterator it = (comp=negA)->deps_begin(); it != comp->deps_end(); ++it) {
				bodyInfo_[it->var()].mBody = 1;
				if (mark) { prg_->getBody(it->var())->markDirty(); }
			}
		}
	}
	for (PrgAtom::dep_iterator it = a->deps_begin(), end = a->deps_end(); it != end; ++it) {
		Var bodyId  = it->var();
		PrgBody* bn = prg_->getBody(bodyId);
		if (bn->relevant()) {
			bool wasSup = bn->isSupported();
			bool isSup  = wasSup || (value != value_false && !it->sign() && bn->propagateSupported(aId));
			bool seen   = false;
			bool dirty  = removeAtom || (removeNeg && it->sign());
			if (fullEq) {
				seen      = bodyInfo_[bodyId].bSeen != 0;
				dirty    |= bodyInfo_[bodyId].mBody == 1;
				if (++bodyInfo_[bodyId].known == bn->size() && !seen && isSup) {
					follow_.push_back( bodyId );
					seen    = true;
				}
			}
			if (!seen && isSup && !wasSup) {
				prg_->getSupportedBodies(false).push_back(bodyId);
			}
			if (dirty) {
				bn->markDirty();
				if (a->eq()) {
					bn->markHeadsDirty();
				}
			}
		}
	}
	if      (removeAtom) { a->clearDeps(PrgAtom::dep_all); }
	else if (removeNeg)  { a->clearDeps(PrgAtom::dep_neg); }
	if (comp) {
		for (PrgAtom::dep_iterator it = comp->deps_begin(), end = comp->deps_end(); it != end; ++it) {
			bodyInfo_[it->var()].mBody = 0;
		}
	}
	return true;
}

// Propagates the assignment of val to a.
bool Preprocessor::propagateAtomValue(PrgAtom* atom, ValueRep val, PrgEdge sup) {
	// No backpropagation possible because supports are not yet fully established.
	return prg_->assignValue(atom, val, sup) && prg_->propagate(false);
}

bool Preprocessor::mergeEqBodies(PrgBody* body, Var rootId, bool equalLits) {
	PrgBody* root = prg_->mergeEqBodies(body, rootId, equalLits, false);
	if (root && root != body && bodyInfo_[root->id()].bSeen == 0) {
		// If root is not yet classified, we can ignore body.
		// The heads of body are added to the "upper"-closure
		// once root is eventually classified.
		body->clearHeads();
		body->markRemoved();
	}
	return root != 0;
}

bool Preprocessor::hasRootLiteral(PrgBody* body) const {
	return body->size() >= 1
		&& getRootAtom(body->literal()) == varMax
		&& getRootAtom(~body->literal())== varMax;
}

// Pre: body is simplified!
bool Preprocessor::superfluous(PrgBody* body) const {
	if (!body->relevant()) { return true; }
	if (!body->inRule()) {
		if (body->value() == value_free) { return true; }
		if (body->bound() <= 0)          { return true; }
		if (body->size() == 1)           {
			// unit constraint
			ValueRep exp = body->value() ^ (int)body->goal(0).sign();
			ValueRep got = prg_->getAtom(body->goal(0).var())->value();
			assert(got != value_free || !prg_->options().backprop);
			return got != value_free && (got&value_true) == (exp&value_true);
		}
	}
	return false;
}

// Simplify the classified body with the given id.
// Return:
//  value_false    : conflict
//  value_true     : ok
//  value_weak_true: ok but program should be reclassified
ValueRep Preprocessor::simplifyBody(PrgBody* b, bool reclass, VarVec& supported) {
	assert(b->relevant() && bodyInfo_[b->id()].bSeen == 1);
	bodyInfo_[b->id()].bSeen = 0;
	bodyInfo_[b->id()].known = 0;
	bool   hadHeads = b->hasHeads();
	bool   hasRoot  = hasRootLiteral(b);
	uint32 eqId     = b->id();
	if (!b->simplify(*prg_, true, &eqId)) {
		return value_false;
	}
	ValueRep ret = value_true;
	if (reclass) {
		if (hadHeads && b->value() == value_false) {
			assert(b->hasHeads() == false);
			// New false body. If it was derived to false, we can ignore the body.
			// Otherwise, we have a new integrity constraint.
			if (!b->relevant()) {
				b->clearLiteral(true);
			}
		}
		else if (b->var() != 0 && superfluous(b)) {
			// Body is no longer needed. All heads are either superfluous or equivalent
			// to other atoms.
			// Reclassify only if var is not used
			if (getRootAtom(b->literal()) == varMax) { ret = value_weak_true; }
			b->clearLiteral(true);
			b->markRemoved();
		}
		else if (b->value() == value_true && b->var() != 0) {
			// New fact body
			for (PrgBody::head_iterator it = b->heads_begin(), end = b->heads_end(); it != end; ++it) {
				if (it->isNormal() && prg_->getHead(*it)->var() != 0) {
					ret = value_weak_true;
					break;
				}
			}
			b->markDirty();
		}
	}
	if (b->relevant() && eqId != b->id() && (reclass || prg_->getBody(eqId)->var() == b->var())) {
		// Body is now eq to some other body - reclassify if body var is not needed
		Var bVar = b->var();
		prg_->mergeEqBodies(b, eqId, true, true);
		if (hasRoot && bVar != b->var()) {
			ret = value_weak_true;
		}
	}
	if (b->relevant() && b->resetSupported()) {
		supported.push_back(b->id());
	}
	return ret;
}

// Simplify the classified head h.
// Update list of bodies defining this head and check
// if atom or disjunction has a distinct var although it is eq to some body.
// Return:
//  value_false    : conflict
//  value_true     : ok
//  value_weak_true: ok but atom should be reclassified
ValueRep Preprocessor::simplifyHead(PrgHead* h, bool more) {
	if (!h->hasVar() || !h->relevant()) {
		// unsupported or eq
		h->clearLiteral(false);
		h->markRemoved();
		h->clearSupports();
		h->setInUpper(false);
		return value_true;
	}
	assert(h->inUpper());
	ValueRep v       = h->value();
	ValueRep ret     = value_true;
	PrgEdge support  = h->supports() ? *h->supps_begin() : PrgEdge::noEdge();
	uint32 numSuppLits= 0;
	if (!h->simplifySupports(*prg_, true, &numSuppLits)) {
		return value_false;
	}
	if (v != h->value() && (h->value() == value_false || (h->value() == value_true && h->var() != 0))) {
		ret = value_weak_true;
	}
	if (more) {
		if (numSuppLits == 0 && h->hasVar()) {
			// unsupported head does not need a variable
			ret = value_weak_true;
		}
		else if (h->supports() > 0 && h->supps_begin()->rep != support.rep) {
			// support for head has changed
			ret = value_weak_true;
		}
		else if ((support.isNormal() && h->supports() == 1) || (h->supports() > 1 && numSuppLits == 1 && h->isAtom())) {
			assert(support.isBody());
			PrgBody* supBody = prg_->getBody(support.node());
			if (supBody->literal() != h->literal()) {
				if (h->supports() > 1) {
					// atom is equivalent to one of its bodies
					EdgeVec temp(h->supps_begin(), h->supps_end());
					h->clearSupports();
					support = temp[0];
					for (EdgeIterator it = temp.begin(), end = temp.end(); it != end; ++it) {
						assert(!it->isDisj());
						PrgBody* B = prg_->getBody(it->node());
						if (it->isNormal() && B->size() == 1 && B->goal(0).sign()) {
							support = *it;
						}
						B->removeHead(h, it->type());
					}
					supBody = prg_->getBody(support.node());
					supBody->addHead(h, support.type());
					if (!supBody->simplifyHeads(*prg_, true)) {
						return value_false;
					}
				}
				ret = value_weak_true;
				if (h->value() == value_weak_true || h->value() == value_true) {
					supBody->assignValue(h->value());
					supBody->propagateValue(*prg_, true);
				}
			}
		}
	}
	return ret;
}

} }
clasp-3.2.2/libclasp/src/cb_enumerator.cpp000066400000000000000000000324141304134206100205270ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#if WITH_THREADS
#include 
#define ACQUIRE_LOCK(m) while ( (m).fetch_and_store(1) != 0 ) Clasp::mt::this_thread::yield()
#define RELEASE_LOCK(m) (m) = 0
#else
#define ACQUIRE_LOCK(m)
#define RELEASE_LOCK(m)
#endif
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// CBConsequences::SharedConstraint
/////////////////////////////////////////////////////////////////////////////////////////
class CBConsequences::SharedConstraint {
public:
	SharedConstraint() : current(0) { mutex = 0; }
	SharedLiterals* fetch_if_neq(SharedLiterals* last) const {
		ACQUIRE_LOCK(mutex);
		SharedLiterals* ret = last != current ? current->share() : 0;
		RELEASE_LOCK(mutex);
		return ret;
	}
	void release(SharedLiterals* newLits) {
		ACQUIRE_LOCK(mutex);
		SharedLiterals* old = current;
		current = newLits;
		RELEASE_LOCK(mutex);
		if (old) { old->release(); }
	}
	SharedLiterals* current;
	typedef Clasp::Atomic_t::type MutexType;
	mutable MutexType mutex;
};
#undef ACQUIRE_LOCK
#undef RELEASE_LOCK
/////////////////////////////////////////////////////////////////////////////////////////
// CBConsequences::CBFinder
/////////////////////////////////////////////////////////////////////////////////////////
class CBConsequences::CBFinder : public EnumerationConstraint {
public:
	typedef CBConsequences::SharedConstraint  SharedCon;
	typedef Solver::ConstraintDB              ConstraintDB;
	typedef SharedLiterals                    SharedLits;
	explicit CBFinder(SharedCon* sh) : EnumerationConstraint(), shared(sh), last(0) {}
	ConPtr clone() { return new CBFinder(shared); }
	void   doCommitModel(Enumerator& ctx, Solver& s) { static_cast(ctx).addCurrent(s, current, s.model, rootLevel()); }
	void   destroy(Solver* s, bool detach);
	bool   doUpdate(Solver& s);
	void   pushLocked(Solver& s, ClauseHead* h);
	LitVec       current;
	SharedCon*   shared;
	SharedLits*  last;
	ConstraintDB locked;
};
/////////////////////////////////////////////////////////////////////////////////////////
// CBConsequences::QueryFinder
/////////////////////////////////////////////////////////////////////////////////////////
class CBConsequences::QueryFinder : public EnumerationConstraint{
public:
	class State {
	public:
		State(Model& m, uint32 nVars) : model_(&m) {
			refs_  = 1;
			size_  = nVars;
			value_ = new ValueType[nVars];
			for (uint32 i = 0; i != nVars; ++i) { value_[i] = 0; }
		}
		State* share()    { ++refs_; return this; }
		void   release()  { if (--refs_ == 0) delete this; }
		uint32 size()          const { return size_; }
		bool   open(Literal p) const { return (value_[p.var()] & Model::estMask(p)) != 0; }
		void   setModel(Clasp::ValueVec& m, bool update) {
			m.assign(value_, value_ + size_);
			if (update) { model_->values = &m; model_->up = 1; }
		}
		void   push(Literal p) { value_[p.var()] = Model::estMask(p)|trueValue(p);}
		void   pop(Literal p)  { value_[p.var()] = 0; }
		void   fix(Literal p)  { value_[p.var()] = trueValue(p); }
	private:
		~State() { delete [] value_; }
		typedef Clasp::Atomic_t::type  ValueType;
		typedef Clasp::Atomic_t::type SizeType;
		typedef ValueType* ValueVec;
		ValueVec value_;
		Model*   model_;
		uint32   size_;
		SizeType refs_;
	};
	explicit QueryFinder(const LitVec& c, Model& m, uint32 nVars) : EnumerationConstraint(), open_(c), state_(new State(m, nVars)), query_(lit_false()), level_(0), dirty_(false) {
		state_->push(query_);
	}
	explicit QueryFinder(const LitVec& c, State* st) : EnumerationConstraint(), open_(c), state_(st), query_(lit_false()), level_(0), dirty_(false) {
	}
	~QueryFinder() { state_->release(); }
	ConPtr clone() { return new QueryFinder(open_, state_->share()); }
	bool    hasQuery() const { return query_ != lit_false(); }
	bool    doUpdate(Solver& s);
	void    doCommitModel(Enumerator&, Solver&);
	void    doCommitUnsat(Enumerator&, Solver&);
	void    updateUpper(Solver& s, uint32 rl, ValueVec& mOut);
	void    updateLower(Solver& s, uint32 rl, ValueVec& mOut);
	bool    selectOpen(Solver& s, Literal& q);
	void    reason(Solver& s, Literal p, LitVec& out) {
		for (uint32 i = 1, end = s.level(p.var()); i <= end; ++i) {
			Literal q = s.decision(i);
			if (q != p) { out.push_back(q); }
		}
	}
	bool    popQuery(Solver& s) {
		if (!hasQuery() || s.rootLevel() == level_ || s.value(query_.var()) == value_free) {
			return s.popRootLevel(0);
		}
		return s.popRootLevel((s.rootLevel() - level_) + 1);
	}
	LitVec  open_;
	State*  state_;
	Literal query_;
	uint32  level_;
	bool    dirty_;
};
// Reduce the overestimate by computing c = c \cap M,
// where M is the current model stored in s.
void CBConsequences::QueryFinder::updateUpper(Solver& s, uint32 root, ValueVec& mOut) {
	LitVec::iterator j = open_.begin();
	for (LitVec::iterator it = j, end = open_.end(); it != end; ++it) {
		if      (!state_->open(*it))        { continue; }
		else if (!s.isTrue(*it))            { state_->pop(*it); }
		else if (s.level(it->var()) > root) { *j++ = *it; }
		else                                { state_->fix(*it); }
	}
	open_.erase(j, open_.end());
	state_->setModel(mOut, dirty_ = false);
}
// Adds facts to (under) estimate.
void CBConsequences::QueryFinder::updateLower(Solver& s, uint32 rl, ValueVec& mOut) {
	LitVec::iterator j = open_.begin();
	for (LitVec::iterator it = j, end = open_.end(); it != end; ++it) {
		ValueRep val = s.value(it->var());
		if (val != value_free && s.level(it->var()) > rl) {
			val = value_free;
		}
		if      (!state_->open(*it)) { continue; }
		else if (val == value_free)  { *j++ = *it; }
		else if (s.isTrue(*it))      { state_->fix(*it); }
		else                         { state_->pop(*it); }
	}
	if (j != open_.end()) { dirty_ = true; }
	open_.erase(j, open_.end());
	state_->setModel(mOut, dirty_);
	dirty_ = false;
}
bool CBConsequences::QueryFinder::selectOpen(Solver& s, Literal& q) {
	for (LitVec::size_type i = 0, end = open_.size();; --end, open_.pop_back()) {
		for (; i != end && s.value(open_[i].var()) == value_free && state_->open(open_[i]); ++i) { ; }
		if (i == end) { break; }
		q = open_[i];
		open_[i] = open_.back();
		if (s.isTrue(q)) { state_->fix(q); }
		else             { state_->pop(q); }
		dirty_ = true;
	}
	if (open_.empty()) { return false; }
	q = s.heuristic()->selectRange(s, &open_[0], &open_[0] + open_.size());
	return true;
}
// solve(~query) produced a model - query is not a cautious consequence, update overstimate
void CBConsequences::QueryFinder::doCommitModel(Enumerator&, Solver& s) {
	if (!hasQuery() && state_->open(query_)) {
		// init state to first model
		for (LitVec::iterator it = open_.begin(), end = open_.end(); it != end; ++it) {
			if (s.isTrue(*it)) { state_->push(*it); }
		}
	}
	state_->pop(query_);
	updateUpper(s, level_, s.model);
	query_.flag();
}
// solve(~query) failed - query is a cautious consequence
void CBConsequences::QueryFinder::doCommitUnsat(Enumerator&, Solver& s) {
	bool commit = !disjointPath() && s.hasConflict() && !s.hasStopConflict() && hasQuery();
	popQuery(s);
	if (commit) {
		state_->fix(query_);
		query_.flag();
	}
	updateLower(s, level_, s.model);
}
bool CBConsequences::QueryFinder::doUpdate(Solver& s) {
	bool newQ = query_.flagged() || !state_->open(query_);
	if (newQ || s.value(query_.var()) == value_free) { // query was SAT/UNSAT or solved by other thread
		if (!popQuery(s)) { return false; }
		assert(s.decisionLevel() == s.rootLevel());
		level_ = s.rootLevel();
		return newQ && !selectOpen(s, query_) ? s.force(query_ = lit_false(), this) : s.pushRoot(~query_);
	}
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// CBConsequences
/////////////////////////////////////////////////////////////////////////////////////////
CBConsequences::CBConsequences(Type type, Algo algo)
	: Enumerator()
	, shared_(0)
	, type_(type)
	, algo_(algo) {
	if (type_ != Cautious) { algo_ = Default; }
}

Enumerator* EnumOptions::createConsEnumerator(const EnumOptions& opts) {
	return new CBConsequences(opts.enumMode == enum_brave ? CBConsequences::Brave : CBConsequences::Cautious, opts.enumMode != enum_query ? CBConsequences::Default : CBConsequences::Query);
}
CBConsequences::~CBConsequences() {
	delete shared_;
}
bool CBConsequences::supportsSplitting(const SharedContext& problem) const {
	return algo_ == Default && Enumerator::supportsSplitting(problem);
}
int CBConsequences::unsatType() const {
	return algo_ == Default ? Enumerator::unsatType() : Enumerator::unsat_sync;
}
EnumerationConstraint* CBConsequences::doInit(SharedContext& ctx, SharedMinimizeData* m, int) {
	cons_.clear();
	const OutputTable& out = ctx.output;
	if (out.projectMode() == OutputTable::project_output) {
		for (OutputTable::pred_iterator it = out.pred_begin(), end = out.pred_end(); it != end; ++it) {
			addLit(ctx, it->cond);
		}
		for (OutputTable::range_iterator it = out.vars_begin(), end = out.vars_end(); it != end; ++it) {
			addLit(ctx, posLit(*it));
		}
	}
	else {
		for (OutputTable::lit_iterator it = out.proj_begin(), end = out.proj_end(); it != end; ++it) {
			addLit(ctx, *it);
		}
	}
	// init M to either cons or {} depending on whether we compute cautious or brave cons.
	const uint32 fMask = (type_ == Cautious && algo_ != Query);
	const uint32 vMask = (type_ == Cautious) ? 3u : 0u;
	for (LitVec::iterator it = cons_.begin(), end = cons_.end(); it != end; ++it) {
		it->rep() |= fMask;
		ctx.unmark(it->var());
		if (!ctx.varInfo(it->var()).nant()) {
			ctx.master()->setPref(it->var(), ValueSet::def_value, static_cast(trueValue(*it) ^ vMask));
		}
	}
	delete shared_; shared_ = 0;
	setIgnoreSymmetric(true);
	if (m && m->optimize() && algo_ == Query) {
		ctx.warn("Query algorithm does not support optimization!");
		algo_ = Default;
	}
	if (type_ != Cautious || algo_ != Query) {
		shared_ = ctx.concurrency() > 1 ? new SharedConstraint() : 0;
		return new CBFinder(shared_);
	}
	return new QueryFinder(cons_, model(), ctx.numVars() + 1);
}
void CBConsequences::addLit(SharedContext& ctx, Literal p) {
	if (!ctx.marked(p) && !ctx.eliminated(p.var())) {
		cons_.push_back(p);
		ctx.setFrozen(p.var(), true);
		ctx.mark(p);
	}
}
void CBConsequences::addCurrent(Solver& s, LitVec& con, ValueVec& m, uint32 root) {
	con.assign(1, ~s.sharedContext()->stepLiteral());
	// reset state of relevant variables
	for (LitVec::iterator it = cons_.begin(), end = cons_.end(); it != end; ++it) {
		m[it->var()] = 0;
	}
	// let M be all lits p with p.watch() == true
	for (LitVec::iterator it = cons_.begin(), end = cons_.end(); it != end; ++it) {
		Literal& p = *it;
		uint32  dl = s.level(p.var());
		uint32 ost = dl > root ? Model::estMask(p) : 0;
		if (type_ == Brave) {
			// brave: extend M with true literals and force a literal not in M to true
			if      (p.flagged() || s.isTrue(p)) { p.flag(); ost = 0; }
			else if (dl)                         { con.push_back(p); }
		}
		else if (type_ == Cautious) {
			// cautious: intersect M with true literals and force a literal in M to false
			if      (!p.flagged() || s.isFalse(p)) { p.unflag(); ost = 0; }
			else if (dl)                           { con.push_back(~p); }
		}
		// set output state
		if (p.flagged()) { ost |= trueValue(p); }
		m[p.var()] |= ost;
	}
	if (shared_) {
		shared_->release(SharedLiterals::newShareable(con, Constraint_t::Other, 1));
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// CBConsequences::CBFinder implementation
/////////////////////////////////////////////////////////////////////////////////////////
void CBConsequences::CBFinder::destroy(Solver* s, bool detach) {
	Clasp::destroyDB(locked, s, detach);
	if (last) {
		last->release();
	}
	EnumerationConstraint::destroy(s, detach);
}
void CBConsequences::CBFinder::pushLocked(Solver& s, ClauseHead* c) {
	for (ClauseHead* h; !locked.empty() && !(h = static_cast(locked.back()))->locked(s);) {
		h->destroy(&s, true);
		locked.pop_back();
	}
	locked.push_back(c);
}
bool CBConsequences::CBFinder::doUpdate(Solver& s) {
	ClauseCreator::Result ret;
	uint32 flags = ClauseCreator::clause_explicit|ClauseCreator::clause_no_add;
	if (!shared) {
		ret  = !current.empty() ? ClauseCreator::create(s, current, flags, ConstraintInfo(Constraint_t::Other)) : ClauseCreator::Result();
	}
	else if (SharedLiterals* x = shared->fetch_if_neq(last)) {
		if (last) { last->release(); }
		last = x;
		ret  = ClauseCreator::integrate(s, x, flags | ClauseCreator::clause_no_release);
	}
	if (ret.local) { pushLocked(s, ret.local); }
	current.clear();
	return ret.ok();
}
}
clasp-3.2.2/libclasp/src/clasp_facade.cpp000066400000000000000000001133641304134206100202730ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#if WITH_THREADS
#include 
#endif
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspConfig
/////////////////////////////////////////////////////////////////////////////////////////
struct ClaspConfig::Impl {
	struct ConfiguratorProxy {
		enum { OnceBit = 62, AcquireBit = 61 };
		ConfiguratorProxy(Configurator* c, Ownership_t::Type own, bool once) : cfg(reinterpret_cast(c)), set(0) {
			if (once) { store_set_bit(cfg, OnceBit); }
			if (own == Ownership_t::Acquire) { store_set_bit(cfg, AcquireBit); }
			assert(ptr() == c);
		}
		bool addPost(Solver& s) {
			CLASP_FAIL_IF(s.id() > 63, "invalid solver id!");
			if (test_bit(set, s.id()))  { return true;  }
			if (test_bit(cfg, OnceBit)) { store_set_bit(set, s.id()); }
			return this->ptr()->addPost(s);
		}
		void prepare(SharedContext& ctx) {
			if (ctx.concurrency() < 64) {
				set &= (bit_mask(ctx.concurrency()) - 1);
			}
			ptr()->prepare(ctx);
		}
		void destroy() { if (test_bit(cfg, AcquireBit)) { delete ptr(); } }
		Configurator* ptr() const {
			static const uint64 ptrMask = ~(bit_mask(OnceBit) | bit_mask(AcquireBit));
			return reinterpret_cast(static_cast(cfg & ptrMask));
		}
		uint64 cfg;
		uint64 set;
	};
	typedef PodVector::type PPVec;
	Impl()  { acycSet = 0; }
	~Impl() { reset(); }
	void reset();
	void prepare(SharedContext& ctx);
	bool addPost(Solver& s, const SolverParams& opts);
	void add(Configurator* c, Ownership_t::Type t, bool once) { pp.push_back(ConfiguratorProxy(c, t, once)); }
	PPVec   pp;
	uint64  acycSet;
#if WITH_THREADS
	Clasp::mt::mutex mutex;
#endif
};
void ClaspConfig::Impl::reset() {
	for (; !pp.empty(); pp.pop_back()) { pp.back().destroy(); }
}

void ClaspConfig::Impl::prepare(SharedContext& ctx) {
	if (ctx.concurrency() < 64) {
		acycSet &= (bit_mask(ctx.concurrency()) - 1);
	}
	for (PPVec::iterator it = pp.begin(), end = pp.end(); it != end; ++it) {
		it->prepare(ctx);
	}
}
bool ClaspConfig::Impl::addPost(Solver& s, const SolverParams& opts) {
#if WITH_THREADS
#define LOCKED() for (Clasp::mt::unique_lock lock(mutex); lock.owns_lock(); lock.unlock())
#else
#define LOCKED()
#endif
	CLASP_FAIL_IF(s.sharedContext() == 0, "Solver not attached!");
	if (s.sharedContext()->sccGraph.get()) {
		if (DefaultUnfoundedCheck* pp = static_cast(s.getPost(PostPropagator::priority_reserved_ufs))) {
			pp->setReasonStrategy(static_cast(opts.loopRep));
		}
		else if (!s.addPost(new DefaultUnfoundedCheck(*s.sharedContext()->sccGraph, static_cast(opts.loopRep)))) {
			return false;
		}
	}
	if (s.sharedContext()->extGraph.get()) {
		bool addAcyc = false;
		// protect access to acycSet
		LOCKED() { addAcyc = !test_bit(acycSet, s.id()) && store_set_bit(acycSet, s.id()); }
		if (addAcyc && !s.addPost(new AcyclicityCheck(s.sharedContext()->extGraph.get()))) {
			return false;
		}
	}
	for (PPVec::iterator it = pp.begin(), end = pp.end(); it != end; ++it) {
		// protect call to user code
		LOCKED() { if (!it->addPost(s)) { return false; } }
	}
	return true;
#undef LOCKED
}

ClaspConfig::ClaspConfig() : tester_(0), impl_(new Impl()) {}
ClaspConfig::~ClaspConfig() {
	delete impl_;
	delete tester_;
}

void ClaspConfig::reset() {
	if (tester_) { tester_->reset(); }
	impl_->reset();
	BasicSatConfig::reset();
	solve = SolveOptions();
	asp   = AspOptions();
}

BasicSatConfig* ClaspConfig::addTesterConfig() {
	if (!tester_) { tester_ = new BasicSatConfig(); }
	return tester_;
}

void ClaspConfig::prepare(SharedContext& ctx) {
	BasicSatConfig::prepare(ctx);
	uint32 numS = solve.numSolver();
	if (numS > solve.supportedSolvers()) {
		ctx.warn("Too many solvers.");
		numS = solve.supportedSolvers();
	}
	if (numS > solve.recommendedSolvers()) {
		ctx.warn(ClaspStringBuffer().appendFormat("Oversubscription: #Threads=%u exceeds logical CPUs=%u.", numS, solve.recommendedSolvers()));
	}
	for (uint32 i = 0; i != numS; ++i) {
		if (solver(i).heuId == Heuristic_t::Domain) {
			parse.enableHeuristic();
			break;
		}
	}
	solve.setSolvers(numS);
	if (std::abs(static_cast(solve.numModels)) != 1 || !solve.models()) {
		ctx.setPreserveModels(true);
	}
	ctx.setConcurrency(solve.numSolver(), SharedContext::resize_resize);
	impl_->prepare(ctx);
}

Configuration* ClaspConfig::config(const char* n) {
	return (n && std::strcmp(n, "tester") == 0) ? testerConfig() : BasicSatConfig::config(n);
}

void ClaspConfig::addConfigurator(Configurator* c, Ownership_t::Type t, bool once) {
	impl_->add(c, t, once);
}

bool ClaspConfig::addPost(Solver& s) const {
	return impl_->addPost(s, solver(s.id())) && BasicSatConfig::addPost(s);
}

ClaspConfig::Configurator::~Configurator() {}
void ClaspConfig::Configurator::prepare(SharedContext&) {}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspFacade::SolveData/SolveStrategy/AsyncResult
/////////////////////////////////////////////////////////////////////////////////////////
struct ClaspFacade::SolveStrategy {
public:
	enum { SIGCANCEL = 9 };
	enum State { state_start = 0, state_running = 1, state_result = 2, state_model = 3, state_done = 6 };
	SolveStrategy()         { state = signal = 0; nrefs = 1; facade = 0; algo = 0; handler = 0; aTop = 0; }
	virtual ~SolveStrategy(){}
	bool running() const    { return (state & state_running) != 0; }
	bool hasResult()const   { return (state & state_result)  != 0; }
	bool interrupt(int sig) {
		if (!running()) { return false; }
		if (!signal)    { signal = sig; }
		return cancel(sig);
	}
	void solve(ClaspFacade& f, const LitVec& a, SolveAlgorithm* algo, EventHandler* h) {
		this->facade  = &f;
		this->algo    = algo;
		this->handler = h;
		this->aTop    = (uint32)f.assume_.size();
		this->state   = 0;
		this->signal  = 0;
		f.assume_.insert(f.assume_.end(), a.begin(), a.end());
		if (!isSentinel(f.ctx.stepLiteral())) {
			f.assume_.push_back(f.ctx.stepLiteral());
		}
		preSolve();
		this->state = state_running;
		facade->interrupt(0); // handle pending interrupts
		doSolve();
	}
	void detach(State end, bool more) {
		facade->assume_.resize(aTop);
		facade->stopStep(signal, !more);
		if (handler) { handler->onEvent(StepReady(facade->summary())); }
		state = end;
	}
	bool attach() {
		CLASP_FAIL_IF(!running(), "invalid call to attach!");
		if (!signal && !facade->ctx.master()->hasConflict()) {
			facade->step_.solveTime = facade->step_.unsatTime = RealTime::getTime();
			return true;
		}
		facade->ctx.report(Event::subsystem_solve);
		return false;
	}
	bool startGen() {
		if (!attach()) {
			detach(state_done, facade->ok());
			return false;
		}
		algo->start(facade->ctx, facade->assume_, facade);
		return true;
	}
	void stopGen() {
		if (running()) {
			algo->stop();
			detach(state_done, algo->more());
		}
	}
	virtual void release()  {}
	virtual bool cancel(int){ return algo->interrupt(); }
	ClaspFacade*    facade;
	SolveAlgorithm* algo;
	EventHandler*   handler;
	typedef Clasp::Atomic_t::type SafeIntType;
	SafeIntType     state;
	SafeIntType     signal;
	SafeIntType     nrefs;   // Facade + #(Async)Result objects
	uint32          aTop;
protected:
	void runAlgo(State end);
	virtual void preSolve() {}
	virtual void doSolve() = 0;
};
struct ClaspFacade::SolveData {
	struct CostArray {
		CostArray() : data(0) {}
		~CostArray() { while (!refs.empty()) { delete refs.back(); refs.pop_back(); } }
		struct LevelRef {
			LevelRef(const CostArray* a, uint32 l) : arr(a), at(l) {}
			static double value(const LevelRef* ref) {
				CLASP_FAIL_IF(ref->at >= ref->arr->size(), "expired key");
				return static_cast(ref->arr->data->costs->at(ref->at));
			}
			const CostArray* arr;
			uint32           at;
		};
		typedef PodVector::type ElemVec;
		uint32 size() const {
			return data && data->costs ? sizeVec(*data->costs) : 0;
		}
		StatisticObject at(uint32 i) const {
			CLASP_FAIL_IF(i >= size(), "invalid key");
			while (i >= refs.size()) { refs.push_back(new LevelRef(this, sizeVec(refs))); }
			return StatisticObject::value(refs[i]);
		}
		const Model*    data;
		mutable ElemVec refs;
	};
	typedef SingleOwnerPtr AlgoPtr;
	typedef SingleOwnerPtr     EnumPtr;
	typedef Clasp::Atomic_t::type     SafeIntType;
	SolveData() : en(0), algo(0), active(0), prepared(false), interruptible(false) { qSig = 0; }
	~SolveData() { reset(); }
	void init(SolveAlgorithm* algo, Enumerator* en) {
		this->en   = en;
		this->algo = algo;
		this->algo->setEnumerator(*en);
		if (interruptible) {
			this->algo->enableInterrupts();
		}
	}
	void reset() {
		if (active)    { active->interrupt(SolveStrategy::SIGCANCEL); active->release(); active = 0; }
		if (algo.get()){ algo->resetSolve(); }
		if (en.get())  { en->reset(); }
		prepared = false;
	}
	void prepareEnum(SharedContext& ctx, int64 numM, EnumOptions::OptMode opt, EnumMode mode) {
		CLASP_FAIL_IF(active, "Solve operation still active");
		if (ctx.ok() && !ctx.frozen() && !prepared) {
			if (mode == enum_volatile && ctx.solveMode() == SharedContext::solve_multi) {
				ctx.requestStepVar();
			}
			int lim = en->init(ctx, opt, (int)Range(-1, INT_MAX).clamp(numM));
			if (lim == 0 || numM < 0) {
				numM = lim;
			}
			algo->setEnumLimit(numM ? static_cast(numM) : UINT64_MAX);
			costs.data = lastModel();
		}
		prepared = true;
	}
	bool update(const Solver& s, const Model& m) { return !active->handler || active->handler->onModel(s, m); }
	bool interrupt(int sig) {
		if (solving()) { return active->interrupt(sig); }
		if (!qSig && sig != SolveStrategy::SIGCANCEL) { qSig = sig; }
		return false;
	}
	bool                      solving()   const  { return active && active->running();   }
	const Model*              lastModel() const  { return en.get() ? &en->lastModel() : 0; }
	const SharedMinimizeData* minimizer() const  { return en.get() ? en->minimizer() : 0; }
	Enumerator*               enumerator()const  { return en.get(); }
	int                       modelType() const  { return en.get() ? en->modelType() : 0; }
	EnumPtr        en;
	AlgoPtr        algo;
	SolveStrategy* active;
	CostArray      costs;
	SafeIntType    qSig;
	bool           prepared;
	bool           interruptible;
};
void ClaspFacade::SolveStrategy::runAlgo(State done) {
	struct OnExit {
		OnExit(SolveStrategy* s, int st) : self(s), endState(st), more(true) {}
		~OnExit() {
			self->detach(static_cast(endState), more);
		}
		SolveStrategy* self;
		int            endState;
		bool           more;
	} scope(this, done);
	scope.more = attach() ? algo->solve(facade->ctx, facade->assume_, facade) : facade->ctx.ok();
}

#if WITH_THREADS
struct ClaspFacade::AsyncSolve : public SolveStrategy, public EventHandler {
	enum { ASYNC_ERROR = 128 };
	static EventHandler* asyncModelHandler() { return reinterpret_cast(0x1); }
	AsyncSolve() { }
	bool hasError() const {
		return (result.flags & uint8(ASYNC_ERROR)) != 0u;
	}
	virtual void preSolve() {
		if (handler == AsyncSolve::asyncModelHandler()) { handler = this; }
		algo->enableInterrupts();
		result = facade->result();
	}
	virtual void doSolve() {
		// start solve in worker thread
		Clasp::mt::thread(std::mem_fun(&AsyncSolve::threadMain), this).swap(task);
	}
	virtual bool cancel(int sig) {
		if (!SolveStrategy::cancel(sig)) return false;
		if (sig == SIGCANCEL) {
			wait();
			join();
		}
		return true;
	}
	void threadMain() {
		uint8 err = 0;
		try         { runAlgo(state_running); }
		catch (...) { err = uint8(ASYNC_ERROR); }
		{
			mt::unique_lock lock(this->mqMutex);
			result = facade->result();
			result.flags |= err;
			state  = state_done;
		}
		mqCond.notify_one();
	}
	virtual void release() {
		if      (--nrefs == 1) { interrupt(SIGCANCEL); }
		else if (nrefs   == 0) { join(); delete this; }
	}
	bool next() {
		if (state != state_model) { return false; }
		mt::unique_lock lock(mqMutex);
		if (state != state_model) { return false; }
		state = state_running;
		mqCond.notify_one();
		return true;
	}
	bool wait(double s = -1.0) {
		if (state == state_start) { return false; }
		if (signal != 0)          { next(); }
		for (mt::unique_lock lock(mqMutex); !hasResult(); ) {
			if (s < 0.0) { mqCond.wait(lock); }
			else {
				mqCond.wait_for(lock, s);
				if (!hasResult()) { return false; }
			}
		}
		if (state == state_done && join()) {
			// Just in case other AsyncSolve objects are waiting on the computation.
			// This should not happen but there is some existing code that uses
			// an AsyncSolve object in a separate thread for cancellation.
			mqCond.notify_all();
		}
		return true;
	}
	bool onModel(const Solver&, const Model&) {
		const Result sat = {Result::SAT, 0};
		mt::unique_lock lock(mqMutex);
		state = state_model;
		result= sat;
		mqCond.notify_one();
		while (state == state_model && signal == 0) { mqCond.wait(lock); }
		return signal == 0;
	}
	bool join() { if (task.joinable()) { task.join(); return true; } return false; }
	Clasp::mt::thread             task;   // async solving thread
	Clasp::mt::mutex              mqMutex;// protects mqCond
	Clasp::mt::condition_variable mqCond; // for iterating over models one by one
	Result                        result; // result of async operation
};
ClaspFacade::AsyncResult::AsyncResult(SolveData& x) : state_(static_cast(x.active)) { ++state_->nrefs; }
ClaspFacade::AsyncResult::~AsyncResult() { state_->release(); }
ClaspFacade::AsyncResult::AsyncResult(const AsyncResult& x) : state_(x.state_) { ++state_->nrefs; }
int  ClaspFacade::AsyncResult::interrupted()        const { return state_->signal; }
bool ClaspFacade::AsyncResult::error()              const { return ready() && state_->hasError(); }
bool ClaspFacade::AsyncResult::ready()              const { return state_->hasResult(); }
bool ClaspFacade::AsyncResult::ready(Result& r)     const { if (ready()) { r = get(); return true; } return false; }
bool ClaspFacade::AsyncResult::running()            const { return state_->running(); }
void ClaspFacade::AsyncResult::wait()               const { state_->wait(-1.0); }
bool ClaspFacade::AsyncResult::waitFor(double sec)  const { return state_->wait(sec); }
bool ClaspFacade::AsyncResult::next()               const { return state_->next(); }
bool ClaspFacade::AsyncResult::cancel()             const { return state_->interrupt(AsyncSolve::SIGCANCEL); }
ClaspFacade::Result ClaspFacade::AsyncResult::get() const {
	state_->wait();
	if (!state_->hasError()) { return state_->result; }
	throw std::runtime_error("Async operation failed!");
}
bool ClaspFacade::AsyncResult::end() const {
	// first running() handles case where iterator is outdated (state was reset to start)
	// second running() is used to distinguish models from final result (summary)
	return !running() || !get().sat() || !running();
}
const Model& ClaspFacade::AsyncResult::model() const {
	CLASP_FAIL_IF(state_->state != AsyncSolve::state_model, "Invalid iterator access!");
	return const_cast(state_->algo)->enumerator()->lastModel();
}
#endif
ClaspFacade::ModelGenerator::ModelGenerator(SolveStrategy& impl) : impl_(&impl) {
	++impl_->nrefs;
}
ClaspFacade::ModelGenerator::ModelGenerator(const ModelGenerator& o) : impl_(o.impl_) {
	++impl_->nrefs;
}
ClaspFacade::ModelGenerator::~ModelGenerator() {
	impl_->release();
}
bool ClaspFacade::ModelGenerator::next() const {
	if (!impl_->running()) {
		return false;
	}
	if (impl_->state != SolveStrategy::state_model && !impl_->startGen()) {
		return false;
	}
	if (!impl_->algo->next()) {
		impl_->stopGen();
		return false;
	}
	impl_->state = SolveStrategy::state_model;
	return true;
}
const Model& ClaspFacade::ModelGenerator::model()  const {
	CLASP_FAIL_IF(!impl_->hasResult(), "Invalid iterator access!");
	return impl_->facade->enumerator()->lastModel();
}
ClaspFacade::Result ClaspFacade::ModelGenerator::result() const {
	CLASP_FAIL_IF(!impl_->hasResult(), "Invalid iterator access!");
	return impl_->facade->result();
}
void ClaspFacade::ModelGenerator::stop() const {
	impl_->stopGen();
}
ClaspFacade::ModelGenerator ClaspFacade::startSolve(const LitVec& a) {
	prepare();
	struct MG : public SolveStrategy {
		virtual void doSolve() { }
		virtual void release() {
			switch (--nrefs) {
				case 1: stopGen();   break;
				case 0: delete this; break;
				default: break;
			}
		}
	};
	solve_->active = new MG();
	solve_->active->solve(*this, a, solve_->algo.get(), 0);
	return ModelGenerator(*solve_->active);
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspFacade::Statistics
/////////////////////////////////////////////////////////////////////////////////////////
namespace {
struct KV { const char* key; StatisticObject(*get)(const ClaspFacade::Summary*); };
template 
StatisticObject _getT(const ClaspFacade::Summary* x) { return StatisticObject::value(&static_cast((x->*time))); }
template 
StatisticObject _getM(const ClaspFacade::Summary* x) { return StatisticObject::value(&static_cast((x->*model))); }
static const KV sumKeys_s[] = {
	{"total"     , _getT<&ClaspFacade::Summary::totalTime>},
	{"cpu"       , _getT<&ClaspFacade::Summary::cpuTime>},
	{"solve"     , _getT<&ClaspFacade::Summary::solveTime>},
	{"unsat"     , _getT<&ClaspFacade::Summary::unsatTime>},
	{"sat"       , _getT<&ClaspFacade::Summary::satTime>},
	{"enumerated", _getM<&ClaspFacade::Summary::numEnum>},
	{"optimal"   , _getM<&ClaspFacade::Summary::numOptimal>},
};
struct SummaryStats {
	SummaryStats() : stats_(0), range_(0,0) {}
	void bind(const ClaspFacade::Summary& x, Range32 r) {
		stats_ = &x;
		range_ = r;
	}
	uint32          size()        const { return range_.hi - range_.lo; }
	const char*     key(uint32 i) const { return i < size() ? sumKeys_s[i + range_.lo].key : throw std::out_of_range("SummaryStats::key()"); }
	StatisticObject at(const char* key) const {
		for (const KV* x = sumKeys_s + range_.lo, *end = sumKeys_s + range_.hi; x != end; ++x) {
			if (std::strcmp(x->key, key) == 0) { return x->get(stats_); }
		}
		throw std::out_of_range("SummaryStats::at()");
	}
	StatisticObject toStats() const { return StatisticObject::map(this); }
	const ClaspFacade::Summary* stats_;
	Range32 range_;
};

double _getConcurrency(const SharedContext* ctx) { return ctx->concurrency(); }
double _getWinner(const SharedContext* ctx) { return ctx->winner(); }
double _getResult(const SolveResult* r) { return static_cast(r->operator Clasp::SolveResult::Base()); }
double _getSignal(const SolveResult* r) { return static_cast(r->signal); }
double _getExhausted(const SolveResult* r) { return static_cast(r->exhausted()); }
}
struct ClaspFacade::Statistics {
	Statistics(ClaspFacade& f) : self_(&f), tester_(0), level_(0), clingo_(0) {}
	~Statistics() { delete clingo_; delete solvers_.multi; }
	void start(uint32 level);
	void initLevel(uint32 level);
	void end();
	void addTo(StatsMap& solving, StatsMap* accu) const;
	void accept(StatsVisitor& out, bool final) const;
	bool incremental() const { return self_->incremental(); }
	Potassco::AbstractStatistics* getClingo();
	typedef StatsVec        SolverVec;
	typedef SingleOwnerPtr LpStatsPtr;
	typedef PrgDepGraph::NonHcfStats     TesterStats;
	ClaspFacade*  self_;
	LpStatsPtr    lp_;      // level 0 and asp
	SolverStats   solvers_; // level 0
	SolverVec     solver_;  // level > 1
	SolverVec     accu_;    // level > 1 and incremental
	TesterStats*  tester_;  // level > 0 and nonhcfs
	uint32        level_;   // active stats level
	// For clingo stats interface
	class ClingoView : public ClaspStatistics {
	public:
		explicit ClingoView(const ClaspFacade& f);
		void update(const Statistics& s);
	private:
		struct StepStats {
			SummaryStats times;
			SummaryStats models;
			void bind(const ClaspFacade::Summary& x) {
				times.bind(x, Range32(0, 5));
				models.bind(x, Range32(5, 7));
			}
			void addTo(StatsMap& summary) {
				summary.add("times", times.toStats());
				summary.add("models", models.toStats());
			}
		};
		StatsMap keys_;
		StatsMap problem_;
		StatsMap solving_;
		struct Summary : StatsMap { StepStats step; } summary_;
		struct Accu    : StatsMap { StepStats step; StatsMap solving_; };
		typedef SingleOwnerPtr AccuPtr;
		AccuPtr accu_;
	}* clingo_; // new clingo stats interface;
};
void ClaspFacade::Statistics::initLevel(uint32 level) {
	if (level_ < level) {
		if (incremental() && !solvers_.multi) { solvers_.multi = new SolverStats(); }
		level_ = level;
	}
	if (self_->isAsp() && !lp_.get()) {
		lp_ = new Asp::LpStats();
	}
	if (self_->ctx.sccGraph.get() && self_->ctx.sccGraph->numNonHcfs() && !tester_) {
		tester_ = self_->ctx.sccGraph->nonHcfStats();
	}
}
void ClaspFacade::Statistics::start(uint32 level) {
	// cleanup previous state
	solvers_.reset();
	solver_.reset();
	if (tester_) { tester_->startStep(self_->config()->testerConfig() ? self_->config()->testerConfig()->context().stats : 0); }
	// init next step
	initLevel(level);
	if (lp_.get() && self_->step_.lpStep()) {
		lp_->accu(*self_->step_.lpStep());
	}
	if (level > 1 && solver_.size() < self_->ctx.concurrency()) {
		uint32 sz = sizeVec(solver_);
		solver_.growTo(self_->ctx.concurrency());
		for (const bool inc = incremental() && (accu_.growTo(sizeVec(solver_)), true); sz != sizeVec(solver_); ++sz) {
			if (!inc) { solver_[sz] = &self_->ctx.solverStats(sz); }
			else      { (solver_[sz] = new SolverStats())->multi = (accu_[sz] = new SolverStats()); }
		}
		if (!incremental()) { solver_.release(); }
	}
}
void ClaspFacade::Statistics::end() {
	self_->ctx.accuStats(solvers_); // compute solvers = sum(solver[1], ... , solver[n])
	solvers_.flush();
	for (uint32 i = incremental() ? 0 : sizeVec(solver_), end = sizeVec(solver_); i != end && self_->ctx.hasSolver(i); ++i) {
		solver_[i]->accu(self_->ctx.solverStats(i), true);
		solver_[i]->flush();
	}
	if (tester_) { tester_->endStep(); }
	if (clingo_) { clingo_->update(*this); }
}
void ClaspFacade::Statistics::addTo(StatsMap& solving, StatsMap* accu) const {
	solvers_.addTo("solvers", solving, accu);
	if (solver_.size())       { solving.add("solver", solver_.toStats()); }
	if (accu && accu_.size()) { accu->add("solver", accu_.toStats()); }
}
void ClaspFacade::Statistics::accept(StatsVisitor& out, bool final) const {
	final = final && solvers_.multi;
	if (out.visitGenerator(StatsVisitor::Enter)) {
		out.visitSolverStats(final ? *solvers_.multi : solvers_);
		if (lp_.get()) { out.visitLogicProgramStats(*lp_); }
		out.visitProblemStats(self_->ctx.stats());
		const SolverVec& solver = final ? accu_ : solver_;
		const uint32 nThreads = final ? (uint32)accu_.size() : self_->ctx.concurrency();
		const uint32 nSolver  = (uint32)solver.size();
		if (nThreads > 1 && nSolver > 1 && out.visitThreads(StatsVisitor::Enter)) {
			for (uint32 i = 0, end = std::min(nSolver, nThreads); i != end; ++i) {
				out.visitThread(i, *solver[i]);
			}
			out.visitThreads(StatsVisitor::Leave);
		}
		out.visitGenerator(StatsVisitor::Leave);
	}
	if (tester_ && out.visitTester(StatsVisitor::Enter)) {
		tester_->accept(out, final);
		out.visitTester(StatsVisitor::Leave);
	}
}
Potassco::AbstractStatistics* ClaspFacade::Statistics::getClingo() {
	if (!clingo_) {
		clingo_ = new ClingoView(*this->self_);
		clingo_->update(*this);
	}
	return clingo_;
}
ClaspFacade::Statistics::ClingoView::ClingoView(const ClaspFacade& f) {
	summary_.add("call"       , StatisticObject::value(&f.step_.step));
	summary_.add("result"     , StatisticObject::value(&f.step_.result));
	summary_.add("signal"     , StatisticObject::value(&f.step_.result));
	summary_.add("exhausted"  , StatisticObject::value(&f.step_.result));
	summary_.add("costs"      , StatisticObject::array(&f.solve_->costs));
	summary_.add("concurrency", StatisticObject::value(&f.ctx));
	summary_.add("winner"     , StatisticObject::value(&f.ctx));
	summary_.step.bind(f.step_);
	summary_.step.addTo(summary_);
	if (f.step_.lpStats()) {
		problem_.add("lp", StatisticObject::map(f.step_.lpStats()));
		if (f.incremental()) { problem_.add("lpStep", StatisticObject::map(f.step_.lpStep())); }
	}
	problem_.add("generator", StatisticObject::map(&f.ctx.stats()));
	keys_.add("problem", problem_.toStats());
	keys_.add("solving", solving_.toStats());
	keys_.add("summary", summary_.toStats());
	if (f.incremental()) {
		accu_ = new Accu();
		accu_->step.bind(*f.accu_.get());
	}
	setRoot(keys_.toStats());
}
void ClaspFacade::Statistics::ClingoView::update(const ClaspFacade::Statistics& stats) {
	if (stats.level_ > 0 && accu_.get() && keys_.add("accu", accu_->toStats())) {
		accu_->step.addTo(*accu_);
		accu_->add("solving", accu_->solving_.toStats());
	}
	stats.addTo(solving_, stats.level_ > 0 && accu_.get() ? &accu_->solving_ : 0);
	if (stats.tester_) {
		stats.tester_->addTo(problem_, solving_, stats.level_ > 0 && accu_.get() ? &accu_->solving_ : 0);
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspFacade
/////////////////////////////////////////////////////////////////////////////////////////
ClaspFacade::ClaspFacade() : config_(0) { step_.init(*this); }
ClaspFacade::~ClaspFacade() {}
bool ClaspFacade::prepared() const {
	return solve_.get() && solve_->prepared;
}
bool ClaspFacade::solving() const {
	return solve_.get() && solve_->solving();
}
bool ClaspFacade::solved() const {
	return step_.totalTime >= 0;
}
bool ClaspFacade::interrupted() const {
	return result().interrupted();
}
bool ClaspFacade::incremental() const {
	return accu_.get() != 0;
}
ProblemType ClaspFacade::detectProblemType(std::istream& str) {
	return Clasp::detectProblemType(str);
}
const ClaspFacade::Summary&  ClaspFacade::summary(bool accu) const {
	return accu && accu_.get() && accu_->step ? *accu_ : step_;
}

void ClaspFacade::discardProblem() {
	config_  = 0;
	builder_ = 0;
	stats_   = 0;
	solve_   = 0;
	accu_    = 0;
	step_.init(*this);
	if (ctx.frozen() || ctx.numVars()) { ctx.reset(); }
}
void ClaspFacade::init(ClaspConfig& config, bool discard) {
	if (discard) { discardProblem(); }
	ctx.setConfiguration(0, Ownership_t::Retain); // force reload of configuration once done
	config_ = &config;
	if (config_->solve.enumMode == EnumOptions::enum_dom_record) {
		if (config_->solver(0).heuId != Heuristic_t::Domain) {
			ctx.warn("Reasoning mode requires domain heuristic and is ignored!");
			config_->solve.enumMode = EnumOptions::enum_auto;
		}
		else if ((config_->solver(0).heuristic.domPref & HeuParams::pref_show) != 0) {
			ctx.setPreserveShown(true);
		}
	}
	SolveData::EnumPtr e(config.solve.createEnumerator(config.solve));
	if (e.get() == 0) { e = EnumOptions::nullEnumerator(); }
	if (config.solve.numSolver() > 1 && !e->supportsParallel()) {
		ctx.warn("Selected reasoning mode implies #Threads=1.");
		config.solve.setSolvers(1);
	}
	ctx.setConfiguration(&config, Ownership_t::Retain); // prepare and apply config
	if (program() && type_ == Problem_t::Asp) {
		Asp::LogicProgram* p = static_cast(program());
		p->setOptions(config.asp);
		p->setNonHcfConfiguration(config.testerConfig());
	}
	if (!solve_.get()) { solve_ = new SolveData(); }
	SolveData::AlgoPtr a(config.solve.createSolveObject());
	solve_->init(a.release(), e.release());
	if (discard) { startStep(0); }
}

void ClaspFacade::initBuilder(ProgramBuilder* in) {
	builder_ = in;
	assume_.clear();
	builder_->startProgram(ctx);
}
ProgramBuilder& ClaspFacade::start(ClaspConfig& config, ProblemType t) {
	if      (t == Problem_t::Sat) { return startSat(config); }
	else if (t == Problem_t::Pb)  { return startPB(config);  }
	else if (t == Problem_t::Asp) { return startAsp(config); }
	else                          { throw std::domain_error("Unknown problem type!"); }
}

ProgramBuilder& ClaspFacade::start(ClaspConfig& config, std::istream& str) {
	ProgramParser& p = start(config, detectProblemType(str)).parser();
	CLASP_FAIL_IF(!p.accept(str, config_->parse), "Auto detection failed!");
	if (p.incremental()) { enableProgramUpdates(); }
	return *program();
}

SatBuilder& ClaspFacade::startSat(ClaspConfig& config) {
	init(config, true);
	initBuilder(new SatBuilder(config.solve.maxSat));
	type_ = Problem_t::Sat;
	return static_cast(*builder_.get());
}

PBBuilder& ClaspFacade::startPB(ClaspConfig& config) {
	init(config, true);
	initBuilder(new PBBuilder());
	type_ = Problem_t::Sat;
	return static_cast(*builder_.get());
}

Asp::LogicProgram& ClaspFacade::startAsp(ClaspConfig& config, bool enableUpdates) {
	init(config, true);
	Asp::LogicProgram* p = new Asp::LogicProgram();
	initBuilder(p);
	p->setOptions(config.asp);
	p->setNonHcfConfiguration(config.testerConfig());
	type_ = Problem_t::Asp;
	if (enableUpdates) { enableProgramUpdates(); }
	return *p;
}

bool ClaspFacade::enableProgramUpdates() {
	CLASP_ASSERT_CONTRACT_MSG(program(), "Program was already released!");
	CLASP_ASSERT_CONTRACT(!solving() && !program()->frozen());
	if (!accu_.get()) {
		builder_->updateProgram();
		ctx.setSolveMode(SharedContext::solve_multi);
		enableSolveInterrupts();
		accu_ = new Summary();
		accu_->init(*this);
		accu_->step = UINT32_MAX;
	}
	return isAsp(); // currently only ASP supports program updates
}
void ClaspFacade::enableSolveInterrupts() {
	CLASP_ASSERT_CONTRACT_MSG(!solving()  , "Solving is already active!");
	CLASP_ASSERT_CONTRACT_MSG(solve_.get(), "Active program required!");
	if (!solve_->interruptible) {
		solve_->interruptible = true;
		solve_->algo->enableInterrupts();
	}
}

void ClaspFacade::startStep(uint32 n) {
	step_.init(*this);
	step_.totalTime = -RealTime::getTime();
	step_.cpuTime   = -ProcessTime::getTime();
	step_.step      = n;
	if (!stats_.get()) { stats_ = new Statistics(*this); }
	ctx.report(StepStart(*this));
}

ClaspFacade::Result ClaspFacade::stopStep(int signal, bool complete) {
	if (!solved()) {
		double t = RealTime::getTime();
		step_.totalTime += t;
		step_.cpuTime   += ProcessTime::getTime();
		if (step_.solveTime) {
			step_.solveTime = t - step_.solveTime;
			step_.unsatTime = complete ? t - step_.unsatTime : 0;
		}
		Result res = {uint8(0), uint8(signal)};
		if (complete) { res.flags = uint8(step_.numEnum ? Result::SAT : Result::UNSAT) | Result::EXT_EXHAUST; }
		else          { res.flags = uint8(step_.numEnum ? Result::SAT : Result::UNKNOWN); }
		if (signal)   { res.flags|= uint8(Result::EXT_INTERRUPT); }
		step_.result = res;
		if (res.sat() && step_.model()->opt && !step_.numOptimal) {
			step_.numOptimal = 1;
		}
		updateStats();
		ctx.report(StepReady(step_));
	}
	return result();
}

void ClaspFacade::updateStats() {
	if (stats_.get()) {
		stats_->end();
	}
	if (accu_.get() && accu_->step != step_.step) {
		accu_->totalTime  += step_.totalTime;
		accu_->cpuTime    += step_.cpuTime;
		accu_->solveTime  += step_.solveTime;
		accu_->unsatTime  += step_.unsatTime;
		accu_->satTime    += step_.satTime;
		accu_->numEnum    += step_.numEnum;
		accu_->numOptimal += step_.numOptimal;
		// no aggregation
		accu_->step   = step_.step;
		accu_->result = step_.result;
	}
}

bool ClaspFacade::interrupt(int signal) {
	return solve_.get() && (signal || (signal = solve_->qSig.fetch_and_store(0)) != 0) && solve_->interrupt(signal);
}

const ClaspFacade::Summary& ClaspFacade::shutdown() {
	if (solve_.get()) {
		solve_->interrupt(SolveStrategy::SIGCANCEL);
		stopStep(solving() ? solve_->active->signal : solve_->qSig, !ok());
	}
	return summary(true);
}

bool ClaspFacade::read() {
	CLASP_ASSERT_CONTRACT(solve_.get());
	if (!program() || interrupted()) { return false; }
	ProgramParser& p = program()->parser();
	if (!p.isOpen() || (solved() && !update().ok())) { return false; }
	CLASP_FAIL_IF(!p.parse(), "Invalid input stream!");
	if (!p.more()) { p.reset(); }
	return true;
}
void ClaspFacade::prepare(EnumMode enumMode) {
	CLASP_ASSERT_CONTRACT(solve_.get() && !solving());
	EnumOptions& en = config_->solve;
	if (solved()) {
		doUpdate(0, false, SIG_DFL);
		solve_->prepareEnum(ctx, en.numModels, en.optMode, enumMode);
		ctx.endInit();
	}
	if (prepared()) { return; }
	SharedMinimizeData* m = 0;
	ProgramBuilder*   prg = program();
	if (prg && prg->endProgram()) {
		assume_.clear();
		prg->getAssumptions(assume_);
		prg->getWeakBounds(en.optBound);
	}
	stats_->start(uint32(config_->context().stats));
	if (ctx.ok() && en.optMode != MinimizeMode_t::ignore && (m = ctx.minimize()) != 0) {
		if (!m->setMode(en.optMode, en.optBound)) {
			assume_.push_back(lit_false());
		}
		if (en.optMode == MinimizeMode_t::enumerate && en.optBound.empty()) {
			ctx.warn("opt-mode=enum: no bound given, optimize statement ignored.");
		}
	}
	CLASP_ASSERT_CONTRACT(!ctx.ok() || !ctx.frozen());
	solve_->prepareEnum(ctx, en.numModels, en.optMode, enumMode);
	if      (!accu_.get()) { builder_ = 0; }
	else if (isAsp())      { static_cast(builder_.get())->dispose(false); }
	if (!builder_.get() && !ctx.heuristic.empty()) {
		bool keepDom = false;
		for (uint32 i = 0; i != config_->solve.numSolver() && !keepDom; ++i) {
			keepDom = config_->solver(i).heuId == Heuristic_t::Domain;
		}
		if (!keepDom) { ctx.heuristic.reset(); }
	}
	if (ctx.ok()) { ctx.endInit(); }
}

ClaspFacade::Result ClaspFacade::solve(EventHandler* handler, const LitVec& a) {
	prepare();
	struct SyncSolve : public SolveStrategy {
		SyncSolve(SolveData& s) : x(&s) { x->active = this; }
		~SyncSolve()                    { x->active = 0;    }
		virtual void doSolve() { runAlgo(state_done); }
		SolveData* x;
	} syncSolve(*solve_);
	syncSolve.solve(*this, a, solve_->algo.get(), handler);
	return result();
}
#if WITH_THREADS
ClaspFacade::AsyncResult ClaspFacade::solveAsync(EventHandler* handler, const LitVec& a) {
	prepare();
	solve_->active = new AsyncSolve();
	solve_->active->solve(*this, a, solve_->algo.get(), handler);
	return AsyncResult(*solve_);
}
ClaspFacade::AsyncResult ClaspFacade::startSolveAsync(const LitVec& a) {
	return solveAsync(AsyncSolve::asyncModelHandler(), a);
}
#endif

ProgramBuilder& ClaspFacade::update(bool updateConfig, void (*sigAct)(int)) {
	CLASP_ASSERT_CONTRACT(config_ && program() && !solving());
	doUpdate(program(), updateConfig, sigAct);
	return *program();
}
ProgramBuilder& ClaspFacade::update(bool updateConfig) {
	return update(updateConfig, SIG_DFL);
}

void ClaspFacade::doUpdate(ProgramBuilder* p, bool updateConfig, void(*sigAct)(int)) {
	if (updateConfig) {
		init(*config_, false);
	}
	if (solved()) {
		startStep(step() + 1);
	}
	if (p && p->frozen()) {
		p->updateProgram();
	}
	if (ctx.frozen()) {
		ctx.unfreeze();
	}
	solve_->reset();
	int sig = sigAct == SIG_DFL ? 0 : solve_->qSig.fetch_and_store(0);
	if (sig && sigAct != SIG_IGN) { sigAct(sig); }
}

bool ClaspFacade::onModel(const Solver& s, const Model& m) {
	step_.unsatTime = RealTime::getTime();
	if (++step_.numEnum == 1) { step_.satTime = step_.unsatTime - step_.solveTime; }
	if (m.opt) { ++step_.numOptimal; }
	return solve_->update(s, m);
}
Enumerator* ClaspFacade::enumerator() const { return solve_.get() ? solve_->enumerator() : 0; }
Potassco::AbstractStatistics* ClaspFacade::getStats() const {
	CLASP_FAIL_IF(!config_ || !solved(), "statistics not (yet) available");
	return stats_->getClingo();
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspFacade::Summary
/////////////////////////////////////////////////////////////////////////////////////////
void ClaspFacade::Summary::init(ClaspFacade& f)  { std::memset(this, 0, sizeof(Summary)); facade = &f;}
const Model* ClaspFacade::Summary::model() const { return facade->solve_.get() ? facade->solve_->lastModel() : 0; }
const SumVec* ClaspFacade::Summary::costs()const { return model() ? model()->costs : 0; }
uint64  ClaspFacade::Summary::optimal()    const { return facade->step_.numOptimal; }
bool ClaspFacade::Summary::optimize()      const {
	if (const Enumerator* e = facade->enumerator()){
		return e->optimize() || e->lastModel().opt;
	}
	return false;
}
const Asp::LpStats* ClaspFacade::Summary::lpStep() const {
	return facade->isAsp() ? &static_cast(facade->program())->stats : 0;
}
const Asp::LpStats* ClaspFacade::Summary::lpStats() const {
	return facade->stats_.get() ? facade->stats_->lp_.get() : lpStep();
}
const char* ClaspFacade::Summary::consequences() const {
	const Model* m = model();
	return m && m->consequences() ? modelType(*m) : 0;
}

bool ClaspFacade::Summary::hasLower() const {
	const SharedMinimizeData* m = optimize() ? facade->enumerator()->minimizer() : 0;
	return m && m->lower(0) != 0;
}
SumVec ClaspFacade::Summary::lower() const {
	if (hasLower()) {
		const SharedMinimizeData* m = facade->enumerator()->minimizer();
		SumVec ret(m->numRules());
		for (uint32 i = 0; i != m->numRules(); ++i) {
			ret[i] = m->lower(i) + m->adjust(i);
		}
		return ret;
	}
	return SumVec();
}
void ClaspFacade::Summary::accept(StatsVisitor& out) const {
	if (facade->solved()) { facade->stats_->accept(out, this == facade->accu_.get()); }
}

}

clasp-3.2.2/libclasp/src/clasp_options.cpp000066400000000000000000001235051304134206100205610ustar00rootroot00000000000000//
// Copyright (c) 2006-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#ifdef _MSC_VER
#pragma warning (disable : 4996)
#pragma warning (disable : 4290) // C++ exception specification ignored
#endif
/////////////////////////////////////////////////////////////////////////////////////////
// Helper MACROS
/////////////////////////////////////////////////////////////////////////////////////////
#define SET(x, v)           ( ((x)=(v)) == (v) )
#define SET_LEQ(x, v, m)    ( ((v)<=(m)) && SET((x), (v)) )
#define SET_GEQ(x, v, m)    ( ((v)>=(m)) && SET((x), (v)) )
#define SET_OR_FILL(x, v)   ( SET((x),(v)) || ((x) = 0, (x) = ~(x),true) )
#define SET_OR_ZERO(x,v)    ( SET((x),(v)) || SET((x),uint32(0)) )
#define SET_R(x, v, lo, hi) ( ((lo)<=(v)) && ((v)<=(hi)) && SET((x), (v)) )
/////////////////////////////////////////////////////////////////////////////////////////
// Primitive types/functions for string <-> T conversions
/////////////////////////////////////////////////////////////////////////////////////////
namespace bk_lib {
static const struct OffType {} off = {};
static int xconvert(const char* x, const OffType&, const char** errPos, int) {
	bool temp = true;
	const char* n = x;
	if (xconvert(n, temp, &n, 0) && !temp) { x = n; }
	if (errPos) { *errPos = x; }
	return int(temp == false);
}
static std::string& xconvert(std::string& out, const OffType&) { return out.append("no"); }

template 
static int xconvert(const char* x, pod_vector& out, const char** errPos, int sep) {
	if (sep == 0) { sep = def_sep; }
	std::size_t sz = out.size();
	std::size_t t  = convert_seq(x, out.max_size() - sz, std::back_inserter(out), static_cast(sep), errPos);
	if (!t) { out.resize(sz); }
	return static_cast(t);
}
template 
static std::string& xconvert(std::string& out, const pod_vector& x) { return xconvert(out, x.begin(), x.end()); }

static std::size_t findEnumValImpl(const char* value, int& out, const char* k1, int v1, va_list args) {
	std::size_t kLen = std::strlen(k1);
	std::size_t vLen = std::strlen(value);
	if (const char* x = std::strchr(value, ',')) {
		vLen = x - value;
	}
	if (vLen == kLen && strncasecmp(value, k1, kLen) == 0) { out = v1; return kLen; }
	while (const char* key = va_arg(args, const char *)) {
		int val = va_arg(args, int);
		kLen    = std::strlen(key);
		if (vLen == kLen && strncasecmp(value, key, kLen) == 0) { out = val; return kLen; }
	}
	return 0;
}
template 
static int findEnumVal(const char* value, T& out, const char** errPos, const char* k1, int v1, ...) {
	va_list args;
	va_start(args, v1);
	int temp;
	std::size_t p = bk_lib::findEnumValImpl(value, temp, k1, v1, args);
	va_end(args);
	if (errPos) { *errPos = value + p; }
	if (p)      { out = static_cast(temp); }
	return p != 0;
}
static const char* enumToString(int x, const char* k1, int v1, ...) {
	va_list args;
	va_start(args, v1);
	const char* res = x == v1 ? k1 : 0;
	if (res == 0) {
		while (const char* key = va_arg(args, const char *)) {
			int val = va_arg(args, int);
			if (x == val) { res = key; break; }
		}
	}
	va_end(args);
	return res ? res : "";
}
struct ArgString {
	ArgString(const char* x) : in(x) { }
	~ArgString() throw (std::logic_error) { CLASP_FAIL_IF(ok() && *in && !off(), "Unused argument!"); }
	bool ok()       const { return in != 0; }
	bool off()      const { return ok() && stringTo(in, bk_lib::off); }
	bool empty()    const { return ok() && !*in; }
	operator void*()const { return (void*)in; }
	char peek()     const { return ok() ? *in : 0; }
	template 
	ArgString& get(T& x)  {
		if (ok()) {
			const char* next = in + (*in == ',');
			in = xconvert(next, x, &next, 0) != 0 ? next : 0;
		}
		return *this;
	}
	const char* in;
	template 
	struct Opt_t {
		Opt_t(T& x) : obj(&x) {}
		T* obj;
	};
};
template 
inline ArgString::Opt_t opt(T& x) { return ArgString::Opt_t(x); }
template 
inline ArgString& operator>>(ArgString& arg, T& x) { return arg.get(x); }
template 
inline ArgString& operator>>(ArgString& arg, const ArgString::Opt_t& x) { return !arg.empty() ? arg.get(*x.obj) : arg; }

struct StringBuilder {
	StringBuilder(std::string& o) : out(&o) {}
	template 
	StringBuilder& _add(const T& x) {
		if (!out->empty()) { out->append(1, ','); }
		xconvert(*out, x);
		return *this;
	}
	operator bool() const { return out != 0; }
	std::string* out;
};
template 
inline StringBuilder& operator<<(StringBuilder& str, const T& val) { return str ? str._add(val) : str; }

}
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// Enum mappings for clasp types
/////////////////////////////////////////////////////////////////////////////////////////
#define MAP(x, y) static_cast(x), static_cast(y)
#define DEFINE_ENUM_MAPPING(X, ...) \
static int xconvert(const char* x, X& out, const char** errPos, int) {\
	return bk_lib::findEnumVal(x, out, errPos, __VA_ARGS__, MAP(0,0)); \
}\
static std::string& xconvert(std::string& out, X x) { \
	return out.append(bk_lib::enumToString(static_cast(x), __VA_ARGS__, MAP(0,0))); \
}
#define OPTION(k, e, a, d, ...) a
#define CLASP_CONTEXT_OPTIONS
#define CLASP_GLOBAL_OPTIONS
#define CLASP_SOLVE_OPTIONS
#define CLASP_ASP_OPTIONS
#define CLASP_SOLVER_OPTIONS
#define CLASP_SEARCH_OPTIONS
#define ARG_EXT(a, X) X
#define ARG(a)
#define NO_ARG
#include 
namespace Cli {
DEFINE_ENUM_MAPPING(ConfigKey, \
  MAP("auto",   config_default), MAP("frumpy", config_frumpy), MAP("jumpy",  config_jumpy), \
  MAP("tweety", config_tweety) , MAP("handy" , config_handy) ,\
  MAP("crafty", config_crafty) , MAP("trendy", config_trendy), MAP("many", config_many))
}
#undef MAP
#undef DEFINE_ENUM_MAPPING
/////////////////////////////////////////////////////////////////////////////////////////
// Conversion functions for complex clasp types
/////////////////////////////////////////////////////////////////////////////////////////
static int xconvert(const char* x, ScheduleStrategy& out, const char** errPos, int e) {
	using bk_lib::xconvert;
	if (!x) { return 0; }
	const char* next = std::strchr(x, ',');
	uint32      base = 0;
	int         tok  = 1;
	if (errPos) { *errPos = x; }
	if (!next || !xconvert(next+1, base, &next, e) || base == 0)         { return 0; }
	if (strncasecmp(x, "f,", 2) == 0 || strncasecmp(x, "fixed,", 6) == 0){
		out = ScheduleStrategy::fixed(base);
	}
	else if (strncasecmp(x, "l,", 2) == 0 || strncasecmp(x, "luby,", 5) == 0) {
		uint32 lim = 0;
		if (*next == ',' && !xconvert(next+1, lim, &next, e)) { return 0; }
		out = ScheduleStrategy::luby(base, lim);
	}
	else if (strncmp(x, "+,", 2) == 0 || strncasecmp(x, "add,", 4) == 0) {
		std::pair arg(0, 0);
		if (*next != ',' || !xconvert(next+1, arg, &next, e)) { return 0; }
		out = ScheduleStrategy::arith(base, arg.first, arg.second);
	}
	else if (strncmp(x, "x,", 2) == 0 || strncmp(x, "*,", 2) == 0 || strncasecmp(x, "d,", 2) == 0) {
		std::pair arg(0, 0);
		if (*next != ',' || !xconvert(next+1, arg, &next, e)) { return 0; }
		if      (strncasecmp(x, "d", 1) == 0 && arg.first > 0.0) { out = ScheduleStrategy(ScheduleStrategy::User, base, arg.first, arg.second); }
		else if (strncasecmp(x, "d", 1) != 0 && arg.first >= 1.0){ out = ScheduleStrategy::geom(base, arg.first, arg.second); }
		else { return 0; }
	}
	else { next = x; tok = 0; }
	if (errPos) { *errPos = next; }
	return tok;
}
static std::string& xconvert(std::string& out, const ScheduleStrategy& sched) {
	using bk_lib::xconvert;
	if (sched.defaulted()){ return xconvert(out, ScheduleStrategy()); }
	if (sched.disabled()) { return out.append("0"); }
	std::size_t t = out.size();
	out.append("f,");
	xconvert(out, sched.base);
	switch (sched.type) {
		case ScheduleStrategy::Geometric:
			out[t] = 'x';
			return xconvert(out.append(1, ','), std::make_pair((double)sched.grow, sched.len));
		case ScheduleStrategy::Arithmetic:
			if (sched.grow) { out[t] = '+'; return xconvert(out.append(1, ','), std::make_pair((uint32)sched.grow, sched.len)); }
			else            { out[t] = 'f'; return out; }
		case ScheduleStrategy::Luby:
			out[t] = 'l';
			if (sched.len) { return xconvert(out.append(1, ','), sched.len); }
			else           { return out; }
		case ScheduleStrategy::User:
			out[t] = 'd';
			return xconvert(out.append(1, ','), std::make_pair((double)sched.grow, sched.len));
		default: CLASP_FAIL_IF(true, "xconvert(ScheduleStrategy): unknown type");
	}
}
namespace Asp { using Clasp::xconvert; }
namespace mt  { using Clasp::xconvert; }
namespace Cli {
/////////////////////////////////////////////////////////////////////////////////////////
// Option -> Key mapping
/////////////////////////////////////////////////////////////////////////////////////////
/// \cond
// Valid option keys.
enum OptionKey {
	detail__before_options = -1,
	meta_config = 0,
#define CLASP_CONTEXT_OPTIONS  GRP(option_category_nodes_end,   option_category_context_begin),
#define CLASP_GLOBAL_OPTIONS   GRP(option_category_context_end, option_category_global_begin),
#define CLASP_SOLVER_OPTIONS   GRP(option_category_global_end,  option_category_solver_begin),
#define CLASP_SEARCH_OPTIONS   GRP(option_category_solver_end,  option_category_search_begin),
#define CLASP_ASP_OPTIONS      GRP(option_category_search_end,  option_category_asp_begin),
#define CLASP_SOLVE_OPTIONS    GRP(option_category_asp_end,     option_category_solve_begin),
#define OPTION(k,e,...) opt_##k,
#define GROUP_BEGIN(X) X
#define GRP(X, Y) X, Y = X, detail__before_##Y = X - 1
#include 
#undef GRP
	option_category_solve_end,
	detail__num_options = option_category_solve_end,
	meta_tester = detail__num_options
};
static inline bool isOption(int k)       { return k >= option_category_nodes_end && k < detail__num_options; }
static inline bool isGlobalOption(int k) { return k >= option_category_global_begin && k < option_category_global_end; }
static inline bool isTesterOption(int k) { return k >= option_category_nodes_end && k < option_category_search_end && !isGlobalOption(k); }
static inline bool isSolverOption(int k) { return k >= option_category_solver_begin && k < option_category_search_end; }
#if WITH_THREADS
#define MANY_DESC  "        many  : Use default portfolio to configure solver(s)\n"
#define MANY_ARG   "|many"
#else
#define MANY_DESC
#define MANY_ARG   ""
#endif
#define KEY_INIT_DESC(desc) \
desc "      : {auto|frumpy|jumpy|tweety|handy|crafty|trendy" MANY_ARG "|}\n" \
"        auto  : Select configuration based on problem type\n"                          \
"        frumpy: Use conservative defaults\n"                                           \
"        jumpy : Use aggressive defaults\n"                                             \
"        tweety: Use defaults geared towards asp problems\n"                            \
"        handy : Use defaults geared towards large problems\n"                          \
"        crafty: Use defaults geared towards crafted problems\n"                        \
"        trendy: Use defaults geared towards industrial problems\n"                     \
         MANY_DESC                                                                      \
"        : Use configuration file to configure solver(s)"

struct NodeKey {
	const char* name;
	const char* desc;
	int16       skBegin;
	int16       skEnd;
	uint32      numSubkeys() const { return static_cast( skEnd - skBegin ); }
};
enum { key_leaf = 0, key_solver = -1, key_asp = -2, key_solve = -3, key_tester = -4, key_root = -5 };
// nodes_g[-k]: entry for key k
static const NodeKey nodes_g[] = {
/* 0: config */ {"configuration", KEY_INIT_DESC("Initializes this configuration\n"), 0,0},
/* 1: */ {"solver", "Solver Options", option_category_solver_begin, option_category_search_end},
/* 2: */ {"asp"   , "Asp Options"   , option_category_asp_begin, option_category_asp_end},
/* 3: */ {"solve" , "Solve Options" , option_category_solve_begin, option_category_solve_end},
/* 4: */ {"tester", "Tester Options", key_solver, option_category_context_end},
/* 5: */ {""      , "Options"       , key_tester, option_category_global_end}
};
static uint32 makeKeyHandle(int16 kId, uint32 mode, uint32 sId) {
	assert(sId <= 255 && mode <= 255);
	return (mode << 24) | (sId << 16) | static_cast(kId);
}
static int16 decodeKey(uint32 key)   { return static_cast(static_cast(key)); }
static uint8 decodeMode(uint32 key)  { return static_cast( (key >> 24) ); }
static uint8 decodeSolver(uint32 key){ return static_cast( (key >> 16) ); }
static bool  isValidId(int16 id)     { return id >= key_root && id < detail__num_options; }
static bool  isLeafId(int16 id)      { return id >= key_leaf && id < detail__num_options; }
const ClaspCliConfig::KeyType ClaspCliConfig::KEY_INVALID = static_cast(-1);
const ClaspCliConfig::KeyType ClaspCliConfig::KEY_ROOT    = makeKeyHandle(key_root, 0, 0);
const ClaspCliConfig::KeyType ClaspCliConfig::KEY_SOLVER  = makeKeyHandle(key_solver, 0, 0);
const ClaspCliConfig::KeyType ClaspCliConfig::KEY_TESTER  = makeKeyHandle(key_tester, ClaspCliConfig::mode_tester, 0);

struct Name2Id {
	const char* name; int key;
	bool operator<(const Name2Id& rhs) const { return std::strcmp(name, rhs.name) < 0; }
};
static Name2Id options_g[detail__num_options+1] = {
	{"configuration", meta_config},
#define OPTION(k, e, ...) { #k, opt_##k },
#define CLASP_CONTEXT_OPTIONS
#define CLASP_GLOBAL_OPTIONS
#define CLASP_SOLVER_OPTIONS
#define CLASP_SEARCH_OPTIONS
#define CLASP_ASP_OPTIONS
#define CLASP_SOLVE_OPTIONS
#include 
	{"tester"       , meta_tester}
};
struct ClaspCliConfig::OptIndex {
	OptIndex(Name2Id* first, Name2Id* last) {
		std::sort(begin = first, end = last);
	}
	Name2Id* find(const char* name) const {
		Name2Id temp = { name, 0 };
		Name2Id* it  = std::lower_bound(begin, end, temp);
		if (it != end && std::strcmp(it->name, name) == 0) { return it; }
		return 0;
	}
	Name2Id* begin;
	Name2Id* end;
};
ClaspCliConfig::OptIndex ClaspCliConfig::index_g(options_g, options_g + detail__num_options+1);
/// \endcond
/////////////////////////////////////////////////////////////////////////////////////////
// Interface to ProgramOptions
/////////////////////////////////////////////////////////////////////////////////////////
// Converts option key to command-line option name.
static void keyToCliName(std::string& out, const char* n, const char* ext) {
	out.clear();
	for (const char* x; (x = std::strchr(n, '_')) != 0; n = ++x) {
		out.append(n, x-n);
		out.append(1, '-');
	}
	out.append(n).append(ext);
}
// Converts command-line option name to option key.
static void cliNameToKey(std::string& out, const char* n) {
	out.clear();
	for (const char* x; (x = std::strchr(n, '-')) != 0; n = ++x) {
		out.append(n, x-n);
		out.append(1, '_');
	}
	out.append(n);
}
// Type for storing one command-line option.
class ClaspCliConfig::ProgOption : public ProgramOptions::Value {
public:
	ProgOption(ClaspCliConfig& c, int o) : ProgramOptions::Value(0), config_(&c), option_(o) {}
	bool doParse(const std::string& opt, const std::string& value) {
		int ret = isOption(option_) ? config_->setActive(option_, value.c_str()) : config_->setAppOpt(option_, value.c_str());
		if (ret == -1) { throw ProgramOptions::UnknownOption(config_->isGenerator() ? "" : "", opt); }
		return ret > 0;
	}
	int option() const { return option_; }
private:
	ClaspCliConfig* config_;
	int             option_;
};

// Adapter for parsing a command string.
struct ClaspCliConfig::ParseContext : public ProgramOptions::ParseContext {
	typedef ProgramOptions::SharedOptPtr OptPtr;
	ParseContext(ClaspCliConfig& x, const char* c, const ParsedOpts* ex, bool allowMeta, ParsedOpts* o)
		: self(&x), config(c), exclude(ex), out(o), meta(allowMeta) { seen[0] = seen[1] = 0;  }
	OptPtr getOption(const char* name, FindType ft);
	OptPtr getOption(int, const char* key) { throw ProgramOptions::UnknownOption(config, key); }
	void   addValue(const OptPtr& key, const std::string& value);
	uint64            seen[2];
	std::string       temp;
	ClaspCliConfig*   self;
	const char*       config;
	const ParsedOpts* exclude;
	ParsedOpts*       out;
	bool              meta;
};
void ClaspCliConfig::ParseContext::addValue(const OptPtr& key, const std::string& value) {
	using namespace ProgramOptions;
	if (exclude->count(key->name()) == 0) {
		ProgOption* v = static_cast(key->value());
		Value::State s= v->state();
		int        id = v->option();
		uint64&    xs = seen[id/64];
		uint64      m = static_cast(1u) << (id & 63);
		if ((xs & m) != 0 && !v->isComposing()){ throw ValueError(config, ValueError::multiple_occurences, key->name(), value); }
		if (!v->parse(key->name(), value, s))  { throw ValueError(config, ValueError::invalid_value, key->name(), value); }
		if (out) { out->add(key->name()); }
		xs |= m;
	}
}
ProgramOptions::SharedOptPtr ClaspCliConfig::ParseContext::getOption(const char* cmdName, FindType ft) {
	Options::option_iterator end = self->opts_->end(), it = end;
	if (ft == OptionContext::find_alias) {
		char a = cmdName[*cmdName == '-'];
		for (it = self->opts_->begin(); it != end && it->get()->alias() != a; ++it) { ; }
	}
	else {
		Name2Id  key = { cmdName, -2 };
		if (std::strchr(cmdName, '-') != 0) { cliNameToKey(temp, cmdName); key.name = temp.c_str(); }
		Name2Id* pos = std::lower_bound(self->index_g.begin, self->index_g.end, key);
		if (pos != self->index_g.end) {
			std::size_t len = std::strlen(key.name);
			int  cmp        = std::strncmp(key.name, pos->name, len);
			bool found      = cmp == 0 && !*(pos->name+len);
			if (!found && cmp == 0 && (ft & OptionContext::find_prefix) != 0) {
				Name2Id* next = pos + 1;
				cmp           = next != self->index_g.end ? std::strncmp(key.name, next->name, len) : -1;
				found         = cmp != 0;
				if (!found) { throw ProgramOptions::AmbiguousOption(config, cmdName, ""); }
			}
			if (found) { it = self->opts_->begin() + pos->key; }
		}
		assert(it == end || static_cast(it->get()->value())->option() == pos->key);
	}
	if (it != end && (meta || isOption(static_cast(it->get()->value())->option()))) {
		return *it;
	}
	throw ProgramOptions::UnknownOption(config, cmdName);
}
/////////////////////////////////////////////////////////////////////////////////////////
// Default Configs
/////////////////////////////////////////////////////////////////////////////////////////
ConfigIter ClaspCliConfig::getConfig(ConfigKey k) {
	switch(k) {
		#define CONFIG(id, n,c,s,p) case config_##n: return ConfigIter("/[" #n "]\0/\0/" s " " c "\0");
		#define CLASP_CLI_DEFAULT_CONFIGS
		#define CLASP_CLI_AUX_CONFIGS
		#include 
		case config_many:
		#define CONFIG(id,n,c,s,p) "/[solver." #id "]\0/\0/" c " " p "\0"
		#define CLASP_CLI_DEFAULT_CONFIGS
		#define CLASP_CLI_AUX_CONFIGS
			return ConfigIter(
				#include 
				);
		case config_default: return ConfigIter("/default\0/\0/\0");
		default            : throw std::logic_error(ClaspStringBuffer().appendFormat("Invalid config key '%d'", (int)k).c_str());
	}
}
ConfigIter ClaspCliConfig::getConfig(uint8 key, std::string& tempMem) {
	CLASP_FAIL_IF(key > (config_max_value + 1), "Invalid key!");
	if (key < config_max_value) { return getConfig(static_cast(key)); }
	tempMem.clear();
	loadConfig(tempMem, config_[key - config_max_value].c_str());
	return ConfigIter(tempMem.data());
}
static inline const char* skipWs(const char* x) {
	while (*x == ' ' || *x == '\t') { ++x; }
	return x;
}
static inline const char* getIdent(const char* x, std::string& to) {
	for (x = skipWs(x); std::strchr(" \t:()[]", *x) == 0; ++x) { to += *x; }
	return x;
}
static inline bool matchSep(const char*& x, char c) {
	if (*(x = skipWs(x)) == c) { ++x; return true; }
	return false;
}

bool ClaspCliConfig::appendConfig(std::string& to, const std::string& line) {
	std::size_t sz = to.size();
	const char*  x = skipWs(line.c_str());
	const bool   p = matchSep(x, '[');
	to.append("/[", 2);
	// match name in optional square brackets
	bool ok = matchSep(x = getIdent(x, to), ']') == p;
	to.append("]\0/", 3);
	// match optional base in parentheses followed by start of option list
	if (ok && (!matchSep(x, '(') || matchSep((x = getIdent(x, to)), ')')) && matchSep(x, ':')) {
		to.append("\0/", 2);
		to.append(skipWs(x));
		to.erase(to.find_last_not_of(" \t") + 1);
		to.append(1, '\0');
		return true;
	}
	to.resize(sz);
	return false;
}
bool ClaspCliConfig::loadConfig(std::string& to, const char* name) {
	std::ifstream file(name);
	CLASP_FAIL_IF(!file, "Could not open config file '%s'", name);
	uint32 lineNum= 0;
	for (std::string line, cont; std::getline(file, line); ) {
		++lineNum;
		line.erase(0, line.find_first_not_of(" \t"));
		if (line.empty() || line[0] == '#') { continue; }
		if (*line.rbegin() == '\\')         { *line.rbegin() = ' '; cont += line; continue; }
		if (!cont.empty()) { cont += line; cont.swap(line); cont.clear(); }
		CLASP_FAIL_IF(!appendConfig(to, line),  "'%s@%u': Invalid configuration", name, lineNum);
	}
	to.append(1, '\0');
	return true;
}
const char* ClaspCliConfig::getDefaults(ProblemType t) {
	if (t == Problem_t::Asp){ return "--configuration=tweety"; }
	else                    { return "--configuration=trendy"; }
}
ConfigIter::ConfigIter(const char* x) : base_(x) {}
const char* ConfigIter::name() const { return base_ + 1; }
const char* ConfigIter::base() const { return base_ + std::strlen(base_) + 2; }
const char* ConfigIter::args() const { const char* x = base(); return x + std::strlen(x) + 2; }
bool        ConfigIter::valid()const { return *base_ != 0; }
bool        ConfigIter::next()       {
	base_ = args();
	base_+= std::strlen(base_) + 1;
	return valid();
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspCliConfig
/////////////////////////////////////////////////////////////////////////////////////////
ClaspCliConfig::ScopedSet::ScopedSet(ClaspCliConfig& s, uint8 mode, uint32 sId) : self(&s) {
	if (sId) { mode |= mode_solver; }
	s.cliId   = static_cast(sId);
	s.cliMode = mode;
}
ClaspCliConfig::ScopedSet::~ScopedSet() { self->cliId = self->cliMode = 0; }
ClaspCliConfig::RawConfig::RawConfig(const char* name) {
	raw.append(1, '/').append(name ? name : "").append("\0/\0/", 4);
}
void ClaspCliConfig::RawConfig::addArg(const char* arg) {
	*raw.rbegin() = ' ';
	raw.append(arg ? arg : "").append(1, '\0');
}
void ClaspCliConfig::RawConfig::addArg(const std::string& arg) { addArg(arg.c_str()); }
ClaspCliConfig::ClaspCliConfig()  {
	initTester_ = true;
	static_assert(
		(option_category_context_begin< option_category_solver_begin) &&
		(option_category_solver_begin < option_category_search_begin) &&
		(option_category_search_begin < option_category_asp_begin)    &&
		(option_category_asp_begin    < option_category_solve_begin)  &&
		(option_category_solve_begin  < option_category_solve_end), "unexpected option order");
}
ClaspCliConfig::~ClaspCliConfig() {}
void ClaspCliConfig::reset() {
	config_[0] = config_[1] = "";
	initTester_ = true;
	ClaspConfig::reset();
}

void ClaspCliConfig::prepare(SharedContext& ctx) {
	if (testerConfig()) {
		// Force init
		ClaspCliConfig::config("tester");
	}
	ClaspConfig::prepare(ctx);
}
Configuration* ClaspCliConfig::config(const char* n) {
	if (n && std::strcmp(n, "tester") == 0) {
		if (!testerConfig() || (!testerConfig()->hasConfig && initTester_)) {
			setAppOpt(meta_tester, "--config=auto");
			initTester_ = false;
		}
		return testerConfig();
	}
	return ClaspConfig::config(n);
}

ClaspCliConfig::ProgOption* ClaspCliConfig::createOption(int o) {  return new ProgOption(*this, o); }

void ClaspCliConfig::createOptions() {
	if (opts_.get()) { return; }
	opts_ = new Options();
	using namespace ProgramOptions;
	opts_->addOptions()("configuration", createOption(meta_config)->defaultsTo("auto")->state(Value::value_defaulted), KEY_INIT_DESC("Configure default configuration [%D]\n"));
	std::string cmdName;
#define CLASP_CONTEXT_OPTIONS
#define CLASP_GLOBAL_OPTIONS
#define CLASP_SOLVE_OPTIONS
#define CLASP_ASP_OPTIONS
#define CLASP_SOLVER_OPTIONS
#define CLASP_SEARCH_OPTIONS
#define OPTION(k, e, a, d, ...) keyToCliName(cmdName, #k, e); opts_->addOptions()(cmdName.c_str(),static_cast( createOption(opt_##k)a ), d);
#define ARG(a) ->a
#define ARG_EXT(a, X) ARG(a)
#define NO_ARG
#include 
	opts_->addOptions()("tester", createOption(meta_tester)->arg(""), "Pass (quoted) string of %A to tester");
}
void ClaspCliConfig::addOptions(OptionContext& root) {
	createOptions();
	using namespace ProgramOptions;
	OptionGroup configOpts("Clasp.Config Options");
	OptionGroup solving("Clasp.Solving Options");
	OptionGroup asp("Clasp.ASP Options");
	OptionGroup search("Clasp.Search Options", ProgramOptions::desc_level_e1);
	OptionGroup lookback("Clasp.Lookback Options", ProgramOptions::desc_level_e1);
	configOpts.addOption(*opts_->begin());
	configOpts.addOption(*(opts_->end()-1));
	for (Options::option_iterator it = opts_->begin() + 1, end = opts_->end() - 1; it != end; ++it) {
		int oId = static_cast(it->get()->value())->option();
		if      (oId < option_category_global_end)  { configOpts.addOption(*it); }
		else if (oId < opt_no_lookback)             { search.addOption(*it); }
		else if (oId < option_category_solver_end)  { lookback.addOption(*it); }
		else if (oId < opt_restarts)                { search.addOption(*it); }
		else if (oId < option_category_search_end)  { lookback.addOption(*it); }
		else if (oId < option_category_asp_end)     { asp.addOption(*it); }
		else                                        { solving.addOption(*it); }
	}
	root.add(configOpts).add(solving).add(asp).add(search).add(lookback);
	root.addAlias("number", root.find("models")); // remove on next version
}
bool ClaspCliConfig::assignDefaults(const ProgramOptions::ParsedOptions& exclude) {
	for (Options::option_iterator it = opts_->begin(), end = opts_->end(); it != end; ++it) {
		const ProgramOptions::Option& o = **it;
		CLASP_FAIL_IF(exclude.count(o.name()) == 0 && !o.assignDefault(), "Option '%s': invalid default value '%s'\n", o.name().c_str(), o.value()->defaultsTo());
	}
	return true;
}
void ClaspCliConfig::releaseOptions() {
	opts_ = 0;
}
bool ClaspCliConfig::match(const char*& path, const char* what) const {
	std::size_t wLen = std::strlen(what);
	if (strncmp(path, what, wLen) != 0 || (path[wLen] && path[wLen++] != '.')) {
		return false;
	}
	path += wLen;
	return true;
}
ClaspCliConfig::KeyType ClaspCliConfig::getKey(KeyType k, const char* path) const {
	int16 id = decodeKey(k);
	if (!isValidId(id) || !path || !*path || (*path == '.' && !*++path)) {
		return k;
	}
	if (isLeafId(id)){ return KEY_INVALID; }
	const NodeKey& x = nodes_g[-id];
	for (int16 sk = x.skBegin; sk != x.skEnd && sk < 0; ++sk) {
		NodeKey sub = nodes_g[-sk];
		if (match(path, sub.name)) {
			KeyType ret = makeKeyHandle(sk, (sk == key_tester ? mode_tester : 0) | decodeMode(k), 0);
			if (!*path) { return ret; }
			return getKey(ret, path);
		}
	}
	uint8 mode = decodeMode(k);
	if (id == key_solver) {
		uint32 solverId;
		if ((mode & mode_solver) == 0 && *path != '.' && bk_lib::xconvert(path, solverId, &path, 0) == 1) {
			return getKey(makeKeyHandle(id, mode | mode_solver, std::min(solverId, (uint32)uint8(-1))), path);
		}
		mode |= mode_solver;
	}
	const Name2Id* opt = index_g.find(path);
	// remaining name must be a valid option in our subkey range
	if (!opt || opt->key < x.skBegin || opt->key >= x.skEnd) {
		return KEY_INVALID;
	}
	return makeKeyHandle(static_cast(opt->key), mode, decodeSolver(k));
}

ClaspCliConfig::KeyType ClaspCliConfig::getArrKey(KeyType k, unsigned i) const {
	int16 id = decodeKey(k);
	if (id != key_solver || (decodeMode(k) & mode_solver) != 0 || i >= solve.supportedSolvers()) { return KEY_INVALID; }
	return makeKeyHandle(id, decodeMode(k) | mode_solver, i);
}
int ClaspCliConfig::getKeyInfo(KeyType k, int* nSubkeys, int* arrLen, const char** help, int* nValues) const {
	int16 id = decodeKey(k);
	int ret  = 0;
	if (!isValidId(id)){ return -1; }
	if (isLeafId(id)){
		if (nSubkeys && ++ret) { *nSubkeys = 0;  }
		if (arrLen && ++ret)   { *arrLen   = -1; }
		if (nValues && ++ret)  { *nValues  = static_cast( (decodeMode(k) & mode_tester) == 0 || testerConfig() != 0 ); }
		if (help && ++ret)     { getActive(id, 0, help, 0); }
		return ret;
	}
	const NodeKey& x = nodes_g[-id];
	if (nSubkeys && ++ret) { *nSubkeys = x.numSubkeys(); }
	if (nValues && ++ret)  { *nValues = -1; }
	if (help && ++ret)     { *help = x.desc; }
	if (arrLen && ++ret)   {
		*arrLen = -1;
		if (id == key_solver && (decodeMode(k) & mode_solver) == 0) {
			const UserConfig* c = (decodeMode(k) & mode_tester) == 0 ? this : testerConfig();
			*arrLen = c ? (int)c->numSolver() : 0;
		}
	}
	return ret;
}
bool ClaspCliConfig::isLeafKey(KeyType k) { return isLeafId(decodeKey(k)); }
const char* ClaspCliConfig::getSubkey(KeyType k, uint32 i) const {
	int16 id = decodeKey(k);
	if (!isValidId(id) || isLeafId(id)) { return 0; }
	const NodeKey& nk = nodes_g[-id];
	if (i >= nk.numSubkeys()) { return 0; }
	int sk = nk.skBegin + static_cast(i);
	if (sk < key_leaf) { return nodes_g[-sk].name; }
	const char* opt = 0;
	getActive(sk, 0, 0, &opt);
	return opt;
}
int ClaspCliConfig::getValue(KeyType key, std::string& out) const {
	int16 id = decodeKey(key);
	if (!isLeafId(id)) { return -1; }
	try {
		int ret = ScopedSet(const_cast(*this), decodeMode(key), decodeSolver(key))->getActive(id, &out, 0, 0);
		return ret > 0 ? static_cast(out.length()) : ret;
	}
	catch (...) { return -2; }
}
int ClaspCliConfig::getValue(KeyType key, char* buffer, std::size_t bufSize) const {
	std::string temp;
	int ret = getValue(key, temp);
	if (ret <= 0) { return ret; }
	if (buffer && bufSize) {
		std::size_t n = temp.length() >= bufSize ? bufSize - 1 : temp.length();
		std::memcpy(buffer, temp.c_str(), n * sizeof(char));
		buffer[n] = 0;
	}
	return static_cast(temp.length());
}
std::string ClaspCliConfig::getValue(const char* path) const {
	std::string temp;
	CLASP_FAIL_IF(getValue(getKey(KEY_ROOT, path), temp) <= 0, "Invalid key: '%s'", path);
	return temp;
}
bool ClaspCliConfig::hasValue(const char* path) const {
	int nVals;
	return getKeyInfo(getKey(KEY_ROOT, path), 0, 0, 0, &nVals) == 1 && nVals > 0;
}

int ClaspCliConfig::setValue(KeyType key, const char* value) {
	int16 id = decodeKey(key);
	if (!isLeafId(id)) { return -1; }
	if ((decodeMode(key) & mode_tester) != 0) {
		addTesterConfig();
		initTester_ = false;
	}
	ScopedSet scope(*this, decodeMode(key), decodeSolver(key));
	try         { return setActive(id, value); }
	catch (...) { return -2; }
}

bool ClaspCliConfig::setValue(const char* path, const char* value) {
	int ret = setValue(getKey(KEY_ROOT, path), value);
	CLASP_FAIL_IF(ret < 0, (ret == -1 ? "Invalid or incomplete key: '%s'" : "Value error in key: '%s'"), path);
	return ret != 0;
}

int ClaspCliConfig::applyActive(int o, const char* _val_, std::string* _val_out_, const char** _desc_out_, const char** _name_out_) {
	UserConfig*    active = this->active();
	uint32         sId    = cliId;
	SolverOpts*    solver = 0;
	SearchOpts*    search = 0;
	ContextParams* ctxOpts= active;
	if (_name_out_) { *_name_out_ = 0; }
	if (_val_ || _val_out_) {
		if (!active || (active == testerConfig() && !isTesterOption(o)) || ((cliMode & mode_solver) != 0 && !isSolverOption(o))) {
			o = (cliMode & mode_relaxed) != 0 ? detail__before_options : detail__num_options;
		}
		else if (isSolverOption(o)) {
			solver = &active->addSolver(sId);
			search = &active->addSearch(sId);
		}
	}
	if (!isOption(o)) {
		return o == detail__before_options ? int(_val_ != 0) : -1;
	}
	// action & helper macros used in get/set
	using bk_lib::xconvert; using bk_lib::off; using bk_lib::opt;
	using bk_lib::stringTo; using bk_lib::toString;
	#define ITE(c, a, b)            (!!(c) ? (a) : (b))
	#define FUN(x)                  for (bk_lib::ArgString x = _val_;;)
	#define STORE(obj)              { return stringTo((_val_), obj); }
	#define STORE_LEQ(x, y)         { unsigned __n; return stringTo(_val_, __n) && SET_LEQ(x, __n, y); }
	#define STORE_FLAG(x)           { bool __b; return stringTo(_val_, __b) && SET(x, static_cast(__b)); }
	#define STORE_OR_FILL(x)        { unsigned __n; return stringTo(_val_, __n) && SET_OR_FILL(x, __n); }
	#define GET_FUN(x)              bk_lib::StringBuilder x(*_val_out_); if (!x);else
	#define GET(...)                *_val_out_ = toString( __VA_ARGS__ )
	#define GET_IF(c, ...)          *_val_out_ = ITE((c), toString(__VA_ARGS__), toString(off))
	switch(static_cast(o)) {
		default: return -1;
		#define OPTION(k, e, a, d, x, v) \
		case opt_##k:\
			if (_name_out_){ *_name_out_ = #k ; }\
			if (_val_) try { x ; }catch(...) {return 0;}\
			if (_val_out_) { v ; }\
			if (_desc_out_){ *_desc_out_ = d; }\
			return 1;
		#define CLASP_CONTEXT_OPTIONS (*ctxOpts)
		#define CLASP_GLOBAL_OPTIONS (*this)
		#define CLASP_ASP_OPTIONS asp
		#define CLASP_SOLVE_OPTIONS solve
		#define CLASP_SOLVER_OPTIONS (*solver)
		#define CLASP_SEARCH_OPTIONS (*search)
		#define CLASP_SEARCH_RESTART_OPTIONS search->restart
		#define CLASP_SEARCH_REDUCE_OPTIONS search->reduce
		#include 
	}
	#undef FUN
	#undef STORE
	#undef STORE_LEQ
	#undef STORE_FLAG
	#undef STORE_OR_FILL
	#undef GET_IF
	#undef GET
	#undef ITE
}

int ClaspCliConfig::setActive(int id, const char* setVal) {
	if      (isOption(id))     { return applyActive(id, setVal ? setVal : "", 0, 0, 0); }
	else if (id == meta_config){
		int sz = setAppOpt(id, setVal);
		if (sz <= 0) { return 0; }
		std::string m;
		UserConfig* act = active();
		ConfigIter it  = getConfig(act->cliConfig, m);
		act->hasConfig = 0;
		cliMode       |= mode_relaxed;
		act->resize(1, 1);
		for (uint32 sId = 0; it.valid(); it.next()) {
			act->addSolver(sId);
			act->addSearch(sId);
			cliId = static_cast(sId);
			if (!setConfig(it, false, ParsedOpts(), 0)){ return 0; }
			if (++sId == static_cast(sz))      { break; }
			cliMode |= mode_solver;
		}
		if (sz < 65 && static_cast(sz) > act->numSolver()) {
			for (uint32 sId = act->numSolver(), mod = sId, end = static_cast(sz); sId != end; ++sId) {
				SolverParams& solver = act->addSolver(sId);
				SolveParams&  search = act->addSearch(sId);
				(solver = act->solver(sId % mod)).setId(sId);
				search = act->search(sId % mod);
			}
		}
		return static_cast((act->hasConfig = 1) == 1);
	}
	else { return -1; }
}

int ClaspCliConfig::getActive(int o, std::string* val, const char** desc, const char** opt) const {
	if      (isOption(o))     { return const_cast(*this).applyActive(o, 0, val, desc, opt); }
	else if (!active())       { return -1; }
	else if (o == meta_config){
		const NodeKey& n = nodes_g[-o];
		if (val)  {
			uint8 k = (ConfigKey)active()->cliConfig;
			if (k < config_max_value) { xconvert(*val, static_cast(k)); }
			else                      { val->append(config_[!isGenerator()]); }
		}
		if (desc) { *desc = n.desc; }
		if (opt)  { *opt  = n.name; }
		return 1;
	}
	else { return -1; }
}
int ClaspCliConfig::setAppOpt(int o, const char* _val_) {
	if (o == meta_config) {
		std::pair defC(config_default, INT_MAX);
		if   (bk_lib::stringTo(_val_, defC)){ active()->cliConfig = (uint8)defC.first; }
		else {
			CLASP_FAIL_IF(!std::ifstream(_val_).is_open(), "Could not open config file '%s'", _val_);
			config_[!isGenerator()] = _val_; active()->cliConfig = config_max_value + !isGenerator();
		}
		return Range(0, INT_MAX).clamp(defC.second);
	}
	else if (o == meta_tester && isGenerator()) {
		addTesterConfig();
		initTester_ = false;
		RawConfig config("");
		config.addArg(_val_);
		ParsedOpts ex;
		bool ret = ScopedSet(*this, mode_tester)->setConfig(config.iterator(), true, ParsedOpts(), &ex);
		return ret && finalizeAppConfig(testerConfig(), finalizeParsed(testerConfig(), ex, ex), Problem_t::Asp, true);
	}
	return -1; // invalid option
}
bool ClaspCliConfig::setAppDefaults(UserConfig* active, uint32 sId, const ParsedOpts& cmdLine, ProblemType t) {
	ScopedSet temp(*this, (active == this ? 0 : mode_tester) | mode_relaxed, sId);
	if (sId == 0 && t != Problem_t::Asp && cmdLine.count("sat-prepro") == 0) {
		setActive(opt_sat_prepro, "2,20,25,120");
	}
	if (active->addSolver(sId).search == SolverParams::no_learning) {
		if (cmdLine.count("heuristic") == 0) { setActive(opt_heuristic, "unit"); }
		if (cmdLine.count("lookahead") == 0) { setActive(opt_lookahead, "atom"); }
		if (cmdLine.count("deletion")  == 0) { setActive(opt_deletion, "no"); }
		if (cmdLine.count("restarts")  == 0) { setActive(opt_restarts, "no"); }
	}
	return true;
}

bool ClaspCliConfig::setConfig(const ConfigIter& config, bool allowMeta, const ParsedOpts& exclude, ParsedOpts* out) {
	createOptions();
	ParseContext ctx(*this, config.name(), &exclude, allowMeta, out);
	ProgramOptions::parseCommandString(config.args(), ctx, ProgramOptions::command_line_allow_flag_value);
	return true;
}

bool ClaspCliConfig::validate() {
	UserConfiguration* arr[3] = { this, testerConfig(), 0 };
	UserConfiguration** c     = arr;
	char ctx[80];
	do {
		for (uint32 i = 0; i != (*c)->numSolver(); ++i) {
			Clasp::Cli::validate(clasp_format(ctx, 80, "<%s>.%u", *c == this ? "":"", i), (*c)->solver(i), (*c)->search(i));
		}
	} while (*++c);
	return true;
}

bool ClaspCliConfig::finalize(const ParsedOpts& x, ProblemType t, bool defs) {
	ParsedOpts temp;
	return finalizeAppConfig(this, finalizeParsed(this, x, temp), t, defs);
}

void ClaspCliConfig::addDisabled(ParsedOpts& parsed) {
	finalizeParsed(this, parsed, parsed);
}

const ClaspCliConfig::ParsedOpts& ClaspCliConfig::finalizeParsed(UserConfig* active, const ParsedOpts& parsed, ParsedOpts& exclude) const {
	bool copied = &parsed == &exclude;
	if (active->search(0).reduce.fReduce() == 0 && parsed.count("deletion") != 0) {
		if (!copied) { exclude = parsed; copied = true; }
		exclude.add("del-cfl");
		exclude.add("del-max");
		exclude.add("del-grow");
	}
	return !copied ? parsed : exclude;
}

bool ClaspCliConfig::finalizeAppConfig(UserConfig* active, const ParsedOpts& parsed, ProblemType t, bool defs) {
	if (defs && !setAppDefaults(active, 0, parsed, t)) { return false; }
	SolverParams defSolver = active->solver(0);
	SolveParams  defSearch = active->search(0);
	if (active->hasConfig) { return true; }
	uint8 c = active->cliConfig;
	if (c == config_many && solve.numSolver() == 1) { c = config_default; }
	if (c == config_default) {
		if      (defSolver.search == SolverParams::no_learning)       { c = config_nolearn; }
		else if (active == testerConfig())                            { c = config_tester_default; }
		else if (solve.numSolver() == 1 || !solve.defaultPortfolio()) { c = t == Problem_t::Asp ? (uint8)config_asp_default : (uint8)config_sat_default; }
		else                                                          { c = config_many; }
	}
	std::string m;
	ConfigIter conf = getConfig(c, m);
	uint8  mode     = (active == testerConfig() ? mode_tester : 0) | mode_relaxed;
	uint32 portSize = 0;
	const char* ctx = active == testerConfig() ? "" : "";
	char   buf[80];
	for (uint32 i = 0; i != solve.numSolver() && conf.valid(); ++i) {
		SolverParams& solver = (active->addSolver(i) = defSolver).setId(i);
		SolveParams&  search = (active->addSearch(i) = defSearch);
		ConfigKey     baseK  = config_default;
		CLASP_FAIL_IF(*conf.base() && !bk_lib::stringTo(conf.base(), baseK), "%s.%s: '%s': Invalid base config!", ctx, conf.name(), conf.base());
		if (baseK != config_default && !ScopedSet(*this, mode|mode_solver, i)->setConfig(getConfig(baseK), false, parsed, 0)) {
			return false;
		}
		if (!ScopedSet(*this, mode, i)->setConfig(conf, false, parsed, 0)) {
			return false;
		}
		Clasp::Cli::validate(clasp_format(buf, 80, "%s.%s", ctx, conf.name()), solver, search);
		++portSize;
		conf.next();
		mode |= mode_solver;
	}
	active->hasConfig = 1;
	return true;
}

bool ClaspCliConfig::setAppConfig(const RawConfig& config, ProblemType t) {
	ProgramOptions::ParsedOptions exclude;
	reset();
	return setConfig(config.iterator(), true, exclude, &exclude) && assignDefaults(exclude) && finalize(exclude, t, true);
}

void validate(const char* ctx, const SolverParams& solver, const SolveParams& search) {
	if (!ctx) { ctx = ""; }
	const ReduceParams& reduce = search.reduce;
	if (solver.search == SolverParams::no_learning) {
		CLASP_FAIL_IF(Heuristic_t::isLookback(solver.heuId), "'%s': Heuristic requires lookback strategy!", ctx);
		CLASP_FAIL_IF(!search.restart.sched.disabled() && !search.restart.sched.defaulted(), "'%s': 'no-lookback': restart options disabled!", ctx);
		CLASP_FAIL_IF(!reduce.cflSched.disabled() || (!reduce.growSched.disabled() && !reduce.growSched.defaulted()) || search.reduce.fReduce() != 0, "'%s': 'no-lookback': deletion options disabled!", ctx);
	}
	bool  hasSched = !reduce.cflSched.disabled() || !reduce.growSched.disabled() || reduce.maxRange != UINT32_MAX;
	CLASP_FAIL_IF(hasSched  && reduce.fReduce() == 0.0f && !reduce.growSched.defaulted(), "'%s': 'no-deletion': deletion strategies disabled!", ctx);
	CLASP_FAIL_IF(!hasSched && reduce.fReduce() != 0.0f && !reduce.growSched.defaulted(), "'%s': 'deletion': deletion strategy required!", ctx);
}
}}
clasp-3.2.2/libclasp/src/clasp_output.cpp000066400000000000000000001214231304134206100204230ustar00rootroot00000000000000//
// Copyright (c) 2009-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#if !defined(_WIN32)
#include 
#elif !defined(SIGALRM)
#define SIGALRM 14
#endif
#ifdef _MSC_VER
#include 
#define CLASP_ISNAN(x) (_isnan(x) != 0)
#pragma warning (disable : 4996)
#elif defined(__cplusplus) && __cplusplus >= 201103L
#include 
#define CLASP_ISNAN(x) std::isnan(x)
#else
#include 
#define CLASP_ISNAN(x) isnan(x)
#endif
inline bool isNan(double d) { return CLASP_ISNAN(d); }
#undef CLASP_ISNAN
namespace Clasp { namespace Cli {
/////////////////////////////////////////////////////////////////////////////////////////
// Event formatting
/////////////////////////////////////////////////////////////////////////////////////////
static void null_term_copy(const char* in, int inSize, char* buf, uint32 bufSize) {
	if (!in || !buf || !bufSize) return;
	uint32 n = inSize < 0 ? static_cast(0) : std::min(bufSize-1, static_cast(inSize));
	std::memcpy(buf, in, n);
	buf[n] = 0;
}
void format(const Clasp::BasicSolveEvent& ev, char* out, uint32 outSize) {
	char buf[1024]; int n;
	const Solver& s = *ev.solver;
	n = sprintf(buf, "%2u:%c|%7u/%-7u|%8u/%-8u|%10" PRIu64"/%-6.3f|%8" PRId64"/%-10" PRId64"|"
		, s.id()
		, static_cast(ev.op)
		, s.numFreeVars()
		, (s.decisionLevel() > 0 ? s.levelStart(1) : s.numAssignedVars())
		, s.numConstraints()
		, s.numLearntConstraints()
		, s.stats.conflicts
		, s.stats.conflicts/std::max(1.0,double(s.stats.choices))
		, ev.cLimit <= (UINT32_MAX) ? (int64)ev.cLimit:-1
		, ev.lLimit != (UINT32_MAX) ? (int64)ev.lLimit:-1
	);
	null_term_copy(buf, n, out, outSize);
}
void format(const Clasp::SolveTestEvent&  ev, char* out, uint32 outSize) {
	char buf[1024]; int n;
	char ct = ev.partial ? 'P' : 'F';
	if (ev.result == -1) { n = sprintf(buf, "%2u:%c| HC: %-5u %-60s|", ev.solver->id(), ct, ev.hcc, "..."); }
	else                 {
		n = sprintf(buf, "%2u:%c| HC: %-5u %-4s|%8u/%-8u|%10" PRIu64"/%-6.3f| T: %-15.3f|", ev.solver->id(), ct, ev.hcc, (ev.result == 1 ? "OK" : "FAIL")
		  , ev.solver->numConstraints()
		  , ev.solver->numLearntConstraints()
		  , ev.conflicts()
		  , ev.conflicts()/std::max(1.0,double(ev.choices()))
		  , ev.time
		);
	}
	null_term_copy(buf, n, out, outSize);
}
#if WITH_THREADS
void format(const Clasp::mt::MessageEvent& ev, char* out, uint32 outSize) {
	typedef Clasp::mt::MessageEvent EV;
	char buf[1024]; int n;
	if (ev.op != EV::completed) { n = sprintf(buf, "%2u:X| %-15s %-53s |", ev.solver->id(), ev.msg, ev.op == EV::sent ? "sent" : "received"); }
	else                        { n = sprintf(buf, "%2u:X| %-15s %-35s in %13.3fs |", ev.solver->id(), ev.msg, "completed", ev.time); }
	null_term_copy(buf, n, out, outSize);
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////
// Output
/////////////////////////////////////////////////////////////////////////////////////////
Output::Output(uint32 verb) : summary_(0), verbose_(0) {
	std::memset(quiet_, 0, sizeof(quiet_));
	setCallQuiet(print_no);
	setVerbosity(verb);
	clearModel();
}
Output::~Output() {}
void Output::setVerbosity(uint32 verb) {
	Event::Verbosity x = (Event::Verbosity)std::min(verbose_ = verb, (uint32)Event::verbosity_max);
	EventHandler::setVerbosity(Event::subsystem_facade , x);
	EventHandler::setVerbosity(Event::subsystem_load   , x);
	EventHandler::setVerbosity(Event::subsystem_prepare, x);
	EventHandler::setVerbosity(Event::subsystem_solve  , x);
}
void Output::setModelQuiet(PrintLevel model){ quiet_[0] = static_cast(model); }
void Output::setOptQuiet(PrintLevel opt)    { quiet_[1] = static_cast(opt);   }
void Output::setCallQuiet(PrintLevel call)  { quiet_[2] = static_cast(call);  }

void Output::saveModel(const Model& m) {
	saved_ = m;
	const SumVec*  costs = m.costs ? &(costs_ = *m.costs) : 0;
	const ValueVec* vals = &(vals_ = *m.values);
	saved_.values = vals;
	saved_.costs  = costs;
}

void Output::onEvent(const Event& ev) {
	typedef ClaspFacade::StepStart StepStart;
	typedef ClaspFacade::StepReady StepReady;
	if (const StepStart* start = event_cast(ev)) {
		startStep(*start->facade);
	}
	else if (const StepReady* ready = event_cast(ev)) {
		stopStep(*ready->summary);
	}
}
bool Output::onModel(const Solver& s, const Model& m) {
	if (modelQ() == print_all || optQ() == print_all) {
		printModel(s.outputTable(), m, print_all);
	}
	if (modelQ() == print_best || optQ() == print_best) {
		if (m.opt == 1 && !m.consequences()) { printModel(s.outputTable(), m, print_best); clearModel(); }
		else                                 { saveModel(m); }
	}
	return true;
}
bool Output::onUnsat(const Solver& s, const Model& m) {
	if (m.ctx) {
		const LowerBound* lower = m.ctx->optimize() && s.lower.bound > 0 ? &s.lower : 0;
		const Model*  prevModel = m.num ? &m : 0;
		if (modelQ() == print_all || optQ() == print_all) {
			printUnsat(s.outputTable(), lower, prevModel);
		}
	}
	return true;
}
void Output::startStep(const ClaspFacade&) { clearModel(); summary_ = 0; }
void Output::stopStep(const ClaspFacade::Summary& s){
	if (getModel()) {
		if (s.model()){
			saved_.opt = s.model()->opt;
			saved_.def = s.model()->def;
		}
		printModel(s.ctx().output, *getModel(), print_best);
		clearModel();
	}
	else if (modelQ() == print_all && s.model() && s.model()->up && !s.model()->def) {
		printModel(s.ctx().output, *s.model(), print_all);
	}
	if (callQ() == print_all) {
		printSummary(s, false);
		if (stats(s)) { printStatistics(s, false); }
	}
	else if (callQ() == print_best) {
		summary_ = &s;
	}
}
void Output::shutdown(const ClaspFacade::Summary& summary) {
	if (summary_) {
		printSummary(*summary_, false);
		if (stats(summary)) { printStatistics(*summary_, false); }
	}
	printSummary(summary, true);
	if (stats(summary)) { printStatistics(summary, true); }
	shutdown();
}
// Returns the number of consequences and estimates in m.
// For a model m with m.consequences and a return value ret:
//   - ret.first  is the number of definite consequences
//   - ret.second is the number of remaining possible consequences
Output::UPair Output::numCons(const OutputTable& out, const Model& m) const {
	uint32 low = 0, up = 0;
	if (out.projectMode() == OutputTable::project_output) {
		low += out.numFacts();
		for (OutputTable::pred_iterator it = out.pred_begin(); it != out.pred_end(); ++it) {
			low += m.isDef(it->cond);
			up  += m.isEst(it->cond);
		}
		for (OutputTable::range_iterator it = out.vars_begin(), end = out.vars_end(); it != end; ++it) {
			Literal p = posLit(*it);
			low += m.isDef(p);
			up  += m.isEst(p);
		}
	}
	else {
		for (OutputTable::lit_iterator it = out.proj_begin(), end = out.proj_end(); it != end; ++it) {
			low += m.isDef(*it);
			up  += m.isEst(*it);
		}
	}
	return UPair(low, m.def ? 0 : up);
}

// Prints shown symbols in model.
// The functions prints
// - true literals in definite answer, followed by
// - true literals in current estimate if m.consequences()
void Output::printWitness(const OutputTable& out, const Model& m, uintp data) {
	for (OutputTable::fact_iterator it = out.fact_begin(); it != out.fact_end(); ++it) {
		data = doPrint(OutPair(*it, lit_true()), data);
	}
	for (const char* x = out.theory ? out.theory->first(m) : 0; x; x = out.theory->next()) {
		data = doPrint(OutPair(x, lit_true()), data);
	}
	const bool onlyD = m.type != Model::Cautious || m.def;
	for (bool D = true;; D = !D) {
		for (OutputTable::pred_iterator it = out.pred_begin(); it != out.pred_end(); ++it) {
			if (m.isTrue(it->cond) && (onlyD || m.isDef(it->cond) == D)) {
				data = doPrint(OutPair(it->name, lit_true()), data);
			}
		}
		if (out.vars_begin() != out.vars_end()) {
			const bool showNeg = !m.consequences();
			if (out.projectMode() == OutputTable::project_output || !out.filter("_")) {
				for (OutputTable::range_iterator it = out.vars_begin(), end = out.vars_end(); it != end; ++it) {
					Literal p = posLit(*it);
					if ((showNeg || m.isTrue(p)) && (onlyD || m.isDef(p) == D)) {
						data = doPrint(OutPair(static_cast(0), m.isTrue(p) ? p : ~p), data);
					}
				}
			}
			else {
				for (OutputTable::lit_iterator it = out.proj_begin(), end = out.proj_end(); it != end; ++it) {
					if ((showNeg || m.isTrue(*it)) && (onlyD || m.isDef(*it) == D)) {
						data = doPrint(OutPair(static_cast(0), m.isTrue(*it) ? *it : ~*it), data);
					}
				}
			}
		}
		if (D == onlyD) { return; }
	}
}
void Output::printUnsat(const OutputTable&, const LowerBound*, const Model*) {}
uintp Output::doPrint(const OutPair&, UPtr x) { return x; }
bool Output::stats(const ClaspFacade::Summary& summary) const {
	return summary.facade->config()->context().stats != 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// JsonOutput
/////////////////////////////////////////////////////////////////////////////////////////
JsonOutput::JsonOutput(uint32 v) : Output(std::min(v, uint32(1))), open_("") {
	objStack_.reserve(10);
}
JsonOutput::~JsonOutput() { JsonOutput::shutdown(); }
void JsonOutput::run(const char* solver, const char* version, const std::string* iBeg, const std::string* iEnd) {
	if (indent() == 0) {
		open_ = "";
		JsonOutput::pushObject();
	}
	printKeyValue("Solver", std::string(solver).append(" version ").append(version).c_str());
	pushObject("Input", type_array);
	printf("%-*s", indent(), " ");
	for (const char* sep = ""; iBeg != iEnd; ++iBeg, sep = ",") {
		printString(iBeg->c_str(), sep);
	}
	popObject();
	pushObject("Call", type_array);
}
void JsonOutput::shutdown(const ClaspFacade::Summary& summary) {
	while (!objStack_.empty() && *objStack_.rbegin() == '[') {
		popObject();
	}
	Output::shutdown(summary);
}

void JsonOutput::shutdown() {
	if (!objStack_.empty()) {
		do { popObject(); } while (!objStack_.empty());
		printf("\n");
	}
	fflush(stdout);
}
void JsonOutput::startStep(const ClaspFacade& f) {
	Output::startStep(f);
	pushObject(0, type_object);
}
void JsonOutput::stopStep(const ClaspFacade::Summary& s) {
	assert(!objStack_.empty());
	Output::stopStep(s);
	while (popObject() != '{') { ; }
}

bool JsonOutput::visitThreads(Operation op) {
	if      (op == Enter) { pushObject("Thread", type_array); }
	else if (op == Leave) { popObject(); }
	return true;
}
bool JsonOutput::visitTester(Operation op) {
	if      (op == Enter) { pushObject("Tester"); }
	else if (op == Leave) { popObject(); }
	return true;
}
bool JsonOutput::visitHccs(Operation op) {
	if      (op == Enter) { pushObject("HCC", type_array); }
	else if (op == Leave) { popObject(); }
	return true;
}
void JsonOutput::visitThread(uint32, const SolverStats& stats) {
	pushObject(0, type_object);
	JsonOutput::visitSolverStats(stats);
	popObject();
}
void JsonOutput::visitHcc(uint32, const ProblemStats& p, const SolverStats& s) {
	pushObject(0, type_object);
	JsonOutput::visitProblemStats(p);
	JsonOutput::visitSolverStats(s);
	popObject();
}

void JsonOutput::visitSolverStats(const SolverStats& stats) {
	printCoreStats(stats);
	if (stats.extra) {
		printExtStats(*stats.extra, objStack_.size() == 2);
		printJumpStats(stats.extra->jumps);
	}
}

void JsonOutput::printCoreStats(const CoreStats& st) {
	pushObject("Core");
	printKeyValue("Choices"    , st.choices);
	printKeyValue("Conflicts"  , st.conflicts);
	printKeyValue("Backtracks" , st.backtracks());
	printKeyValue("Backjumps"  , st.backjumps());
	printKeyValue("Restarts"   , st.restarts);
	printKeyValue("RestartAvg" , st.avgRestart());
	printKeyValue("RestartLast", st.lastRestart);
	popObject(); // Core
}

void JsonOutput::printExtStats(const ExtendedStats& stx, bool generator) {
	pushObject("More");
	printKeyValue("CPU", stx.cpuTime);
	printKeyValue("Models", stx.models);
	if (stx.domChoices) {
		printKeyValue("DomChoices", stx.domChoices);
	}
	if (stx.hccTests) {
		pushObject("StabTests");
		printKeyValue("Sum", stx.hccTests);
		printKeyValue("Full", stx.hccTests - stx.hccPartial);
		printKeyValue("Partial", stx.hccPartial);
		popObject();
	}
	if (stx.models) {
		printKeyValue("AvgModel", stx.avgModel());
	}
	printKeyValue("Splits", stx.splits);
	printKeyValue("Problems", stx.gps);
	printKeyValue("AvgGPLength", stx.avgGp());
	pushObject("Lemma");
	printKeyValue("Sum", stx.lemmas());
	printKeyValue("Deleted" , stx.deleted);
	pushObject("Type", type_array);
	const char* names[] = {"Short", "Conflict", "Loop", "Other"};
	for (int i = Constraint_t::Static; i <= Constraint_t::Other; ++i) {
		pushObject();
		printKeyValue("Type", names[i]);
		if (i == 0) {
			printKeyValue("Sum", stx.binary+stx.ternary);
			printKeyValue("Ratio", percent(stx.binary+stx.ternary, stx.lemmas()));
			printKeyValue("Binary", stx.binary);
			printKeyValue("Ternary", stx.ternary);
		}
		else {
			printKeyValue("Sum", stx.lemmas(ConstraintType(i)));
			printKeyValue("AvgLen", stx.avgLen(ConstraintType(i)));
		}
		popObject();
	}
	popObject();
	popObject(); // Lemma
	if (stx.distributed || stx.integrated) {
		pushObject("Distribution");
		printKeyValue("Distributed", stx.distributed);
		printKeyValue("Ratio", stx.distRatio());
		printKeyValue("AvgLbd", stx.avgDistLbd());
		popObject();
		pushObject("Integration");
		printKeyValue("Integrated", stx.integrated);
		printKeyValue("Units", stx.intImps);
		printKeyValue("AvgJump", stx.avgIntJump());
		if (generator) { printKeyValue("Ratio", stx.intRatio()); }
		popObject();
	}
	popObject(); // More
}
void JsonOutput::printJumpStats(const JumpStats& st) {
	pushObject("Jumps");
	printKeyValue("Sum", st.jumps);
	printKeyValue("Max", st.maxJump);
	printKeyValue("MaxExec", st.maxJumpEx);
	printKeyValue("Avg", st.avgJump());
	printKeyValue("AvgExec", st.avgJumpEx());
	printKeyValue("Levels", st.jumpSum);
	printKeyValue("LevelsExec", st.jumped());
	pushObject("Bounded");
	printKeyValue("Sum", st.bounded);
	printKeyValue("Max", st.maxBound);
	printKeyValue("Avg", st.avgBound());
	printKeyValue("Levels", st.boundSum);
	popObject();
	popObject();
}
void JsonOutput::visitLogicProgramStats(const Asp::LpStats& lp) {
	using namespace Asp;
	pushObject("LP");
	pushObject("Rules");
	printKeyValue("Original", lp.rules[0].sum());
	printKeyValue("Final",    lp.rules[1].sum());
	for (uint32 i = 0; i != RuleStats::numKeys(); ++i) {
		if (i != RuleStats::Normal && lp.rules[0][i]) {
			pushObject(RuleStats::toStr(i));
			printKeyValue("Original", lp.rules[0][i]);
			printKeyValue("Final",    lp.rules[1][i]);
			popObject();
		}
	}
	popObject(); // Rules
	printKeyValue("Atoms", lp.atoms);
	if (lp.auxAtoms) { printKeyValue("AuxAtoms", lp.auxAtoms); }
	if (lp.disjunctions[0]) {
		pushObject("Disjunctions");
		printKeyValue("Original", lp.disjunctions[0]);
		printKeyValue("Final", lp.disjunctions[1]);
		popObject();
	}
	pushObject("Bodies");
	printKeyValue("Original", lp.bodies[0].sum());
	printKeyValue("Final"   , lp.bodies[1].sum());
	for (uint32 i = 1; i != BodyStats::numKeys(); ++i) {
		if (lp.bodies[0][i]) {
			pushObject(BodyStats::toStr(i));
			printKeyValue("Original", lp.bodies[0][i]);
			printKeyValue("Final",    lp.bodies[1][i]);
			popObject();
		}
	}
	popObject();
	if      (lp.sccs == 0)              { printKeyValue("Tight", "yes"); }
	else if (lp.sccs == PrgNode::noScc) { printKeyValue("Tight", "N/A"); }
	else                                {
		printKeyValue("Tight", "no");
		printKeyValue("SCCs", lp.sccs);
		printKeyValue("NonHcfs", lp.nonHcfs);
		printKeyValue("UfsNodes", lp.ufsNodes);
		printKeyValue("NonHcfGammas", lp.gammas);
	}
	pushObject("Equivalences");
	printKeyValue("Sum", lp.eqs());
	printKeyValue("Atom", lp.eqs(Var_t::Atom));
	printKeyValue("Body", lp.eqs(Var_t::Body));
	printKeyValue("Other", lp.eqs(Var_t::Hybrid));
	popObject();
	popObject(); // LP
}
void JsonOutput::visitProblemStats(const ProblemStats& p) {
	pushObject("Problem");
	printKeyValue("Variables", p.vars.num);
	printKeyValue("Eliminated", p.vars.eliminated);
	printKeyValue("Frozen", p.vars.frozen);
	pushObject("Constraints");
	uint32 sum = p.numConstraints();
	printKeyValue("Sum", sum);
	printKeyValue("Binary", p.constraints.binary);
	printKeyValue("Ternary", p.constraints.ternary);
	popObject(); // Constraints
	printKeyValue("AcycEdges", p.acycEdges);
	popObject(); // PS
}

void JsonOutput::printKey(const char* k) {
	printf("%s%-*s\"%s\": ", open_, indent(), " ", k);
	open_ = ",\n";
}

void JsonOutput::printString(const char* v, const char* sep) {
	assert(v);
	const uint32 BUF_SIZE = 1024;
	char buf[BUF_SIZE];
	uint32 n = 0;
	buf[n++] = '"';
	while (*v) {
		if      (*v != '\\' && *v != '"')                       { buf[n++] = *v++; }
		else if (*v == '"' || !strchr("\"\\/\b\f\n\r\t", v[1])) { buf[n++] = '\\'; buf[n++] = *v++; }
		else                                                    { buf[n++] = v[0]; buf[n++] = v[1]; v += 2; }
		if (n > BUF_SIZE - 2) { buf[n] = 0; printf("%s%s", sep, buf); n = 0; sep = ""; }
	}
	buf[n] = 0;
	printf("%s%s\"", sep, buf);
}

void JsonOutput::printKeyValue(const char* k, const char* v) {
	printf("%s%-*s\"%s\": ", open_, indent(), " ", k);
	printString(v,"");
	open_ = ",\n";
}
void JsonOutput::printKeyValue(const char* k, uint64 v) {
	printf("%s%-*s\"%s\": %" PRIu64, open_, indent(), " ", k, v);
	open_ = ",\n";
}
void JsonOutput::printKeyValue(const char* k, uint32 v) { return printKeyValue(k, uint64(v)); }
void JsonOutput::printKeyValue(const char* k, double v) {
	if (!isNan(v)) { printf("%s%-*s\"%s\": %.3f", open_, indent(), " ", k, v); }
	else           { printf("%s%-*s\"%s\": %s", open_, indent(), " ", k, "null"); }
	open_ = ",\n";
}

void JsonOutput::pushObject(const char* k, ObjType t) {
	if (k) {
		printKey(k);
	}
	else {
		printf("%s%-*.*s", open_, indent(), indent(), " ");
	}
	char o = t == type_object ? '{' : '[';
	objStack_ += o;
	printf("%c\n", o);
	open_ = "";
}
char JsonOutput::popObject() {
	assert(!objStack_.empty());
	char o = *objStack_.rbegin();
	objStack_.erase(objStack_.size()-1);
	printf("\n%-*.*s%c", indent(), indent(), " ", o == '{' ? '}' : ']');
	open_ = ",\n";
	return o;
}
void JsonOutput::startModel() {
	if (!hasWitness()) {
		pushObject("Witnesses", type_array);
	}
	pushObject();
}
uintp JsonOutput::doPrint(const OutPair& out, uintp data) {
	const char* sep = reinterpret_cast(data);
	if (out.first){ printString(out.first, sep); }
	else          { printf("%s%d", sep, out.second.sign() ? -static_cast(out.second.var()) : static_cast(out.second.var())); }
	return reinterpret_cast(", ");
}
void JsonOutput::printModel(const OutputTable& out, const Model& m, PrintLevel x) {
	uint32 hasModel = (x == modelQ());
	if (hasModel) {
		startModel();
		pushObject("Value", type_array);
		printf("%-*s", indent(), " ");
		printWitness(out, m, reinterpret_cast(""));
		popObject();
		if (m.consequences() && x == optQ()) {
			printCons(numCons(out, m));
		}
	}
	if (x == optQ()) {
		if (m.consequences() && !hasModel++) {
			startModel();
			printCons(numCons(out, m));
		}
		if (m.costs) {
			if (!hasModel++) { startModel(); }
			printCosts(*m.costs);
		}
	}
	if (hasModel) { popObject(); }
}
void JsonOutput::printCosts(const SumVec& opt, const char* name) {
	pushObject(name, type_array);
	printf("%-*s", indent(), " ");
	const char* sep = "";
	for (SumVec::const_iterator it = opt.begin(), end = opt.end(); it != end; ++it) {
		printf("%s%" PRId64, sep, *it);
		sep = ", ";
	}
	popObject();
}
void JsonOutput::printCons(const UPair& cons) {
	pushObject("Consequences");
	printKeyValue("True", cons.first);
	printKeyValue("Open", cons.second);
	popObject();
}

void JsonOutput::printSummary(const ClaspFacade::Summary& run, bool final) {
	if (hasWitness()) { popObject(); }
	const char* res = "UNKNOWN";
	if      (run.unsat()) { res = "UNSATISFIABLE"; }
	else if (run.sat())   { res = !run.optimum() ? "SATISFIABLE" : "OPTIMUM FOUND"; }
	printKeyValue("Result", res);
	if (verbosity()) {
		if (run.result.interrupted()){ printKeyValue(run.result.signal != SIGALRM ? "INTERRUPTED" : "TIME LIMIT", uint32(1));  }
		pushObject("Models");
		printKeyValue("Number", run.numEnum);
		printKeyValue("More"  , run.complete() ? "no" : "yes");
		if (run.sat()) {
			if (run.consequences()){
				printKeyValue(run.consequences(), run.complete() ? "yes":"unknown");
				printCons(numCons(run.ctx().output, *run.model()));
			}
			if (run.optimize())    {
				printKeyValue("Optimum", run.optimum()?"yes":"unknown");
				printKeyValue("Optimal", run.optimal());
				printCosts(*run.costs());
			}
		}
		popObject();
		if (run.hasLower() && !run.optimum()) {
			pushObject("Bounds");
			printCosts(run.lower(), "Lower");
			printCosts(run.costs() ? *run.costs() : SumVec(), "Upper");
			popObject();
		}
		if (final) { printKeyValue("Calls", run.step + 1); }
		pushObject("Time");
		printKeyValue("Total", run.totalTime);
		printKeyValue("Solve", run.solveTime);
		printKeyValue("Model", run.satTime);
		printKeyValue("Unsat", run.unsatTime);
		printKeyValue("CPU"  , run.cpuTime);
		popObject(); // Time
		if (run.ctx().concurrency() > 1) {
			printKeyValue("Threads", run.ctx().concurrency());
			printKeyValue("Winner",  run.ctx().winner());
		}
	}
}
void JsonOutput::printStatistics(const ClaspFacade::Summary& summary, bool) {
	if (hasWitness()) { popObject(); }
	pushObject("Stats", type_object);
	summary.accept(*this);
	popObject();
}
/////////////////////////////////////////////////////////////////////////////////////////
// TextOutput
/////////////////////////////////////////////////////////////////////////////////////////
#define printKeyValue(k, fmt, value) printf("%s%-*s: " fmt, format[cat_comment], width_, (k), (value))
#define printLN(cat, fmt, ...)       printf("%s" fmt "\n", format[cat], __VA_ARGS__)
#define printBR(cat)                 printf("%s\n", format[cat])
#define printKey(k)                  printf("%s%-*s: ", format[cat_comment], width_, (k))
const char* const rowSep   = "----------------------------------------------------------------------------|";
const char* const finalSep = "=============================== Accumulation ===============================|";

static inline std::string prettify(const std::string& str) {
	if (str.size() < 40) return str;
	std::string t("...");
	t.append(str.end()-38, str.end());
	return t;
}
TextOutput::TextOutput(uint32 verbosity, Format f, const char* catAtom, char ifs) : Output(verbosity), stTime_(0.0), state_(0) {
	result[res_unknonw]    = "UNKNOWN";
	result[res_sat]        = "SATISFIABLE";
	result[res_unsat]      = "UNSATISFIABLE";
	result[res_opt]        = "OPTIMUM FOUND";
	format[cat_comment]    = "";
	format[cat_value]      = "";
	format[cat_objective]  = "Optimization: ";
	format[cat_result]     = "";
	format[cat_value_term] = "";
	format[cat_atom_name]  = "%s";
	format[cat_atom_var]   = "-%d";
	if (f == format_aspcomp) {
		format[cat_comment]   = "% ";
		format[cat_value]     = "ANSWER\n";
		format[cat_objective] = "COST ";
		format[cat_atom_name] = "%s.";
		result[res_sat]       = "";
		result[res_unsat]     = "INCONSISTENT";
		result[res_opt]       = "OPTIMUM";
		setModelQuiet(print_best);
		setOptQuiet(print_best);
	}
	else if (f == format_sat09 || f == format_pb09) {
		format[cat_comment]   = "c ";
		format[cat_value]     = "v ";
		format[cat_objective] = "o ";
		format[cat_result]    = "s ";
		format[cat_value_term]= "0";
		if (f == format_pb09) {
			format[cat_value_term]= "";
			format[cat_atom_var]  = "-x%d";
			setModelQuiet(print_best);
		}
	}
	if (catAtom && *catAtom) {
		char f = 0;
		for (const char* x = catAtom; *x; ++x) {
			CLASP_FAIL_IF(*x == '\n', "cat_atom: Invalid format string - new line not allowed!");
			if (*x == '%')  {
				CLASP_FAIL_IF(!*++x, "cat_atom: Invalid format string - missing format specifier!");
				if (*x != '%') {
					CLASP_FAIL_IF(f, "cat_atom: Invalid format string - too many arguments!");
					CLASP_FAIL_IF(std::strchr("sd0", *x) == 0, "cat_atom: Invalid format string - invalid format specifier!");
					f = *x;
				}
			}
		}
		if (f == '0') {
			std::size_t len = std::strlen(catAtom);
			fmt_.reserve((len * 2) + 2);
			fmt_.append(catAtom).append(1, '\0').append(1, '-').append(catAtom);
			std::string::size_type p = fmt_.find("%0") + 1;
			fmt_[p] = 's';
			fmt_[len + 2 + p] = 'd';
			format[cat_atom_name] = fmt_.c_str();
			format[cat_atom_var]  = fmt_.c_str() + len + 1;
		}
		else {
			format[f == 's' ? cat_atom_name : cat_atom_var] = catAtom;
		}
	}
	CLASP_FAIL_IF(*format[cat_atom_var] != '-' , "cat_atom: Invalid format string - must start with '-'!");
	ifs_[0] = ifs;
	ifs_[1] = 0;
	width_  = 13+(int)strlen(format[cat_comment]);
	ev_     = -1;
}
TextOutput::~TextOutput() {}

void TextOutput::comment(uint32 v, const char* fmt, ...) const {
	if (verbosity() >= v) {
		printf("%s", format[cat_comment]);
		va_list args;
		va_start(args, fmt);
		vfprintf(stdout, fmt, args);
		va_end(args);
		fflush(stdout);
	}
}

void TextOutput::run(const char* solver, const char* version, const std::string* begInput, const std::string* endInput) {
	if (!version) version = "";
	if (solver) comment(1, "%s version %s\n", solver, version);
	if (begInput != endInput) {
		comment(1, "Reading from %s%s\n", prettify(*begInput).c_str(), (endInput - begInput) > 1 ? " ..." : "");
	}
}
void TextOutput::shutdown() {}
void TextOutput::printSummary(const ClaspFacade::Summary& run, bool final) {
	if (final && callQ() != print_no){
		comment(1, "%s\n", finalSep);
	}
	const char* res = result[res_unknonw];
	if      (run.unsat()) { res = result[res_unsat]; }
	else if (run.sat())   { res = !run.optimum() ? result[res_sat] : result[res_opt]; }
	if (std::strlen(res)) { printLN(cat_result, "%s", res); }
	if (verbosity() || stats(run)) {
		printBR(cat_comment);
		if (run.result.interrupted()){ printKeyValue((run.result.signal != SIGALRM ? "INTERRUPTED" : "TIME LIMIT"), "%u\n", uint32(1));  }
		const char* const moreStr = run.complete() ? "" :  "+";
		printKey("Models");
		printf("%" PRIu64 "%s\n", run.numEnum, moreStr);
		if (run.sat()) {
			if (run.consequences()) { printLN(cat_comment, "  %-*s: %s", width_-2, run.consequences(), (run.complete()?"yes":"unknown")); }
			if (run.costs())        { printKeyValue("  Optimum", "%s\n", run.optimum()?"yes":"unknown"); }
			if (run.optimize())     {
				if (run.optimal() > 1){ printKeyValue("  Optimal", "%" PRIu64"\n", run.optimal()); }
				printKey("Optimization");
				printCosts(*run.costs());
				printf("\n");
			}
			if (run.consequences()) {
				printKey("Consequences");
				printf("%u%s\n", numCons(run.ctx().output, *run.model()).first, moreStr);
			}
		}
		if (run.hasLower() && !run.optimum()) {
			printKey("Bounds");
			printBounds(run.lower(), run.costs() ? *run.costs() : SumVec());
			printf("\n");
		}
		if (final) { printKeyValue("Calls", "%u\n", run.step + 1); }
		printKey("Time");
		printf("%.3fs (Solving: %.2fs 1st Model: %.2fs Unsat: %.2fs)\n"
			, run.totalTime
			, run.solveTime
			, run.satTime
			, run.unsatTime);
		printKeyValue("CPU Time", "%.3fs\n", run.cpuTime);
		if (run.ctx().concurrency() > 1) {
			printKeyValue("Threads", "%-8u", run.ctx().concurrency());
			printf(" (Winner: %u)\n", run.ctx().winner());
		}
	}
}
void TextOutput::printStatistics(const ClaspFacade::Summary& run, bool) {
	printBR(cat_comment);
	accu_ = true;
	run.accept(*this);
}
void TextOutput::startStep(const ClaspFacade& f) {
	Output::startStep(f);
	if (callQ() != print_no) { comment(1, "%s\n", rowSep); comment(2, "%-13s: %d\n", "Call", f.step()+1); }
}
void TextOutput::onEvent(const Event& ev) {
	typedef SatElite::Progress SatPre;
	if (ev.verb <= verbosity()) {
		if      (ev.system == 0)      { setState(0,0,0); }
		else if (ev.system == state_) {
			if      (ev.system == Event::subsystem_solve)       { printSolveProgress(ev); }
			else if (const SatPre* sat = event_cast(ev)){
				if      (sat->op != SatElite::Progress::event_algorithm) { comment(2, "Sat-Prepro   : %c: %8u/%-8u\r", (char)sat->op, sat->cur, sat->max); }
				else if (sat->cur!= sat->max)                            {
					setState(0,0,0); comment(2, "Sat-Prepro   :\r");
					state_ = Event::subsystem_prepare;
				}
				else {
					SatPreprocessor* p = sat->self;
					double tEnd = RealTime::getTime();
					comment(2, "Sat-Prepro   : %.3f (ClRemoved: %u ClAdded: %u LitsStr: %u)\n", tEnd - stTime_, p->stats.clRemoved, p->stats.clAdded, p->stats.litsRemoved);
					state_ = 0;
				}
			}
		}
		else if (const LogEvent* log = event_cast(ev)) {
			setState(ev.system, ev.verb, log->msg);
		}
	}
	Output::onEvent(ev);
}

void TextOutput::setState(uint32 state, uint32 verb, const char* m) {
	if (state != state_ && verb <= verbosity()) {
		double tEnd = RealTime::getTime();
		if      (state_ == Event::subsystem_solve) { comment(2, "%s\n", rowSep); line_ = 20; }
		else if (state_ != Event::subsystem_facade){ printf("%.3f\n", tEnd - stTime_); }
		stTime_ = tEnd;
		state_  = state;
		ev_     = -1;
		if      (state_ == Event::subsystem_load)   { comment(2, "%-13s: ", m ? m : "Reading"); }
		else if (state_ == Event::subsystem_prepare){ comment(2, "%-13s: ", m ? m : "Preprocessing"); }
		else if (state_ == Event::subsystem_solve)  { comment(1, "Solving...\n"); line_ = 0; }
	}
}

void TextOutput::printSolveProgress(const Event& ev) {
	if (ev.id == SolveTestEvent::id_s  && (verbosity() & 4) == 0) { return; }
	if (ev.id == BasicSolveEvent::id_s && (verbosity() & 1) == 0) { return; }
	char lEnd = '\n';
	char line[128];
	if      (const BasicSolveEvent* be = event_cast(ev)) { Clasp::Cli::format(*be, line, 128); }
	else if (const SolveTestEvent*  te = event_cast(ev) ) { Clasp::Cli::format(*te, line, 128); lEnd= te->result == -1 ? '\r' : '\n'; }
#if WITH_THREADS
	else if (const mt::MessageEvent*me = event_cast(ev)){ Clasp::Cli::format(*me, line, 128); }
#endif
	else if (const LogEvent* log = event_cast(ev))              {
		clasp_format(line, sizeof(line), "[Solving+%.3fs]", RealTime::getTime() - stTime_);
		printLN(cat_comment, "%2u:L| %-30s %-38s |", log->solver->id(), line, log->msg);
		return;
	}
	else                                                                  { return; }
	bool newEvent = ((uint32)ev_.fetch_and_store(static_cast(ev.id))) != ev.id;
	if ((lEnd == '\n' && --line_ == 0) || newEvent) {
		if (line_ <= 0) {
			line_ = 20;
			if (verbosity() > 1 && (verbosity() & 1) != 0) {
				printf("%s%s\n"
					"%sID:T       Vars           Constraints         State            Limits       |\n"
					"%s       #free/#fixed   #problem/#learnt  #conflicts/ratio #conflict/#learnt  |\n"
					"%s%s\n", format[cat_comment], rowSep, format[cat_comment], format[cat_comment], format[cat_comment], rowSep);
			}
			else if (verbosity() > 1) {
				printf("%s%s\n"
					"%sID:T       Info                     Info                      Info          |\n"
					"%s%s\n", format[cat_comment], rowSep, format[cat_comment], format[cat_comment], rowSep);
			}
		}
		else { printLN(cat_comment, "%s", rowSep); }
	}
	printf("%s%s%c", format[cat_comment], line, lEnd);
	fflush(stdout);
}

const char* TextOutput::fieldSeparator() const { return ifs_; }
int TextOutput::printSep(CategoryKey k) const {
	return printf("%s%s", fieldSeparator(), *fieldSeparator() != '\n' ? "" : format[k]);
}
uintp TextOutput::doPrint(const OutPair& s, UPtr data) {
	uint32& accu    = reinterpret_cast(data)->first;
	uint32& maxLine = reinterpret_cast(data)->second;
	if      (accu < maxLine) { accu += printSep(cat_value); }
	else if (!maxLine)       { maxLine = s.first || *fieldSeparator() != ' ' ? UINT32_MAX : 70; }
	else                     { printf("\n%s", format[cat_value]); accu = 0; }
	if (s.first){ accu += printf(format[cat_atom_name], s.first); }
	else        { accu += printf(format[cat_atom_var] + !s.second.sign(), static_cast(s.second.var())); }
	return data;
}
void TextOutput::printValues(const OutputTable& out, const Model& m) {
	printf("%s", format[cat_value]);
	UPair data;
	printWitness(out, m, reinterpret_cast(&data));
	if (*format[cat_value_term]) {
		printSep(cat_value);
		printf("%s", format[cat_value_term]);
	}
	printf("\n");
}
void TextOutput::printMeta(const OutputTable& out, const Model& m) {
	if (m.consequences()) {
		UPair cons = numCons(out, m);
		printLN(cat_comment, "Consequences: [%u;%u]", cons.first, cons.first + cons.second);
	}
	if (m.costs) {
		printf("%s", format[cat_objective]);
		printCosts(*m.costs);
		printf("\n");
	}
}
void TextOutput::printModel(const OutputTable& out, const Model& m, PrintLevel x) {
	if (x == modelQ()) {
		comment(1, "%s: %" PRIu64"\n", !m.up ? "Answer" : "Update", m.num);
		printValues(out, m);
	}
	if (x == optQ()) {
		printMeta(out, m);
	}
	fflush(stdout);
}
void TextOutput::printUnsat(const OutputTable& out, const LowerBound* lower, const Model* prevModel) {
	if (lower && optQ() == print_all) {
		const SumVec* costs = prevModel ? prevModel->costs : 0;
		printf("%s%-12s: ", format[cat_comment], "Progression");
		if (costs && costs->size() > lower->level) {
			const char* next = *fieldSeparator() != '\n' ? "" : format[cat_comment];
			for (uint32 i = 0; i != lower->level; ++i) {
				printf("%" PRId64 "%s%s", (*costs)[i], fieldSeparator(), next);
			}
			wsum_t ub = (*costs)[lower->level];
			int w = 1; for (wsum_t x = ub; x > 9; ++w) { x /= 10; }
			printf("[%*" PRId64 ";%" PRId64 "] (Error: %g)", w, lower->bound, ub, double(ub - lower->bound)/double(lower->bound));
		}
		else {
			printf("[%" PRId64 ";inf]", lower->bound);
		}
		printf("\n");
	}
	if (prevModel && prevModel->up && optQ() == print_all) {
		printMeta(out, *prevModel);
	}
	fflush(stdout);
}

void TextOutput::printBounds(const SumVec& lower, const SumVec& upper) const {
	for (uint32 i = 0, uMax = upper.size(), lMax = lower.size(), end = std::max(uMax, lMax), seps = end; i != end; ++i) {
		if (i >= uMax) {
			printf("[%" PRId64";*]", lower[i]);
		}
		else if (i >= lMax || lower[i] == upper[i]) {
			printf("%" PRId64, upper[i]);
		}
		else {
			printf("[%" PRId64";%" PRId64"]", lower[i], upper[i]);
		}
		if (--seps) { printSep(cat_objective); }
	}
}

void TextOutput::printCosts(const SumVec& costs) const {
	if (!costs.empty()) {
		printf("%" PRId64, costs[0]);
		for (uint32 i = 1, end = (uint32)costs.size(); i != end; ++i) {
			printSep(cat_objective);
			printf("%" PRId64, costs[i]);
		}
	}
}
bool TextOutput::startSection(const char* n) const {
	printLN(cat_comment, "============ %s Stats ============", n);
	printBR(cat_comment);
	return true;
}
void TextOutput::startObject(const char* n, uint32 i) const {
	printLN(cat_comment, "[%s %u]", n, i);
	printBR(cat_comment);
}
bool TextOutput::visitThreads(Operation op) {
	accu_ = false;
	return op != Enter || startSection("Thread");
}
bool TextOutput::visitTester(Operation op) {
	accu_ = false;
	return op != Enter || startSection("Tester");
}
void TextOutput::visitThread(uint32 i, const SolverStats& stats) {
	startObject("Thread", i);
	TextOutput::visitSolverStats(stats);
}
void TextOutput::visitHcc(uint32 i, const ProblemStats& p, const SolverStats& s) {
	startObject("HCC", i);
	TextOutput::visitProblemStats(p);
	TextOutput::visitSolverStats(s);
}
void TextOutput::visitLogicProgramStats(const Asp::LpStats& lp) {
	using namespace Asp;
	uint32 rFinal = lp.rules[1].sum(), rOriginal = lp.rules[0].sum();
	printKeyValue("Rules", "%-8u", rFinal);
	if (rFinal != rOriginal) {
		printf(" (Original: %u)", rOriginal);
	}
	printf("\n");
	char buf[80];
	for (uint32 i = 0; i != RuleStats::numKeys(); ++i) {
		if (i == RuleStats::Normal) { continue; }
		if (uint32 r = lp.rules[0][i]) {
			printKeyValue(clasp_format(buf, 80, "  %s", RuleStats::toStr(i)), "%-8u", lp.rules[1][i]);
			if (r != lp.rules[1][i]) { printf(" (Original: %u)", r); }
			printf("\n");
		}
	}
	printKeyValue("Atoms", "%-8u", lp.atoms);
	if (lp.auxAtoms) {
		printf(" (Original: %u Auxiliary: %u)", lp.atoms-lp.auxAtoms, lp.auxAtoms);
	}
	printf("\n");
	if (lp.disjunctions[0]) {
		printKeyValue("Disjunctions", "%-8u", lp.disjunctions[1]);
		printf(" (Original: %u)\n", lp.disjunctions[0]);
	}
	uint32 bFinal = lp.bodies[1].sum(), bOriginal = lp.bodies[0].sum();
	printKeyValue("Bodies", "%-8u", bFinal);
	if (bFinal != bOriginal) {
		printf(" (Original: %u)", bOriginal);
	}
	printf("\n");
	for (uint32 i = 1; i != BodyStats::numKeys(); ++i) {
		if (uint32 b = lp.bodies[0][i]) {
			printKeyValue(clasp_format(buf, 80, "  %s", BodyStats::toStr(i)), "%-8u", lp.bodies[1][i]);
			if (b != lp.bodies[1][i]) { printf(" (Original: %u)", b); }
			printf("\n");
		}
	}
	if (lp.eqs() > 0) {
		printKeyValue("Equivalences", "%-8u", lp.eqs());
		printf(" (Atom=Atom: %u Body=Body: %u Other: %u)\n"
			, lp.eqs(Var_t::Atom)
			, lp.eqs(Var_t::Body)
			, lp.eqs(Var_t::Hybrid));
	}
	printKey("Tight");
	if      (lp.sccs == 0)              { printf("Yes"); }
	else if (lp.sccs != PrgNode::noScc) { printf("%-8s (SCCs: %u Non-Hcfs: %u Nodes: %u Gammas: %u)", "No", lp.sccs, lp.nonHcfs, lp.ufsNodes, lp.gammas); }
	else                                { printf("N/A"); }
	printf("\n");
}
void TextOutput::visitProblemStats(const ProblemStats& ps) {
	uint32 sum = ps.numConstraints();
	printKeyValue("Variables", "%-8u", ps.vars.num);
	printf(" (Eliminated: %4u Frozen: %4u)\n", ps.vars.eliminated, ps.vars.frozen);
	printKeyValue("Constraints", "%-8u", sum);
	printf(" (Binary: %5.1f%% Ternary: %5.1f%% Other: %5.1f%%)\n"
		, percent(ps.constraints.binary, sum)
		, percent(ps.constraints.ternary, sum)
		, percent(ps.constraints.other, sum));
	if (ps.acycEdges) {
		printKeyValue("Acyc-Edges", "%-8u\n", ps.acycEdges);
	}
	printBR(cat_comment);
}
void TextOutput::visitSolverStats(const Clasp::SolverStats& st) {
	printStats(st);
	printBR(cat_comment);
}
void TextOutput::printStats(const Clasp::SolverStats& st) const {
	if (!accu_ && st.extra) {
		printKeyValue("CPU Time", "%.3fs\n", st.extra->cpuTime);
		printKeyValue("Models", "%" PRIu64"\n", st.extra->models);
	}
	printKeyValue("Choices", "%-8" PRIu64, st.choices);
	if (st.extra && st.extra->domChoices) { printf(" (Domain: %" PRIu64")", st.extra->domChoices); }
	printf("\n");
	printKeyValue("Conflicts", "%-8" PRIu64"", st.conflicts);
	printf(" (Analyzed: %" PRIu64")\n", st.backjumps());
	printKeyValue("Restarts", "%-8" PRIu64"", st.restarts);
	if (st.restarts) {
		printf(" (Average: %.2f Last: %" PRIu64")", st.avgRestart(), st.lastRestart);
	}
	printf("\n");
	if (!st.extra) return;
	const ExtendedStats& stx = *st.extra;
	if (stx.hccTests) {
		printKeyValue("Stab. Tests", "%-8" PRIu64, stx.hccTests);
		printf(" (Full: %" PRIu64" Partial: %" PRIu64")\n", stx.hccTests - stx.hccPartial, stx.hccPartial);
	}
	if (stx.models) {
		printKeyValue("Model-Level", "%-8.1f\n", stx.avgModel());
	}
	printKeyValue("Problems", "%-8" PRIu64, (uint64)stx.gps);
	printf(" (Average Length: %.2f Splits: %" PRIu64")\n", stx.avgGp(), (uint64)stx.splits);
	uint64 sum = stx.lemmas();
	printKeyValue("Lemmas", "%-8" PRIu64, sum);
	printf(" (Deleted: %" PRIu64")\n", stx.deleted);
	printKeyValue("  Binary", "%-8" PRIu64, uint64(stx.binary));
	printf(" (Ratio: %6.2f%%)\n", percent(stx.binary, sum));
	printKeyValue("  Ternary", "%-8" PRIu64, uint64(stx.ternary));
	printf(" (Ratio: %6.2f%%)\n", percent(stx.ternary, sum));
	const char* names[] = {"  Conflict", "  Loop", "  Other"};
	for (int i = 0; i != sizeof(names)/sizeof(names[0]); ++i) {
		ConstraintType type = static_cast(i+1);
		printKeyValue(names[i], "%-8" PRIu64, stx.lemmas(type));
		printf(" (Average Length: %6.1f Ratio: %6.2f%%) \n", stx.avgLen(type), percent(stx.lemmas(type), sum));
	}
	if (stx.distributed || stx.integrated) {
		printKeyValue("  Distributed", "%-8" PRIu64, stx.distributed);
		printf(" (Ratio: %6.2f%% Average LBD: %.2f) \n", stx.distRatio()*100.0, stx.avgDistLbd());
		printKeyValue("  Integrated", "%-8" PRIu64, stx.integrated);
		if (accu_) { printf(" (Ratio: %6.2f%% ", stx.intRatio()*100.0); }
		else { printf(" ("); }
		printf("Unit: %" PRIu64" Average Jumps: %.2f)\n", stx.intImps, stx.avgIntJump());
	}
	printJumps(stx.jumps);
}
void TextOutput::printJumps(const JumpStats& st) const {
	printKeyValue("Backjumps", "%-8" PRIu64, st.jumps);
	printf(" (Average: %5.2f Max: %3u Sum: %6" PRIu64")\n", st.avgJump(), st.maxJump, st.jumpSum);
	printKeyValue("  Executed", "%-8" PRIu64, st.jumps-st.bounded);
	printf(" (Average: %5.2f Max: %3u Sum: %6" PRIu64" Ratio: %6.2f%%)\n", st.avgJumpEx(), st.maxJumpEx, st.jumped(), st.jumpedRatio()*100.0);
	printKeyValue("  Bounded", "%-8" PRIu64, st.bounded);
	printf(" (Average: %5.2f Max: %3u Sum: %6" PRIu64" Ratio: %6.2f%%)\n", st.avgBound(), st.maxBound, st.boundSum, 100.0 - (st.jumpedRatio()*100.0));
}

#undef printKeyValue
#undef printKey
#undef printLN
#undef printBR
}}
clasp-3.2.2/libclasp/src/clause.cpp000066400000000000000000001123421304134206100171550ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 

namespace Clasp { namespace Detail {
struct GreaterLevel {
	GreaterLevel(const Solver& s) : solver_(s) {}
	bool operator()(const Literal& p1, const Literal& p2) const {
		assert(solver_.value(p1.var()) != value_free && solver_.value(p2.var()) != value_free);
		return solver_.level(p1.var()) > solver_.level(p2.var());
	}
private:
	GreaterLevel& operator=(const GreaterLevel&);
	const Solver& solver_;
};

struct Sink {
	explicit Sink(SharedLiterals* c) : clause(c) {}
	~Sink() { if (clause) clause->release(); }
	SharedLiterals* clause;
};

void* alloc(uint32 size) {
	CLASP_PRAGMA_TODO("replace with CACHE_LINE_ALIGNED alloc")
	return ::operator new(size);
}
void free(void* mem) {
	::operator delete(mem);
}

} // namespace Detail

/////////////////////////////////////////////////////////////////////////////////////////
// SharedLiterals
/////////////////////////////////////////////////////////////////////////////////////////
SharedLiterals* SharedLiterals::newShareable(const Literal* lits, uint32 size, ConstraintType t, uint32 numRefs) {
	void* m = Detail::alloc(sizeof(SharedLiterals)+(size*sizeof(Literal)));
	return new (m) SharedLiterals(lits, size, t, numRefs);
}

SharedLiterals::SharedLiterals(const Literal* a_lits, uint32 size, ConstraintType t, uint32 refs)
	: size_type_( (size << 2) + t ) {
	refCount_ = std::max(uint32(1),refs);
	std::memcpy(lits_, a_lits, size*sizeof(Literal));
}

uint32 SharedLiterals::simplify(Solver& s) {
	bool   removeFalse = unique();
	uint32   newSize   = 0;
	Literal* r         = lits_;
	Literal* e         = lits_+size();
	ValueRep v;
	for (Literal* c = r; r != e; ++r) {
		if ( (v = s.value(r->var())) == value_free ) {
			if (c != r) *c = *r;
			++c; ++newSize;
		}
		else if (v == trueValue(*r)) {
			newSize = 0; break;
		}
		else if (!removeFalse) ++c;
	}
	if (removeFalse && newSize != size()) {
		size_type_ = (newSize << 2) | (size_type_ & uint32(3));
	}
	return newSize;
}

void SharedLiterals::release(uint32 n) {
	if ((refCount_ -= n) == 0) {
		this->~SharedLiterals();
		Detail::free(this);
	}
}
SharedLiterals* SharedLiterals::share() {
	++refCount_;
	return this;
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClauseCreator
/////////////////////////////////////////////////////////////////////////////////////////
ClauseCreator::ClauseCreator(Solver* s)
	: solver_(s)
	, flags_(0){
}

ClauseCreator& ClauseCreator::start(ConstraintType t) {
	assert(solver_ && (solver_->decisionLevel() == 0 || t != Constraint_t::Static));
	literals_.clear();
	extra_ = ConstraintInfo(t);
	return *this;
}

uint32 ClauseCreator::watchOrder(const Solver& s, Literal p) {
	ValueRep value_p = s.value(p.var());
	// DL+1,  if isFree(p)
	// DL(p), if isFalse(p)
	// ~DL(p),if isTrue(p)
	uint32   abstr_p = value_p == value_free ? s.decisionLevel()+1 : s.level(p.var()) ^ -(value_p==trueValue(p));
	assert(abstr_p > 0 || (s.isFalse(p) && s.level(p.var()) == 0));
	return abstr_p;
}

ClauseRep ClauseCreator::prepare(Solver& s, const Literal* in, uint32 inSize, const ConstraintInfo& e, uint32 flags, Literal* out, uint32 outMax) {
	assert(out && outMax > 2);
	ClauseRep ret  = ClauseRep::prepared(out, 0, e);
	uint32 abst_w1 = 0, abst_w2 = 0;
	bool simplify  = ((flags & clause_force_simplify) != 0) && inSize > 2 && outMax >= inSize;
	Literal tag    = ~s.tagLiteral();
	Var     vMax   = 0;
	for (uint32 i = 0, j = 0, MAX_OUT = outMax - 1; i != inSize; ++i) {
		Literal p     = in[i];
		uint32 abst_p = watchOrder(s, p);
		if ((abst_p + 1) > 1 && (!simplify || !s.seen(p.var()))) {
			out[j] = p;
			if (p == tag)         { ret.info.setTagged(true); }
			if (p.var() > vMax)   { vMax = p.var();}
			if (simplify)         { s.markSeen(p); }
			if (abst_p > abst_w1) { std::swap(abst_p, abst_w1); std::swap(out[0], out[j]); }
			if (abst_p > abst_w2) { std::swap(abst_p, abst_w2); std::swap(out[1], out[j]); }
			if (j != MAX_OUT)     { ++j;  }
			++ret.size;
		}
		else if (abst_p == UINT32_MAX || (simplify && abst_p && s.seen(~p))) {
			abst_w1 = UINT32_MAX;
			break;
		}
	}
	if (simplify) {
		for (uint32 x = 0, end = ret.size; x != end; ++x) { s.clearSeen(out[x].var()); }
	}
	if (abst_w1 == UINT32_MAX || (abst_w2 && out[0].var() == out[1].var())) {
		out[0]   = abst_w1 == UINT32_MAX || out[0] == ~out[1] ? lit_true() : out[0];
		ret.size = 1;
	}
	ret.info.setAux(s.auxVar(vMax));
	return ret;
}


ClauseRep ClauseCreator::prepare(Solver& s, LitVec& lits, uint32 flags, const ConstraintInfo& info) {
	if (lits.empty()) { lits.push_back(lit_false()); }
	if ((flags & clause_no_prepare) == 0 || (flags & clause_force_simplify) != 0) {
		ClauseRep x = prepare(s, &lits[0], (uint32)lits.size(), info, flags, &lits[0]);
		shrinkVecTo(lits, x.size);
		return x;
	}
	return ClauseRep::prepared(&lits[0], (uint32)lits.size(), info);
}

ClauseRep ClauseCreator::prepare(bool forceSimplify) {
	return prepare(*solver_, literals_, forceSimplify ? clause_force_simplify : 0, extra_);
}

ClauseCreator::Status ClauseCreator::status(const Solver& s, const Literal* clause_begin, const Literal* clause_end) {
	if (clause_end <= clause_begin) { return status_empty; }
	Literal temp[3];
	ClauseRep x = prepare(const_cast(s), clause_begin, uint32(clause_end - clause_begin), ConstraintInfo(), 0, temp, 3);
	return status(s, x);
}

ClauseCreator::Status ClauseCreator::status(const Solver& s, const ClauseRep& c) {
	uint32 dl = s.decisionLevel();
	uint32 fw = c.size     ? watchOrder(s, c.lits[0]) : 0;
	if (fw == UINT32_MAX) { return status_subsumed; }
	uint32 sw = c.size > 1 ? watchOrder(s, c.lits[1]) : 0;
	uint32 st = status_open;
	if      (fw > varMax)   { st|= status_sat; fw = ~fw; }
	else if (fw <= dl)      { st|= (fw ? status_unsat : status_empty); }
	if (sw <= dl && fw > sw){ st|= status_unit;  }
	return static_cast(st);
}

bool ClauseCreator::ignoreClause(const Solver& s, const ClauseRep& c, Status st, uint32 flags) {
	uint32 x = (st & (status_sat|status_unsat));
	if (x == status_open)  { return false; }
	if (x == status_unsat) { return st != status_empty && (flags & clause_not_conflict) != 0; }
	return st == status_subsumed || (st == status_sat && ( (flags & clause_not_sat) != 0 || ((flags & clause_not_root_sat) != 0 && s.level(c.lits[0].var()) <= s.rootLevel())));
}

ClauseCreator::Result ClauseCreator::end(uint32 flags) {
	assert(solver_);
	flags |= flags_;
	return ClauseCreator::create_prepared(*solver_, prepare(*solver_, literals_, flags, extra_), flags);
}

ClauseHead* ClauseCreator::newProblemClause(Solver& s, const ClauseRep& clause, uint32 flags) {
	ClauseHead* ret;
	Solver::WatchInitMode wMode = s.watchInitMode();
	if      (flags&clause_watch_first){ wMode = SolverStrategies::watch_first;}
	else if (flags&clause_watch_rand) { wMode = SolverStrategies::watch_rand; }
	else if (flags&clause_watch_least){ wMode = SolverStrategies::watch_least;}
	if (clause.size > 2 && wMode != SolverStrategies::watch_first) {
		uint32 fw = 0, sw = 1;
		if (wMode == SolverStrategies::watch_rand) {
			fw = s.rng.irand(clause.size);
			do { sw = s.rng.irand(clause.size); } while (sw == fw);
		}
		else if (wMode == SolverStrategies::watch_least) {
			uint32 cw1 = s.numWatches(~clause.lits[0]);
			uint32 cw2 = s.numWatches(~clause.lits[1]);
			if (cw1 > cw2) { std::swap(fw, sw); std::swap(cw1, cw2); }
			for (uint32 i = 2; i != clause.size && cw2; ++i) {
				uint32 p   = i;
				uint32 cwp = s.numWatches(~clause.lits[i]);
				if (cwp < cw1) { std::swap(cwp, cw1); std::swap(fw, p); }
				if (cwp < cw2) { std::swap(cwp, cw2); std::swap(sw, p); }
			}
		}
		std::swap(clause.lits[0], clause.lits[fw]);
		std::swap(clause.lits[1], clause.lits[sw]);
	}
	if (clause.size <= Clause::MAX_SHORT_LEN || !s.sharedContext()->physicalShareProblem()) {
		ret = Clause::newClause(s, clause);
	}
	else {
		ret = Clause::newShared(s, SharedLiterals::newShareable(clause.lits, clause.size, clause.info.type(), 1), clause.info, clause.lits, false);
	}
	if ( (flags & clause_no_add) == 0 ) {
		assert(!clause.info.aux());
		s.add(ret);
	}
	return ret;
}

ClauseHead* ClauseCreator::newLearntClause(Solver& s, const ClauseRep& clause, uint32 flags) {
	ClauseHead* ret;
	Detail::Sink sharedPtr(0);
	sharedPtr.clause = s.distribute(clause.lits, clause.size, clause.info);
	if (clause.size <= Clause::MAX_SHORT_LEN || sharedPtr.clause == 0) {
		if (!s.isFalse(clause.lits[1]) || clause.size < s.compressLimit()) {
			ret = Clause::newClause(s, clause);
		}
		else {
			ret = Clause::newContractedClause(s, clause, 2, true);
		}
	}
	else {
		ret              = Clause::newShared(s, sharedPtr.clause, clause.info, clause.lits, false);
		sharedPtr.clause = 0;
	}
	if ( (flags & clause_no_add) == 0 ) {
		s.addLearnt(ret, clause.size, clause.info.type());
	}
	return ret;
}

ClauseHead* ClauseCreator::newUnshared(Solver& s, SharedLiterals* clause, const Literal* w, const ConstraintInfo& e) {
	LitVec temp; temp.reserve(clause->size());
	temp.assign(w, w+2);
	for (const Literal* x = clause->begin(), *end = clause->end(); x != end; ++x) {
		if (watchOrder(s, *x) > 0 && *x != temp[0] && *x != temp[1]) {
			temp.push_back(*x);
		}
	}
	return Clause::newClause(s, ClauseRep::prepared(&temp[0], (uint32)temp.size(), e));
}

ClauseCreator::Result ClauseCreator::create_prepared(Solver& s, const ClauseRep& clause, uint32 flags) {
	assert(s.decisionLevel() == 0 || (clause.info.learnt() && clause.prep));
	Status x = status(s, clause);
	if (ignoreClause(s, clause, x, flags)){
		return Result(0, x);
	}
	if (clause.size > 1) {
		Result ret(0, x);
		if (!clause.info.learnt() && s.satPrepro() && !s.sharedContext()->frozen()) {
			return Result(0, s.satPrepro()->addClause(clause.lits, clause.size) ? x : status_unsat);
		}
		if ((flags & clause_no_heuristic) == 0) { s.heuristic()->newConstraint(s, clause.lits, clause.size, clause.info.type()); }
		if (clause.size > 3 || (flags&clause_explicit) != 0 || !s.allowImplicit(clause)) {
			ret.local = clause.info.learnt() ? newLearntClause(s, clause, flags) : newProblemClause(s, clause, flags);
		}
		else {
			// add implicit short rep
			s.add(clause);
		}
		if ((x & (status_unit|status_unsat)) != 0) {
			Antecedent ante(ret.local);
			if (!ret.local){ ante = clause.size == 3 ? Antecedent(~clause.lits[1], ~clause.lits[2]) : Antecedent(~clause.lits[1]); }
			ret.status = s.force(clause.lits[0], s.level(clause.lits[1].var()), ante) ? status_unit : status_unsat;
		}
		return ret;
	}
	s.add(clause);
	return Result(0, !s.hasConflict() ? status_unit : status_unsat);
}

ClauseCreator::Result ClauseCreator::create(Solver& s, LitVec& lits, uint32 flags, const ConstraintInfo& extra) {
	return create_prepared(s, prepare(s, lits, flags, extra), flags);
}

ClauseCreator::Result ClauseCreator::create(Solver& s, const ClauseRep& rep, uint32 flags) {
	return create_prepared(s, (rep.prep == 0 && (flags & clause_no_prepare) == 0
		? prepare(s, rep.lits, rep.size, rep.info, flags, rep.lits)
		: ClauseRep::prepared(rep.lits, rep.size, rep.info)), flags);
}

ClauseCreator::Result ClauseCreator::integrate(Solver& s, SharedLiterals* clause, uint32 modeFlags, ConstraintType t) {
	assert(!s.hasConflict() && "ClauseCreator::integrate() - precondition violated!");
	Detail::Sink shared( (modeFlags & clause_no_release) == 0 ? clause : 0);
	// determine state of clause
	Literal temp[Clause::MAX_SHORT_LEN]; temp[0] = temp[1] = lit_false();
	ClauseRep x    = prepare(s, clause->begin(), clause->size(), ConstraintInfo(t), 0, temp, Clause::MAX_SHORT_LEN);
	uint32 impSize = (modeFlags & clause_explicit) != 0 || !s.allowImplicit(x) ? 1 : 3;
	Status xs      = status(s, x);
	if (ignoreClause(s, x, xs, modeFlags)) {
		return Result(0, xs);
	}
	Result result(0, xs);
	if ((modeFlags & clause_no_heuristic) == 0) { s.heuristic()->newConstraint(s, clause->begin(), clause->size(), t); }
	if (x.size > Clause::MAX_SHORT_LEN && s.sharedContext()->physicalShare(t)) {
		result.local  = Clause::newShared(s, clause, x.info, temp, shared.clause == 0);
		shared.clause = 0;
	}
	else if (x.size > impSize) {
		result.local  = x.size <= Clause::MAX_SHORT_LEN ? Clause::newClause(s, x) : newUnshared(s, clause, temp, x.info);
	}
	else {
		// unary clause or implicitly shared via binary/ternary implication graph;
		// only check for implication/conflict but do not create
		// a local representation for the clause
		s.stats.addLearnt(x.size, x.info.type());
		modeFlags |= clause_no_add;
	}
	if ((modeFlags & clause_no_add) == 0) { s.addLearnt(result.local, x.size, x.info.type()); }
	if ((xs & (status_unit|status_unsat)) != 0) {
		Antecedent ante = result.local ? Antecedent(result.local) : Antecedent(~temp[1], ~temp[2]);
		uint32 impLevel = s.level(temp[1].var());
		result.status   = s.force(temp[0], impLevel, ante) ? status_unit : status_unsat;
		if (result.local && (modeFlags & clause_int_lbd) != 0) {
			uint32 lbd = s.countLevels(clause->begin(), clause->end());
			result.local->resetScore(makeScore(x.info.activity(), lbd));
		}
	}
	return result;
}
ClauseCreator::Result ClauseCreator::integrate(Solver& s, SharedLiterals* clause, uint32 modeFlags) {
	return integrate(s, clause, modeFlags, clause->type());
}
/////////////////////////////////////////////////////////////////////////////////////////
// Clause
/////////////////////////////////////////////////////////////////////////////////////////
void* Clause::alloc(Solver& s, uint32 lits, bool learnt) {
	if (lits <= Clause::MAX_SHORT_LEN) {
		if (learnt) { s.addLearntBytes(32); }
		return s.allocSmall();
	}
	uint32 extra = std::max((uint32)ClauseHead::HEAD_LITS, lits) - ClauseHead::HEAD_LITS;
	uint32 bytes = sizeof(Clause) + (extra)*sizeof(Literal);
	if (learnt) { s.addLearntBytes(bytes); }
	return Detail::alloc(bytes);
}

ClauseHead* Clause::newClause(void* mem, Solver& s, const ClauseRep& rep) {
	assert(rep.size >= 2 && mem);
	return new (mem) Clause(s, rep);
}

ClauseHead* Clause::newShared(Solver& s, SharedLiterals* shared_lits, const InfoType& e, const Literal* lits, bool addRef) {
	return mt::SharedLitsClause::newClause(s, shared_lits, e, lits, addRef);
}

ClauseHead* Clause::newContractedClause(Solver& s, const ClauseRep& rep, uint32 tailStart, bool extend) {
	assert(rep.size >= 2);
	if (extend) { std::stable_sort(rep.lits+tailStart, rep.lits+rep.size, Detail::GreaterLevel(s)); }
	return new (alloc(s, rep.size, rep.info.learnt())) Clause(s, rep, tailStart, extend);
}
void ClauseHead::Local::init(uint32 sz) {
	std::memset(mem, 0, sizeof(mem));
	if (sz > ClauseHead::MAX_SHORT_LEN) { mem[0] = (sz << 3) + 1; }
	assert(isSmall() == (sz <= ClauseHead::MAX_SHORT_LEN));
}
Clause::Clause(Solver& s, const ClauseRep& rep, uint32 tail, bool extend)
	: ClauseHead(rep.info) {
	assert(tail >= rep.size || s.isFalse(rep.lits[tail]));
	local_.init(rep.size);
	if (!isSmall()) {
		// copy literals
		std::memcpy(head_, rep.lits, rep.size*sizeof(Literal));
		tail = std::max(tail, (uint32)ClauseHead::HEAD_LITS);
		if (tail < rep.size) {       // contracted clause
			head_[rep.size-1].flag();  // mark last literal of clause
			Literal t = head_[tail];
			if (s.level(t.var()) > 0) {
				local_.markContracted();
				if (extend) {
					s.addUndoWatch(s.level(t.var()), this);
				}
			}
			local_.setSize(tail);
		}
	}
	else {
		std::memcpy(head_, rep.lits, std::min(rep.size, (uint32)ClauseHead::HEAD_LITS)*sizeof(Literal));
		small()[0] = rep.size > ClauseHead::HEAD_LITS   ? rep.lits[ClauseHead::HEAD_LITS]   : lit_false();
		small()[1] = rep.size > ClauseHead::HEAD_LITS+1 ? rep.lits[ClauseHead::HEAD_LITS+1] : lit_false();
		assert(isSmall() && Clause::size() == rep.size);
	}
	attach(s);
}

Clause::Clause(Solver& s, const Clause& other) : ClauseHead(other.info_) {
	uint32 oSize = other.size();
	local_.init(oSize);
	if      (!isSmall())      { std::memcpy(head_, other.head_, oSize*sizeof(Literal)); }
	else if (other.isSmall()) { std::memcpy(&local_, &other.local_, (ClauseHead::MAX_SHORT_LEN+1)*sizeof(Literal)); }
	else { // this is small, other is not
		std::memcpy(head_, other.head_, ClauseHead::HEAD_LITS*sizeof(Literal));
		std::memcpy(&local_, other.head_+ClauseHead::HEAD_LITS, 2*sizeof(Literal));
	}
	attach(s);
}

Constraint* Clause::cloneAttach(Solver& other) {
	assert(!learnt());
	return new (alloc(other, Clause::size(), false)) Clause(other, *this);
}
Literal* Clause::small()          { return static_cast(static_cast(&local_)); }
bool Clause::contracted()   const { return local_.contracted(); }
bool Clause::isSmall()      const { return local_.isSmall(); }
bool Clause::strengthened() const { return local_.strengthened(); }
void Clause::destroy(Solver* s, bool detachFirst) {
	if (s) {
		if (detachFirst) { Clause::detach(*s); }
		if (learnt())    { s->freeLearntBytes(computeAllocSize()); }
	}
	void* mem   = static_cast(this);
	bool  small = isSmall();
	this->~Clause();
	if (!small) { Detail::free(mem); }
	else if (s) { s->freeSmall(mem); }
}

void Clause::detach(Solver& s) {
	if (contracted()) {
		Literal* eoc = end();
		if (s.isFalse(*eoc) && s.level(eoc->var()) != 0) {
			s.removeUndoWatch(s.level(eoc->var()), this);
		}
	}
	ClauseHead::detach(s);
}

uint32 Clause::computeAllocSize() const {
	if (isSmall()) { return 32; }
	uint32 rt = sizeof(Clause) - (ClauseHead::HEAD_LITS*sizeof(Literal));
	uint32 sz = local_.size();
	uint32 nw = contracted() + strengthened();
	if (nw != 0u) {
		const Literal* eoc = head_ + sz;
		do { nw -= eoc++->flagged(); } while (nw);
		sz = static_cast(eoc - head_);
	}
	return rt + (sz*sizeof(Literal));
}

bool Clause::updateWatch(Solver& s, uint32 pos) {
	Literal* it;
	if (!isSmall()) {
		for (Literal* begin = head_ + ClauseHead::HEAD_LITS, *end = this->end(), *first = begin + local_.mem[1];;) {
			for (it = first; it < end; ++it) {
				if (!s.isFalse(*it)) {
					std::swap(*it, head_[pos]);
					local_.mem[1] = static_cast(++it - begin);
					return true;
				}
			}
			if (first == begin) { break; }
			end = first;
			first = begin;
		}
	}
	else if (!s.isFalse(*(it = this->small())) || !s.isFalse(*++it)) {
		std::swap(head_[pos], *it);
		return true;
	}
	return false;
}
Clause::LitRange Clause::tail() {
	if (!isSmall()) { return LitRange(head_+ClauseHead::HEAD_LITS, end()); }
	Literal* tBeg = small(), *tEnd = tBeg;
	if (*tEnd != lit_false()) ++tEnd;
	if (*tEnd != lit_false()) ++tEnd;
	return LitRange(tBeg, tEnd);
}
void Clause::reason(Solver& s, Literal p, LitVec& out) {
	out.push_back(~head_[p == head_[0]]);
	if (!isSentinel(head_[2])) {
		out.push_back(~head_[2]);
		LitRange t = tail();
		for (const Literal* r = t.first; r != t.second; ++r) {
			out.push_back(~*r);
		}
		if (contracted()) {
			const Literal* r = t.second;
			do { out.push_back(~*r); } while (!r++->flagged());
		}
	}
	if (learnt()) {
		s.updateOnReason(info_.score(), p, out);
	}
}

bool Clause::minimize(Solver& s, Literal p, CCMinRecursive* rec) {
	s.updateOnMinimize(info_.score());
	uint32 other = p == head_[0];
	if (!s.ccMinimize(~head_[other], rec) || !s.ccMinimize(~head_[2], rec)) { return false; }
	LitRange t = tail();
	for (const Literal* r = t.first; r != t.second; ++r) {
		if (!s.ccMinimize(~*r, rec)) { return false; }
	}
	if (contracted()) {
		do {
			if (!s.ccMinimize(~*t.second, rec)) { return false; }
		} while (!t.second++->flagged());
	}
	return true;
}

bool Clause::isReverseReason(const Solver& s, Literal p, uint32 maxL, uint32 maxN) {
	uint32 other   = p == head_[0];
	if (!isRevLit(s, head_[other], maxL) || !isRevLit(s, head_[2], maxL)) { return false; }
	uint32 notSeen = !s.seen(head_[other].var()) + !s.seen(head_[2].var());
	LitRange t     = tail();
	for (const Literal* r = t.first; r != t.second && notSeen <= maxN; ++r) {
		if (!isRevLit(s, *r, maxL)) { return false; }
		notSeen += !s.seen(r->var());
	}
	if (contracted()) {
		const Literal* r = t.second;
		do { notSeen += !s.seen(r->var()); } while (notSeen <= maxN && !r++->flagged());
	}
	return notSeen <= maxN;
}

bool Clause::simplify(Solver& s, bool reinit) {
	assert(s.decisionLevel() == 0 && s.queueSize() == 0);
	if (ClauseHead::satisfied(s)) {
		detach(s);
		return true;
	}
	LitRange t = tail();
	Literal* it= t.first - !isSmall(), *j;
	// skip free literals
	while (it != t.second && s.value(it->var()) == value_free) { ++it; }
	// copy remaining free literals
	for (j = it; it != t.second; ++it) {
		if      (s.value(it->var()) == value_free) { *j++ = *it; }
		else if (s.isTrue(*it)) { Clause::detach(s); return true;}
	}
	// replace any false lits with sentinels
	for (Literal* r = j; r != t.second; ++r) { *r = lit_false(); }
	if (!isSmall()) {
		uint32 size = std::max((uint32)ClauseHead::HEAD_LITS, static_cast(j-head_));
		local_.setSize(size);
		local_.clearIdx();
		if (j != t.second && learnt() && !strengthened()) {
			// mark last literal so that we can recompute alloc size later
			t.second[-1].flag();
			local_.markStrengthened();
		}
		if (reinit && size > 3) {
			detach(s);
			std::random_shuffle(head_, j, s.rng);
			attach(s);
		}
	}
	else if (s.isFalse(head_[2])) {
		head_[2]   = t.first[0];
		t.first[0] = t.first[1];
		t.first[1] = lit_false();
		--j;
	}
	return j <= t.first && ClauseHead::toImplication(s);
}

uint32 Clause::isOpen(const Solver& s, const TypeSet& x, LitVec& freeLits) {
	if (!x.inSet(ClauseHead::type()) || ClauseHead::satisfied(s)) {
		return 0;
	}
	assert(s.queueSize() == 0 && "Watches might be false!");
	freeLits.push_back(head_[0]);
	freeLits.push_back(head_[1]);
	if (!s.isFalse(head_[2])) freeLits.push_back(head_[2]);
	ValueRep v;
	LitRange t = tail();
	for (Literal* r = t.first; r != t.second; ++r) {
		if ( (v = s.value(r->var())) == value_free) {
			freeLits.push_back(*r);
		}
		else if (v == trueValue(*r)) {
			std::swap(head_[2], *r);
			return 0;
		}
	}
	return ClauseHead::type();
}

void Clause::undoLevel(Solver& s) {
	assert(!isSmall());
	uint32   t = local_.size();
	uint32  ul = s.jumpLevel();
	Literal* r = head_+t;
	while (!r->flagged() && (s.value(r->var()) == value_free || s.level(r->var()) > ul)) {
		++t;
		++r;
	}
	if (r->flagged() || s.level(r->var()) == 0) {
		r->unflag();
		t += !isSentinel(*r);
		local_.clearContracted();
	}
	else {
		s.addUndoWatch(s.level(r->var()), this);
	}
	local_.setSize(t);
}

void Clause::toLits(LitVec& out) const {
	out.insert(out.end(), head_, (head_+ClauseHead::HEAD_LITS)-isSentinel(head_[2]));
	LitRange t = const_cast(*this).tail();
	if (contracted()) { while (!t.second++->flagged()) {;} }
	out.insert(out.end(), t.first, t.second);
}

ClauseHead::BoolPair Clause::strengthen(Solver& s, Literal p, bool toShort) {
	LitRange t  = tail();
	Literal* eoh= head_+ClauseHead::HEAD_LITS;
	Literal* eot= t.second;
	Literal* it = std::find(head_, eoh, p);
	BoolPair ret(false, false);
	if (it != eoh) {
		if (it != head_+2) { // update watch
			*it = head_[2];
			s.removeWatch(~p, this);
			Literal* best = it, *n;
			for (n = t.first; n != eot && s.isFalse(*best); ++n) {
				if (!s.isFalse(*n) || s.level(n->var()) > s.level(best->var())) {
					best = n;
				}
			}
			std::swap(*it, *best);
			s.addWatch(~*it, ClauseWatch(this));
			it = head_+2;
		}
		// replace cache literal with literal from tail
		if ((*it  = *t.first) != lit_false()) {
			eot     = removeFromTail(s, t.first, eot);
		}
		ret.first = true;
	}
	else if ((it = std::find(t.first, eot, p)) != eot) {
		eot       = removeFromTail(s, it, eot);
		ret.first = true;
	}
	else if (contracted()) {
		for (; *it != p && !it->flagged(); ++it) { ; }
		ret.first = *it == p;
		eot       = *it == p ? removeFromTail(s, it, eot) : it + 1;
	}
	if (ret.first && ~p == s.tagLiteral()) {
		clearTagged();
	}
	ret.second = toShort && eot == t.first && toImplication(s);
	return ret;
}

Literal* Clause::removeFromTail(Solver& s, Literal* it, Literal* end) {
	assert(it != end || contracted());
	if (!contracted()) {
		*it  = *--end;
		*end = lit_false();
		if (!isSmall()) {
			local_.setSize(local_.size()-1);
			local_.clearIdx();
		}
	}
	else {
		uint32 uLev  = s.level(end->var());
		Literal* j   = it;
		while ( !j->flagged() ) { *j++ = *++it; }
		*j           = lit_false();
		uint32 nLev  = s.level(end->var());
		if (uLev != nLev && s.removeUndoWatch(uLev, this) && nLev != 0) {
			s.addUndoWatch(nLev, this);
		}
		if (j != end) { (j-1)->flag(); }
		else          { local_.clearContracted(); }
		end = j;
	}
	if (learnt() && !isSmall() && !strengthened()) {
		end->flag();
		local_.markStrengthened();
	}
	return end;
}
uint32 Clause::size() const {
	LitRange t = const_cast(*this).tail();
	return !isSentinel(head_[2])
		? 3u + static_cast(t.second - t.first)
		: 2u;
}
/////////////////////////////////////////////////////////////////////////////////////////
// mt::SharedLitsClause
/////////////////////////////////////////////////////////////////////////////////////////
namespace mt {
ClauseHead* SharedLitsClause::newClause(Solver& s, SharedLiterals* shared_lits, const InfoType& e, const Literal* lits, bool addRef) {
	return new (s.allocSmall()) SharedLitsClause(s, shared_lits, lits, e, addRef);
}

SharedLitsClause::SharedLitsClause(Solver& s, SharedLiterals* shared_lits, const Literal* w, const InfoType& e, bool addRef)
	: ClauseHead(e) {
	static_assert(sizeof(SharedLitsClause) <= 32, "Unsupported Padding");
	shared_ = addRef ? shared_lits->share() : shared_lits;
	std::memcpy(head_, w, std::min((uint32)ClauseHead::HEAD_LITS, shared_lits->size())*sizeof(Literal));
	attach(s);
	if (learnt()) { s.addLearntBytes(32); }
}

Constraint* SharedLitsClause::cloneAttach(Solver& other) {
	return SharedLitsClause::newClause(other, shared_, InfoType(this->type()), head_);
}

bool SharedLitsClause::updateWatch(Solver& s, uint32 pos) {
	Literal  other = head_[1^pos];
	for (const Literal* r = shared_->begin(), *end = shared_->end(); r != end; ++r) {
		// at this point we know that head_[2] is false so we only need to check
		// that we do not watch the other watched literal twice!
		if (!s.isFalse(*r) && *r != other) {
			head_[pos] = *r; // replace watch
			// try to replace cache literal
			switch( std::min(static_cast(8), static_cast(end-r)) ) {
				case 8: if (!s.isFalse(*++r) && *r != other) { head_[2] = *r; return true; }
				case 7: if (!s.isFalse(*++r) && *r != other) { head_[2] = *r; return true; }
				case 6: if (!s.isFalse(*++r) && *r != other) { head_[2] = *r; return true; }
				case 5: if (!s.isFalse(*++r) && *r != other) { head_[2] = *r; return true; }
				case 4: if (!s.isFalse(*++r) && *r != other) { head_[2] = *r; return true; }
				case 3: if (!s.isFalse(*++r) && *r != other) { head_[2] = *r; return true; }
				case 2: if (!s.isFalse(*++r) && *r != other) { head_[2] = *r; return true; }
				default: return true;
			}
		}
	}
	return false;
}

void SharedLitsClause::reason(Solver& s, Literal p, LitVec& out) {
	for (const Literal* r = shared_->begin(), *end = shared_->end(); r != end; ++r) {
		assert(s.isFalse(*r) || *r == p);
		if (*r != p) { out.push_back(~*r); }
	}
	if (learnt()) {
		s.updateOnReason(info_.score(), p, out);
	}
}

bool SharedLitsClause::minimize(Solver& s, Literal p, CCMinRecursive* rec) {
	s.updateOnMinimize(info_.score());
	for (const Literal* r = shared_->begin(), *end = shared_->end(); r != end; ++r) {
		if (*r != p && !s.ccMinimize(~*r, rec)) { return false; }
	}
	return true;
}

bool SharedLitsClause::isReverseReason(const Solver& s, Literal p, uint32 maxL, uint32 maxN) {
	uint32 notSeen = 0;
	for (const Literal* r = shared_->begin(), *end = shared_->end(); r != end; ++r) {
		if (*r == p) continue;
		if (!isRevLit(s, *r, maxL)) return false;
		if (!s.seen(r->var()) && ++notSeen > maxN) return false;
	}
	return true;
}

bool SharedLitsClause::simplify(Solver& s, bool reinit) {
	if (ClauseHead::satisfied(s)) {
		detach(s);
		return true;
	}
	uint32 optSize = shared_->simplify(s);
	if (optSize == 0) {
		detach(s);
		return true;
	}
	else if (optSize <= Clause::MAX_SHORT_LEN) {
		Literal lits[Clause::MAX_SHORT_LEN];
		Literal* j = lits;
		for (const Literal* r = shared_->begin(), *e = shared_->end(); r != e; ++r) {
			if (!s.isFalse(*r)) *j++ = *r;
		}
		// safe extra data
		InfoType myInfo = info_;
		// detach & destroy but do not release memory
		detach(s);
		SharedLitsClause::destroy(0, false);
		// construct short clause in "this"
		ClauseHead* h = Clause::newClause(this, s, ClauseRep::prepared(lits, static_cast(j-lits), myInfo));
		return h->simplify(s, reinit);
	}
	else if (s.isFalse(head_[2])) {
		// try to replace cache lit with non-false literal
		for (const Literal* r = shared_->begin(), *e = shared_->end(); r != e; ++r) {
			if (!s.isFalse(*r) && std::find(head_, head_+2, *r) == head_+2) {
				head_[2] = *r;
				break;
			}
		}
	}
	return false;
}

void SharedLitsClause::destroy(Solver* s, bool detachFirst) {
	if (s) {
		if (detachFirst) { ClauseHead::detach(*s); }
		if (learnt())    { s->freeLearntBytes(32); }
	}
	shared_->release();
	void* mem = this;
	this->~SharedLitsClause();
	if (s) { s->freeSmall(mem); }
}

uint32 SharedLitsClause::isOpen(const Solver& s, const TypeSet& x, LitVec& freeLits) {
	if (!x.inSet(ClauseHead::type()) || ClauseHead::satisfied(s)) {
		return 0;
	}
	Literal* head = head_;
	ValueRep v;
	for (const Literal* r = shared_->begin(), *end = shared_->end(); r != end; ++r) {
		if ( (v = s.value(r->var())) == value_free ) {
			freeLits.push_back(*r);
		}
		else if (v == trueValue(*r)) {
			head[2] = *r; // remember as cache literal
			return 0;
		}
	}
	return ClauseHead::type();
}

void SharedLitsClause::toLits(LitVec& out) const {
	out.insert(out.end(), shared_->begin(), shared_->end());
}

ClauseHead::BoolPair SharedLitsClause::strengthen(Solver&, Literal, bool) {
	return BoolPair(false, false);
}

uint32 SharedLitsClause::size() const { return shared_->size(); }
} // end namespace mt

/////////////////////////////////////////////////////////////////////////////////////////
// LoopFormula
/////////////////////////////////////////////////////////////////////////////////////////
LoopFormula* LoopFormula::newLoopFormula(Solver& s, const ClauseRep& c1, const Literal* atoms, uint32 nAtoms, bool heu) {
	uint32 bytes = sizeof(LoopFormula) + (c1.size + nAtoms + 2) * sizeof(Literal);
	void* mem = Detail::alloc(bytes);
	s.addLearntBytes(bytes);
	return new (mem)LoopFormula(s, c1, atoms, nAtoms, heu);
}
LoopFormula::LoopFormula(Solver& s, const ClauseRep& c1, const Literal* atoms, uint32 nAtoms, bool heu) {
	act_ = c1.info.score();
	lits_[0] = lit_true(); // Starting sentinel
	std::memcpy(lits_ + 1, c1.lits, c1.size * sizeof(Literal));
	lits_[end_ = c1.size + 1] = lit_true(); // Ending sentinel
	s.addWatch(~lits_[2], this, (2 << 1) + 1);
	lits_[2].flag();
	size_  = c1.size + nAtoms + 2;
	str_   = 0;
	xPos_  = 1;
	other_ = 1;
	for (uint32 i = 0, x = end_ + 1; i != nAtoms; ++i, ++x) {
		act_.bumpActivity();
		s.addWatch(~(lits_[x] = atoms[i]), this, (1 << 1) + 1);
		if (heu) {
			lits_[1] = atoms[i];
			s.heuristic()->newConstraint(s, lits_ + 1, c1.size, Constraint_t::Loop);
		}
	}
	(lits_[1] = c1.lits[0]).flag();
}
void LoopFormula::destroy(Solver* s, bool detach) {
	if (s) {
		if (detach) { this->detach(*s); }
		if (str_)   { while (lits_[size_++].rep() != 3u) { ; } }
		s->freeLearntBytes(sizeof(LoopFormula) + (size_ * sizeof(Literal)));
	}
	void* mem = static_cast(this);
	this->~LoopFormula();
	Detail::free(mem);
}
void LoopFormula::detach(Solver& s) {
	for (Literal* it = begin() + xPos_; !isSentinel(*it); ++it) {
		if (it->flagged()) { s.removeWatch(~*it, this); it->unflag(); }
	}
	for (Literal* it = xBegin(), *end = xEnd(); it != end; ++it) {
		s.removeWatch(~*it, this);
	}
}
bool LoopFormula::otherIsSat(const Solver& s) {
	if (other_ != xPos_)          { return s.isTrue(lits_[other_]); }
	if (!s.isTrue(lits_[other_])) { return false; }
	for (Literal* it = xBegin(), *end = xEnd(); it != end; ++it) {
		if (!s.isTrue(*it)) {
			if (lits_[xPos_].flagged()){ (lits_[xPos_] = *it).flag(); }
			else                       { lits_[xPos_] = *it; }
			return false;
		}
	}
	return true;
}
Constraint::PropResult LoopFormula::propagate(Solver& s, Literal p, uint32& data) {
	if (otherIsSat(s)) { // already satisfied?
		return PropResult(true, true);
	}
	uint32 idx = data >> 1;
	Literal* w = lits_ + idx;
	bool  head = idx == xPos_;
	if (head) { // p is one of the atoms - move to active part
		p = ~p;
		if (*w != p && s.isFalse(*w)) { return PropResult(true, true); }
		if (!w->flagged())            { *w = p; return PropResult(true, true); }
		(*w = p).flag();
	}
	for (int bounds = 0, dir = ((data & 1) << 1) - 1;;) {
		// search non-false literal - sentinels guarantee termination
		for (w += dir; s.isFalse(*w); w += dir) {;}
		if (!isSentinel(*w)) {
			uint32 nIdx = static_cast(w - lits_);
			// other watched literal?
			if (w->flagged()) { other_ = nIdx; continue; }
			// replace watch
			lits_[idx].unflag();
			w->flag();
			// add new watch only w is not one of the atoms
			// and keep previous watch if p is one of the atoms
			if (nIdx != xPos_) { s.addWatch(~*w, this, (nIdx << 1) + (dir==1)); }
			return PropResult(true, head);
		}
		else if (++bounds == 1) {
			w     = lits_ + idx; // Halfway through, restart search, but
			dir  *= -1;          // this time walk in the opposite direction.
			data ^= 1;           // Save new direction of watch
		}
		else { // clause is unit
			bool ok = s.force(lits_[other_], this);
			if (other_ == xPos_ && ok) { // all lits in inactive part are implied
				for (Literal* it = xBegin(), *end = xEnd(); it != end && (ok = s.force(*it, this)) == true; ++it) { ; }
			}
			return PropResult(ok, true);
		}
	}
}
void LoopFormula::reason(Solver& s, Literal p, LitVec& lits) {
	// p = body: all literals in active clause
	// p = atom: only bodies
	for (Literal* it = begin() + (other_ == xPos_); !isSentinel(*it); ++it) {
		if (*it != p) { lits.push_back(~*it); }
	}
	s.updateOnReason(act_, p, lits);
}
bool LoopFormula::minimize(Solver& s, Literal p, CCMinRecursive* rec) {
	s.updateOnMinimize(act_);
	for (Literal* it = begin() + (other_ == xPos_); !isSentinel(*it); ++it) {
		if (*it != p && !s.ccMinimize(~*it, rec)) { return false; }
	}
	return true;
}
uint32 LoopFormula::size() const {
	return size_ - (2 + xPos_);
}
bool LoopFormula::locked(const Solver& s) const {
	if (other_ != xPos_ || !s.isTrue(lits_[other_])) {
		return s.isTrue(lits_[other_]) && s.reason(lits_[other_]) == this;
	}
	LoopFormula& self = const_cast(*this);
	for (const Literal* it = self.xBegin(), *end = self.xEnd(); it != end; ++it) {
		if (s.isTrue(*it) && s.reason(*it) == this) { return true; }
	}
	return false;
}
uint32 LoopFormula::isOpen(const Solver& s, const TypeSet& xs, LitVec& freeLits) {
	if (!xs.inSet(Constraint_t::Loop) || otherIsSat(s)) {
		return 0;
	}
	for (Literal* it = begin() + xPos_; !isSentinel(*it); ++it) {
		if      (s.value(it->var()) == value_free) { freeLits.push_back(*it); }
		else if (s.isTrue(*it))                    { other_ = static_cast(it-lits_); return 0; }
	}
	for (Literal* it = xBegin(), *end = xEnd(); it != end; ++it) {
		if (s.value(it->var()) == value_free) { freeLits.push_back(*it); }
	}
	return Constraint_t::Loop;
}
bool LoopFormula::simplify(Solver& s, bool) {
	if (otherIsSat(s) || (other_ != xPos_ && (other_ = xPos_) != 0 && otherIsSat(s))) {
		detach(s);
		return true;
	}
	Literal* it = begin(), *j, *end = xEnd();
	while (s.value(it->var()) == value_free) { ++it; }
	if (!isSentinel(*(j=it))) {
		// simplify active clause
		if (*it == lits_[xPos_]){ xPos_ = 0; }
		for (GenericWatch* w; !isSentinel(*it); ++it) {
			if (s.value(it->var()) == value_free) {
				if (it->flagged() && (w = s.getWatch(~*it, this)) != 0) {
					w->data = (static_cast(j - lits_) << 1) + (w->data&1);
				}
				*j++ = *it;
			}
			else if (s.isTrue(*it)) { detach(s); return true; }
			else                    { assert(!it->flagged() && "Constraint not propagated!"); }
		}
		*j   = lit_true();
		end_ = static_cast(j - lits_);
	}
	// simplify extra part
	for (++it, ++j; it != end; ++it) {
		if (s.value(it->var()) == value_free && xPos_) { *j++ = *it; }
		else { s.removeWatch(~*it, this); }
	}
	bool isClause = static_cast(j - xBegin()) == 1;
	if (isClause) { --j; }
	if (j != end) { // size changed?
		if (!str_)   { (end-1)->rep() = 3u; str_ = 1u; }
		if (isClause){
			assert(xPos_ && *j == lits_[xPos_]);
			if (!lits_[xPos_].flagged()) { s.removeWatch(~*j, this); }
			xPos_ = 0;
		}
		size_ = static_cast((end = j) - lits_);
	}
	assert(!isClause || xPos_ == 0);
	other_ = xPos_ + 1;
	ClauseRep act = ClauseRep::create(begin(), end_ - 1, Constraint_t::Loop);
	if (act.isImp() && s.allowImplicit(act)) {
		detach(s);
		ClauseCreator::Result res;
		for (it = xBegin(); it != end && res.ok() && !res.local; ++it) {
			lits_[xPos_] = *it;
			res = ClauseCreator::create(s, act, ClauseCreator::clause_no_add);
			CLASP_FAIL_IF(lits_[xPos_] != *it, "LOOP MUST NOT CONTAIN ASSIGNED VARS!");
		}
		if (!xPos_) { res = ClauseCreator::create(s, act, ClauseCreator::clause_no_add); }
		CLASP_FAIL_IF(!res.ok() || res.local, "LOOP MUST NOT CONTAIN AUX VARS!");
		return true;
	}
	return false;
}

}
clasp-3.2.2/libclasp/src/clingo.cpp000066400000000000000000000265601304134206100171620ustar00rootroot00000000000000//
// Copyright (c) 2015-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
namespace Clasp { namespace {
	template 
	struct Scoped {
		Scoped(L* lock, O* obj, const OP& op = OP()) : lock_(lock), obj_(obj), op_(op) { if (lock) (lock->*enter)(); }
		~Scoped() { if (lock_) (lock_->*exit)(); }
		O* operator->() const { op_(); return obj_; }
		L* lock_;
		O* obj_;
		OP op_;
	};
	struct Nop { void operator()() const {} };
	struct Inc { Inc(LitVec::size_type& e) : epoch_(&e) {} void operator()() const { ++*epoch_; } LitVec::size_type* epoch_; };
	typedef Scoped ScopedLock;
	typedef Scoped ScopedUnlock;
}
ClingoPropagatorLock::~ClingoPropagatorLock() {}
/////////////////////////////////////////////////////////////////////////////////////////
// ClingoPropagator::Control
/////////////////////////////////////////////////////////////////////////////////////////
class ClingoPropagator::Control : public Potassco::AbstractSolver, Potassco::AbstractAssignment {
public:
	Control(ClingoPropagator& ctx, Solver& s, uint32 st = 0u) : ctx_(&ctx), s_(&s), state_(st | state_ctrl) {}
	const AbstractAssignment& assignment() const { return *this; }
	// AbstractAssignment
	virtual bool     hasConflict()     const { return s_->hasConflict(); }
	virtual uint32_t level()           const { return s_->decisionLevel(); }
	virtual bool     hasLit(Lit_t lit) const { return s_->validVar(decodeVar(lit)); }
	virtual Value_t  value(Lit_t lit)  const {
		CLASP_ASSERT_CONTRACT_MSG(Control::hasLit(lit), "Invalid literal");
		switch (s_->value(decodeVar(lit))) {
			default: return Value_t::Free;
			case value_true:  return lit >= 0 ? Value_t::True  : Value_t::False;
			case value_false: return lit >= 0 ? Value_t::False : Value_t::True;
		}
	}
	virtual uint32_t level(Lit_t lit)  const { return Control::value(lit) != Potassco::Value_t::Free ? s_->level(decodeVar(lit)) : UINT32_MAX; }
	virtual Lit_t    decision(uint32_t dl) const {
		CLASP_ASSERT_CONTRACT_MSG(dl <= s_->decisionLevel(), "Invalid decision level");
		return encodeLit(dl ? s_->decision(dl) : lit_true());
	}

	// Potassco::AbstractSolver
	virtual Potassco::Id_t id() const { return s_->id(); }
	virtual bool addClause(const Potassco::LitSpan& clause, Potassco::Clause_t prop);
	virtual bool propagate();
	virtual Lit  addVariable();
	virtual bool hasWatch(Lit lit) const;
	virtual void addWatch(Lit lit);
	virtual void removeWatch(Lit lit);
protected:
	typedef ClingoPropagator::State State;
	ClingoPropagator* ctx_;
	Solver*           s_;
	uint32            state_;
};
bool ClingoPropagator::Control::addClause(const Potassco::LitSpan& clause, Potassco::Clause_t prop) {
	CLASP_ASSERT_CONTRACT_MSG(!s_->hasConflict(), "Invalid addClause() on conflicting assignment");
	ScopedUnlock pp(ctx_->lock_, ctx_);
	pp->toClause(*s_, clause, prop);
	return pp->addClause(*s_, state_);
}
bool ClingoPropagator::Control::propagate() {
	ScopedUnlock unlocked(ctx_->lock_, ctx_);
	if (s_->hasConflict())    { return false; }
	if (s_->queueSize() == 0) { return true;  }
	ClingoPropagator::size_t epoch = ctx_->epoch_;
	return (state_ & state_prop) != 0u && s_->propagateUntil(unlocked.obj_) && epoch == ctx_->epoch_;
}
Potassco::Lit_t ClingoPropagator::Control::addVariable() {
	CLASP_ASSERT_CONTRACT_MSG(!s_->hasConflict(), "Invalid addVariable() on conflicting assignment");
	ScopedUnlock unlocked(ctx_->lock_, ctx_);
	return encodeLit(posLit(s_->pushAuxVar()));
}
bool ClingoPropagator::Control::hasWatch(Lit_t lit) const {
	ScopedUnlock unlocked(ctx_->lock_, ctx_);
	return Control::hasLit(lit) && s_->hasWatch(decodeLit(lit), ctx_);
}
void ClingoPropagator::Control::addWatch(Lit_t lit) {
	ScopedUnlock unlocked(ctx_->lock_, ctx_);
	CLASP_ASSERT_CONTRACT_MSG(Control::hasLit(lit), "Invalid literal");
	Literal p = decodeLit(lit);
	if (!s_->hasWatch(p, ctx_)) {
		s_->addWatch(p, ctx_);
	}
}
void ClingoPropagator::Control::removeWatch(Lit_t lit) {
	ScopedUnlock unlocked(ctx_->lock_, ctx_);
	if (Control::hasLit(lit)) {
		s_->removeWatch(decodeLit(lit), ctx_);
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClingoPropagator
/////////////////////////////////////////////////////////////////////////////////////////
// flags for clauses from propagator
static const uint32 ccFlags_s[2] = {
	/* 0: learnt */ ClauseCreator::clause_not_sat | Clasp::ClauseCreator::clause_int_lbd,
	/* 1: static */ ClauseCreator::clause_no_add  | ClauseCreator::clause_explicit
};
ClingoPropagator::ClingoPropagator(const LitVec& watches, Potassco::AbstractPropagator& cb, ClingoPropagatorLock* ctrl)
	: watches_(watches)
	, call_(&cb)
	, lock_(ctrl)
	, init_(0), prop_(0), epoch_(0), level_(0) {
}
uint32 ClingoPropagator::priority() const { return static_cast(priority_class_general); }

void ClingoPropagator::destroy(Solver* s, bool detach) {
	destroyDB(db_, s, detach);
	PostPropagator::destroy(s, detach);
}

bool ClingoPropagator::init(Solver& s) {
	CLASP_ASSERT_CONTRACT_MSG(init_ <= watches_.size(), "Invalid watch list update");
	uint32 ignore = 0;
	for (size_t max = watches_.size(); init_ != max; ++init_) {
		Literal p = watches_[init_];
		if (s.value(p.var()) == value_free || s.level(p.var()) > s.rootLevel()) {
			s.addWatch(p, this, toU32(init_));
		}
		else if (s.isTrue(p)) {
			ClingoPropagator::propagate(s, p, ignore);
		}
	}
	return true;
}

Constraint::PropResult ClingoPropagator::propagate(Solver& s, Literal p, uint32&) {
	uint32 dl = s.decisionLevel();
	CLASP_ASSERT_CONTRACT_MSG(dl >= level_, "Stack property violated");
	if (dl != level_) { // remember start of new decision level
		s.addUndoWatch(level_ = dl, this);
		undo_.push_back(static_cast(trail_.size()));
	}
	trail_.push_back(encodeLit(p));
	return PropResult(true, true);
}
void ClingoPropagator::undoLevel(Solver& s) {
	CLASP_ASSERT_CONTRACT_MSG(s.decisionLevel() == level_, "Invalid undo");
	uint32 beg = undo_.back();
	undo_.pop_back();
	if (prop_ > beg) {
		Potassco::LitSpan change = Potassco::toSpan(&trail_[0] + beg, prop_ - beg);
		ScopedLock(lock_, call_, Inc(epoch_))->undo(Control(*this, s), change);
		prop_ = beg;
	}
	trail_.resize(beg);
	level_ = !trail_.empty() ? s.level(decodeLit(trail_.back()).var()) : 0;
}
bool ClingoPropagator::propagateFixpoint(Clasp::Solver& s, Clasp::PostPropagator*) {
	CLASP_ASSERT_CONTRACT_MSG(prop_ <= trail_.size(), "Invalid propagate");
	for (Control ctrl(*this, s, state_prop); prop_ != trail_.size();) {
		Potassco::LitSpan change = Potassco::toSpan(&trail_[0] + prop_, trail_.size() - prop_);
		prop_ = static_cast(trail_.size());
		ScopedLock(lock_, call_, Inc(epoch_))->propagate(ctrl, change);
		if (!addClause(s, state_prop) || (s.queueSize() && !s.propagateUntil(this))) {
			return false;
		}
	}
	return true;
}

void ClingoPropagator::toClause(Solver& s, const Potassco::LitSpan& clause, Potassco::Clause_t prop) {
	CLASP_ASSERT_CONTRACT_MSG(todo_.empty(), "Assignment not propagated");
	Literal max;
	LitVec& mem = todo_.mem;
	for (const Potassco::Lit_t* it = Potassco::begin(clause); it != Potassco::end(clause); ++it) {
		Literal p = decodeLit(*it);
		if (max < p) { max = p; }
		mem.push_back(p);
	}
	if (aux_ < max) { aux_ = max; }
	if ((Potassco::Clause_t::isVolatile(prop) || s.auxVar(max.var())) && !isSentinel(s.sharedContext()->stepLiteral())) {
		mem.push_back(~s.sharedContext()->stepLiteral());
	}
	todo_.clause = ClauseCreator::prepare(s, mem, Clasp::ClauseCreator::clause_force_simplify, Constraint_t::Other);
	todo_.flags  = ccFlags_s[int(Potassco::Clause_t::isStatic(prop))];
	if (mem.empty()) {
		mem.push_back(lit_false());
	}
}
bool ClingoPropagator::addClause(Solver& s, uint32 st) {
	if (s.hasConflict()) { todo_.clear(); return false; }
	if (todo_.empty())   { return true; }
	const ClauseRep& clause = todo_.clause;
	Literal first   = clause.size > 0 ? clause.lits[0] : lit_false();
	uint32 impLevel = clause.size > 1 ? ClauseCreator::watchOrder(s, clause.lits[1]) : 0;
	if (impLevel < s.decisionLevel() && s.isUndoLevel()) {
		if ((st & state_ctrl) != 0u) { return false; }
		if ((st & state_prop) != 0u) { ClingoPropagator::reset(); cancelPropagation(); }
		s.undoUntil(impLevel);
	}
	bool local = (todo_.flags & ClauseCreator::clause_no_add) != 0;
	if (!s.isFalse(first) || local || s.force(first, this)) {
		ClauseCreator::Result res = ClauseCreator::create(s, clause, todo_.flags);
		if (res.local && local) { db_.push_back(res.local); }
	}
	todo_.clear();
	return !s.hasConflict();
}

void ClingoPropagator::reason(Solver&, Literal p, LitVec& r) {
	if (!todo_.empty() && todo_.mem[0] == p) {
		for (LitVec::const_iterator it = todo_.mem.begin() + 1, end = todo_.mem.end(); it != end; ++it) {
			r.push_back(~*it);
		}
	}
}

bool ClingoPropagator::simplify(Solver& s, bool) {
	if (!s.validVar(aux_.var())) {
		ClauseDB::size_type i, j, end = db_.size();
		LitVec cc;
		Var last = s.numVars();
		aux_ = lit_true();
		for (i = j = 0; i != end; ++i) {
			db_[j++] = db_[i];
			ClauseHead* c = db_[i]->clause();
			if (c && c->aux()) {
				cc.clear();
				c->toLits(cc);
				Literal x = *std::max_element(cc.begin(), cc.end());
				if (x.var() > last) {
					c->destroy(&s, true);
					--j;
				}
				else if (aux_ < x) { aux_ = x; }
			}
		}
		db_.erase(db_.begin()+j, db_.end());
	}
	simplifyDB(s, db_, false);
	return false;
}

bool ClingoPropagator::isModel(Solver& s) {
	CLASP_ASSERT_CONTRACT_MSG(prop_ == trail_.size(), "Assignment not propagated");
	Control ctrl(*this, s);
	ScopedLock(lock_, call_, Inc(epoch_))->check(ctrl);
	return addClause(s, 0u) && s.numFreeVars() == 0 && s.queueSize() == 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClingoPropagatorInit
/////////////////////////////////////////////////////////////////////////////////////////
ClingoPropagatorInit::ClingoPropagatorInit(Potassco::AbstractPropagator& cb, ClingoPropagatorLock* lock) : prop_(&cb), lock_(lock) {}
ClingoPropagatorInit::~ClingoPropagatorInit()      {}
void ClingoPropagatorInit::prepare(SharedContext&) {}
bool ClingoPropagatorInit::addPost(Solver& s)      { return s.addPost(new ClingoPropagator(watches_, *prop_, lock_)); }
Potassco::Lit_t ClingoPropagatorInit::addWatch(Literal lit) {
	uint32 const word = lit.id() / 32;
	uint32 const bit  = lit.id() & 31;
	if (word >= seen_.size()) { seen_.resize(word + 1, 0); }
	if (!test_bit(seen_[word], bit)) {
		watches_.push_back(lit);
		store_set_bit(seen_[word], bit);
	}
	return encodeLit(lit);
}
}
clasp-3.2.2/libclasp/src/constraint.cpp000066400000000000000000000075121304134206100200670ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// Constraint
/////////////////////////////////////////////////////////////////////////////////////////
Constraint::Constraint()                  {}
Constraint::~Constraint()                 {}
void Constraint::destroy(Solver*, bool)   { delete this; }
ConstraintType Constraint::type() const   { return Constraint_t::Static; }
bool Constraint::simplify(Solver&, bool)  { return false; }
void Constraint::undoLevel(Solver&)       {}
uint32 Constraint::estimateComplexity(const Solver&) const { return 1;  }
bool Constraint::valid(Solver&)           { return true; }
ClauseHead* Constraint::clause()          { return 0; }
void Constraint::decreaseActivity()       {}
void Constraint::resetActivity()          {}
ConstraintScore Constraint::activity() const { return makeScore(); }
bool Constraint::locked(const Solver&) const { return true; }
uint32 Constraint::isOpen(const Solver&, const TypeSet&, LitVec&) { return 0; }
/////////////////////////////////////////////////////////////////////////////////////////
// PostPropagator
/////////////////////////////////////////////////////////////////////////////////////////
PostPropagator::PostPropagator() : next(0)           {}
PostPropagator::~PostPropagator()                    {}
bool PostPropagator::init(Solver&)                   { return true; }
void PostPropagator::reset()                         {}
bool PostPropagator::isModel(Solver& s)              { return valid(s); }
void PostPropagator::reason(Solver&, Literal, LitVec&) {}
Constraint::PropResult PostPropagator::propagate(Solver&, Literal, uint32&) {
	return PropResult(true, false);
}
void PostPropagator::cancelPropagation() {
	for (PostPropagator* n = this->next; n; n = n->next) { n->reset(); }
}
MessageHandler::MessageHandler() {}
/////////////////////////////////////////////////////////////////////////////////////////
// PropagatorList
/////////////////////////////////////////////////////////////////////////////////////////
PropagatorList::PropagatorList() : head_(0) {}
PropagatorList::~PropagatorList() { clear(); }
void PropagatorList::clear() {
	for (PostPropagator* r = head_; r;) {
		PostPropagator* t = r;
		r = r->next;
		t->destroy();
	}
	head_ = 0;
}
void PropagatorList::add(PostPropagator* p) {
	CLASP_ASSERT_CONTRACT_MSG(p && p->next == 0, "Invalid post propagator");
	uint32 prio = p->priority();
	for (PostPropagator** r = head(), *x;; r = &x->next) {
		if ((x = *r) == 0 || prio < (uint32)x->priority()) {
			p->next = x;
			*r      = p;
			break;
		}
	}
}
void PropagatorList::remove(PostPropagator* p) {
	CLASP_ASSERT_CONTRACT_MSG(p, "Invalid post propagator");
	for (PostPropagator** r = head(), *x; *r; r = &x->next) {
		if ((x = *r) == p) {
			*r      = x->next;
			p->next = 0;
			break;
		}
	}
}
PostPropagator* PropagatorList::find(uint32 prio) const {
	for (PostPropagator* x = head_; x; x = x->next) {
		uint32 xp = x->priority();
		if (xp >= prio) { return xp == prio ? x : 0; }
	}
	return 0;
}
}
clasp-3.2.2/libclasp/src/dependency_graph.cpp000066400000000000000000001155501304134206100212040ustar00rootroot00000000000000//
// Copyright (c) 2010-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
SolveTestEvent::SolveTestEvent(const Solver& s, uint32 a_hcc, bool part)
	: SolveEvent(s, Event::verbosity_max)
	, result(-1), hcc(a_hcc), partial(part) {
	confDelta   = s.stats.conflicts;
	choiceDelta = s.stats.choices;
	time        = 0.0;
}
uint64 SolveTestEvent::choices() const {
	return solver->stats.choices - choiceDelta;
}
uint64 SolveTestEvent::conflicts() const {
	return solver->stats.conflicts - confDelta;
}
namespace Asp {
/////////////////////////////////////////////////////////////////////////////////////////
// class PrgDepGraph
/////////////////////////////////////////////////////////////////////////////////////////
PrgDepGraph::PrgDepGraph(NonHcfMapType m) {
	// add sentinal atom needed for disjunctions
	createAtom(lit_false(), PrgNode::noScc);
	VarVec adj;	adj.push_back(idMax);
	initAtom(sentinel_atom, 0, adj, 0);
	seenComponents_ = 0;
	mapType_        = (uint32)m;
	stats_ = 0;
}

PrgDepGraph::~PrgDepGraph() {
	for (AtomVec::size_type i = 0; i != atoms_.size(); ++i) {
		delete [] atoms_[i].adj_;
	}
	for (AtomVec::size_type i = 0; i != bodies_.size(); ++i) {
		delete [] bodies_[i].adj_;
	}
	delete stats_;
	while (!components_.empty()) {
		delete components_.back();
		components_.pop_back();
	}
}
bool PrgDepGraph::relevantPrgAtom(const Solver& s, PrgAtom* a) const {
	return !a->ignoreScc() && a->inUpper() && a->scc() != PrgNode::noScc && !s.isFalse(a->literal());
}
bool PrgDepGraph::relevantPrgBody(const Solver& s, PrgBody* b) const {
	return !s.isFalse(b->literal());
}

// Creates a positive-body-atom-dependency graph (PBADG)
// The PBADG contains a node for each atom A of a non-trivial SCC and
// a node for each body B, s.th. there is a non-trivially connected atom A with
// B in body(A).
// Pre : b->seen() = 1 for all new and relevant bodies b
// Post: b->seen() = 0 for all bodies that were added to the PBADG
void PrgDepGraph::addSccs(LogicProgram& prg, const AtomList& sccAtoms, const NonHcfSet& nonHcfs) {
	// Pass 1: Create graph atom nodes and estimate number of bodies
	atoms_.reserve(atoms_.size() + sccAtoms.size());
	AtomList::size_type numBodies = 0;
	SharedContext& ctx = *prg.ctx();
	for (AtomList::size_type i = 0, end = sccAtoms.size(); i != end; ++i) {
		PrgAtom* a = sccAtoms[i];
		if (relevantPrgAtom(*ctx.master(), a)) {
			// add graph atom node and store link between program node and graph node for later lookup
			a->resetId(createAtom(a->literal(), a->scc()), true);
			// atom is defined by more than just a bunch of clauses
			ctx.setFrozen(a->var(), true);
			numBodies += a->supports();
		}
	}
	// Pass 2: Init atom nodes and create body nodes
	VarVec adj, ext;
	bodies_.reserve(bodies_.size() + numBodies/2);
	PrgBody* prgBody; PrgDisj* prgDis;
	for (AtomList::size_type i = 0, end = sccAtoms.size(); i != end; ++i) {
		PrgAtom*   a  = sccAtoms[i];
		if (relevantPrgAtom(*ctx.master(), a)) {
			uint32 prop = 0;
			for (PrgAtom::sup_iterator it = a->supps_begin(), endIt = a->supps_end(); it != endIt; ++it) {
				assert(it->isBody() || it->isDisj());
				NodeId bId= PrgNode::noNode;
				if (it->isBody() && !it->isGamma()) {
					prgBody = prg.getBody(it->node());
					bId     = relevantPrgBody(*ctx.master(), prgBody) ? addBody(prg, prgBody) : PrgNode::noNode;
				}
				else if (it->isDisj()) {
					prgDis  = prg.getDisj(it->node());
					bId     = addDisj(prg, prgDis);
					prop   |= AtomNode::property_in_disj;
				}
				if (bId != PrgNode::noNode) {
					if (!bodies_[bId].seen()) {
						bodies_[bId].seen(true);
						adj.push_back(bId);
					}
					if (it->isChoice()) {
						// mark atom as in choice
						prop |= AtomNode::property_in_choice;
					}
				}
			}
			uint32 nPred= (uint32)adj.size();
			for (PrgAtom::dep_iterator it = a->deps_begin(), endIt = a->deps_end(); it != endIt; ++it) {
				if (!it->sign()) {
					prgBody = prg.getBody(it->var());
					if (relevantPrgBody(*ctx.master(), prgBody) && prgBody->scc(prg) == a->scc()) {
						NodeId bodyId = addBody(prg, prgBody);
						if (!bodies_[bodyId].extended()) {
							adj.push_back(bodyId);
						}
						else {
							ext.push_back(bodyId);
							ext.push_back(bodies_[bodyId].get_pred_idx(a->id()));
							assert(bodies_[bodyId].get_pred(ext.back()) == a->id());
							prop |= AtomNode::property_in_ext;
						}
					}
				}
			}
			if (!ext.empty()) {
				adj.push_back(idMax);
				adj.insert(adj.end(), ext.begin(), ext.end());
			}
			adj.push_back(idMax);
			initAtom(a->id(), prop, adj, nPred);
			adj.clear(); ext.clear();
		}
	}
	if (nonHcfs.size() != 0 && stats_ == 0 && nonHcfs.config && nonHcfs.config->context().stats) {
		stats_ = enableNonHcfStats(nonHcfs.config->context().stats, prg.isIncremental());
	}
	// "update" existing non-hcf components
	for (NonHcfIter it = nonHcfBegin(), end = nonHcfEnd(); it != end; ++it) {
		(*it)->update(ctx);
	}
	// add new non-hcf components
	uint32 hcc = seenComponents_;
	for (NonHcfSet::const_iterator it = nonHcfs.begin() + seenComponents_, end = nonHcfs.end(); it != end; ++it, ++hcc) {
		addNonHcf(hcc, ctx, nonHcfs.config, *it);
	}
	seenComponents_ = nonHcfs.size();
}

uint32 PrgDepGraph::createAtom(Literal lit, uint32 aScc) {
	NodeId id    = (uint32)atoms_.size();
	atoms_.push_back(AtomNode());
	AtomNode& ua = atoms_.back();
	ua.lit       = lit;
	ua.scc       = aScc;
	return id;
}

void PrgDepGraph::initAtom(uint32 id, uint32 prop, const VarVec& adj, uint32 numPreds) {
	AtomNode& ua = atoms_[id];
	ua.setProperties(prop);
	ua.adj_      = new NodeId[adj.size()];
	ua.sep_      = ua.adj_ + numPreds;
	NodeId* sExt = ua.adj_;
	NodeId* sSame= sExt + numPreds;
	uint32  aScc = ua.scc;
	for (VarVec::const_iterator it = adj.begin(), end = adj.begin()+numPreds; it != end; ++it) {
		BodyNode& bn = bodies_[*it];
		if (bn.scc != aScc) { *sExt++ = *it; }
		else                { *--sSame= *it; }
		bn.seen(false);
	}
	std::reverse(sSame, ua.adj_ + numPreds);
	std::copy(adj.begin()+numPreds, adj.end(), ua.sep_);
}

uint32 PrgDepGraph::createBody(PrgBody* b, uint32 bScc) {
	NodeId id = (uint32)bodies_.size();
	bodies_.push_back(BodyNode(b, bScc));
	return id;
}

// Creates and initializes a body node for the given body b.
uint32 PrgDepGraph::addBody(const LogicProgram& prg, PrgBody* b) {
	if (b->seen()) {     // first time we see this body -
		VarVec preds, atHeads;
		uint32 bScc  = b->scc(prg);
		NodeId bId   = createBody(b, bScc);
		addPreds(prg, b, bScc, preds);
		addHeads(prg, b, atHeads);
		initBody(bId, preds, atHeads);
		b->resetId(bId, false);
		prg.ctx()->setFrozen(b->var(), true);
	}
	return b->id();
}

// Adds all relevant predecessors of b to preds.
// The returned list looks like this:
// [[B], a1, [w1], ..., aj, [wj], idMax, l1, [w1], ..., lk, [wk], idMax], where
// B is the bound of b (only for card/weight rules),
// ai is a positive predecessor from bScc,
// wi is the weight of ai (only for weight rules), and
// li is a literal of a subgoal from some other scc (only for cardinality/weight rules)
void PrgDepGraph::addPreds(const LogicProgram& prg, PrgBody* b, uint32 bScc, VarVec& preds) const {
	if (bScc == PrgNode::noScc) { preds.clear(); return; }
	const bool weights = b->type() == Body_t::Sum;
	for (uint32 i = 0; i != b->size() && !b->goal(i).sign(); ++i) {
		PrgAtom* pred = prg.getAtom(b->goal(i).var());
		if (relevantPrgAtom(*prg.ctx()->master(), pred) && pred->scc() == bScc) {
			preds.push_back( pred->id() );
			if (weights) { preds.push_back(b->weight(i)); }
		}
	}
	if (b->type() != Body_t::Normal) {
		preds.insert(preds.begin(), b->bound());
		preds.push_back(idMax);
		for (uint32 n = 0; n != b->size(); ++n) {
			PrgAtom* pred = prg.getAtom(b->goal(n).var());
			bool     ext  = b->goal(n).sign() || pred->scc() != bScc;
			Literal lit   = b->goal(n).sign() ? ~pred->literal() : pred->literal();
			if (ext && !prg.ctx()->master()->isFalse(lit)) {
				preds.push_back(lit.rep());
				if (weights) { preds.push_back(b->weight(n)); }
			}
		}
	}
	preds.push_back(idMax);
}

// Splits the heads of b into atoms and disjunctions.
// Disjunctions are flattened to sentinel-enclose datom-lists.
uint32 PrgDepGraph::addHeads(const LogicProgram& prg, PrgBody* b, VarVec& heads) const {
	for (PrgBody::head_iterator it = b->heads_begin(), end = b->heads_end(); it != end; ++it) {
		if (it->isAtom() && !it->isGamma()) {
			PrgAtom* a = prg.getAtom(it->node());
			if (relevantPrgAtom(*prg.ctx()->master(), a)) {
				heads.push_back(a->id());
			}
		}
		else if (it->isDisj()) {
			assert(prg.getDisj(it->node())->inUpper() && prg.getDisj(it->node())->supports() == 1);
			PrgDisj* d = prg.getDisj(it->node());
			// flatten disjunction and enclose in sentinels
			heads.push_back(sentinel_atom);
			getAtoms(prg, d, heads);
			heads.push_back(sentinel_atom);
		}
	}
	return sizeVec(heads);
}

// Adds the atoms from the given disjunction to atoms and returns the disjunction's scc.
uint32 PrgDepGraph::getAtoms(const LogicProgram& prg, PrgDisj* d, VarVec& atoms) const {
	uint32 scc = PrgNode::noScc;
	for (PrgDisj::atom_iterator it = d->begin(), end = d->end(); it != end; ++it) {
		PrgAtom* a = prg.getAtom(*it);
		if (relevantPrgAtom(*prg.ctx()->master(), a)) {
			assert(scc == PrgNode::noScc || scc == a->scc());
			atoms.push_back(a->id());
			scc = a->scc();
		}
	}
	return scc;
}

// Initializes preds and succs lists of the body node with the given id.
void PrgDepGraph::initBody(uint32 id, const VarVec& preds, const VarVec& atHeads) {
	BodyNode* bn = &bodies_[id];
	uint32 nSuccs= sizeVec(atHeads);
	bn->adj_     = new NodeId[nSuccs + preds.size()];
	bn->sep_     = bn->adj_ + nSuccs;
	NodeId* sSame= bn->adj_;
	NodeId* sExt = sSame + nSuccs;
	uint32  bScc = bn->scc;
	uint32  hScc = PrgNode::noScc;
	uint32  disj = 0;
	for (VarVec::const_iterator it = atHeads.begin(), end = atHeads.end(); it != end;) {
		if (*it) {
			hScc = getAtom(*it).scc;
			if (hScc == bScc) { *sSame++ = *it++; }
			else              { *--sExt  = *it++; }
		}
		else {
			hScc = getAtom(it[1]).scc; ++disj;
			if (hScc == bScc) { *sSame++ = *it++; while ( (*sSame++ = *it++) ) { ; } }
			else              { *--sExt  = *it++; while ( (*--sExt  = *it++) ) { ; } }
		}
	}
	std::copy(preds.begin(), preds.end(), bn->sep_);
	bn->sep_ += bn->extended();
	if (disj) { bodies_[id].data |= BodyNode::flag_has_delta; }
}

uint32 PrgDepGraph::addDisj(const LogicProgram& prg, PrgDisj* d) {
	assert(d->inUpper() && d->supports() == 1);
	if (d->seen()) { // first time we see this disjunction
		PrgBody* prgBody = prg.getBody(d->supps_begin()->node());
		uint32   bId     = PrgNode::noNode;
		if (relevantPrgBody(*prg.ctx()->master(), prgBody)) {
			bId = addBody(prg, prgBody);
		}
		d->resetId(bId, false);
	}
	return d->id();
}

void PrgDepGraph::addNonHcf(uint32 id, SharedContext& ctx, Configuration* config, uint32 scc) {
	VarVec sccAtoms, sccBodies;
	// get all atoms from scc
	for (uint32 i = 0; i != numAtoms(); ++i) {
		if (getAtom(i).scc == scc) {
			sccAtoms.push_back(i);
			atoms_[i].set(AtomNode::property_in_non_hcf);
		}
	}
	// get all bodies defining an atom in scc
	const Solver& generator = *ctx.master(); (void)generator;
	for (uint32 i = 0; i != sccAtoms.size(); ++i) {
		const AtomNode& a = getAtom(sccAtoms[i]);
		for (const NodeId* bodyIt = a.bodies_begin(), *bodyEnd = a.bodies_end(); bodyIt != bodyEnd; ++bodyIt) {
			BodyNode& B = bodies_[*bodyIt];
			if (!B.seen()) {
				assert(generator.value(B.lit.var()) != value_free || !generator.seen(B.lit));
				sccBodies.push_back(*bodyIt);
				B.seen(true);
			}
		}
	}
	for (uint32 i = 0; i != sccBodies.size(); ++i) { bodies_[sccBodies[i]].seen(false); }
	components_.push_back( new NonHcfComponent(id, *this, ctx, config, scc, sccAtoms, sccBodies) );
	if (stats_) { stats_->addHcc(*components_.back()); }
}
void PrgDepGraph::simplify(const Solver& s) {
	const bool shared        = s.sharedContext()->isShared();
	ComponentVec::iterator j = components_.begin();
	for (ComponentVec::iterator it = components_.begin(), end = components_.end(); it != end; ++it) {
		bool ok = (*it)->simplify(s);
		if (!shared) {
			if (ok) { *j++ = *it; }
			else    {
				if (stats_) { stats_->removeHcc(**it); }
				delete *it;
			}
		}
	}
	if (!shared) { components_.erase(j, components_.end()); }
}
PrgDepGraph::NonHcfStats* PrgDepGraph::enableNonHcfStats(uint32 level, bool inc) {
	if (!stats_) { stats_ = new NonHcfStats(*this, level, inc); }
	return stats_;
}
/////////////////////////////////////////////////////////////////////////////////////////
// class PrgDepGraph::NonHcfComponent::ComponentMap
/////////////////////////////////////////////////////////////////////////////////////////
class PrgDepGraph::NonHcfComponent::ComponentMap {
public:
	ComponentMap() { static_assert(sizeof(Mapping) == sizeof(uint64), "Invalid padding!"); }
	struct Mapping {
		explicit Mapping(NodeId id) : node(id), var(0), ext(0) { }
		uint32 node;     // node id in dep-graph of generator program P
		uint32 var : 30; // var in tester solver
		uint32 ext :  2; // additional data
		// Atom
		bool  disj() const { return ext != 0u; }
		bool hasTp() const { return ext == 2u; }
		Literal up() const { return posLit(var); }
		Literal hp() const { assert(disj()); return posLit(var + 1); }
		Literal tp() const { assert(disj()); return posLit((var + 2)*uint32(hasTp())); }
		// Body
		Literal fb() const { return Literal(var, (ext & 1u) != 0u); }
		bool    eq() const { return ext != 0u; }
		bool operator<(const Mapping& other) const { return node < other.node; }
	};
	typedef  PrgDepGraph                 SccGraph;
	typedef  PodVector::type    NodeMap;
	typedef  NodeMap::iterator           MapIt;
	typedef  NodeMap::const_iterator     MapIt_c;
	typedef  std::pair MapRange;
	void     addVars(Solver& generator, const SccGraph& dep, const VarVec& atoms, const VarVec& bodies, SharedContext& out);
	void     addAtomConstraints(SharedContext& out);
	void     addBodyConstraints(const Solver& generator, const SccGraph& dep, uint32 scc, SharedContext& out);
	void     mapGeneratorAssignment(const Solver& generator, const SccGraph& dep, LitVec& out) const;
	void     mapTesterModel(const Solver& tester, VarVec& out) const;
	bool     simplify(const Solver& generator, const SccGraph& dep, Solver& tester);
	MapRange atoms() const { return MapRange(mapping.begin(), mapping.begin() + numAtoms); }
	MapRange bodies()const { return MapRange(mapping.begin() + numAtoms, mapping.end()); }
	MapIt_c  findAtom(NodeId nodeId) const { return std::lower_bound(mapping.begin(), mapping.begin()+numAtoms, Mapping(nodeId)); }
	NodeMap  mapping; // maps nodes of P to literals in C;
	uint32   numAtoms;// number of atoms
};
// Adds necessary variables for all atoms and bodies to the component program.
// Input-Vars: (set via assumptions)
//  tp: for each atom p in a proper disjunctive head, tp is true iff p is true in P
//  fb: for each body b, fb is true iff b is false in P
// Aux-Var: (derived)
//  hp: for each atom p in a proper disjunctive head, hp is true iff tp and ~up
// Output: (unfounded sets)
//  up: for each atom p, up is true iff a is unfounded w.r.t the assignment of P.
void PrgDepGraph::NonHcfComponent::ComponentMap::addVars(Solver& generator, const SccGraph& dep, const VarVec& atoms, const VarVec& bodies, SharedContext& comp) {
	assert(generator.decisionLevel() == 0);
	mapping.reserve(atoms.size() + bodies.size());
	const PrgDepGraph::NonHcfMapType mt = dep.nonHcfMapType();
	for (VarVec::const_iterator it = atoms.begin(), end = atoms.end(); it != end; ++it) {
		const AtomNode& at = dep.getAtom(*it);
		Literal gen        = at.lit;
		if (generator.isFalse(gen)) { continue; }
		Mapping map(*it);
		// up [ hp [tp] ]
		map.var = comp.addVar(Var_t::Atom); // up
		map.ext = (mt == PrgDepGraph::map_old || at.inDisjunctive());
		comp.setFrozen(map.var, true);
		if (map.ext) {
			comp.addVar(Var_t::Atom); // hp
			if (!generator.isTrue(gen)) { // tp
				comp.setFrozen(comp.addVar(Var_t::Atom), true);
				++map.ext;
			}
		}
		mapping.push_back(map);
	}
	numAtoms = (uint32)mapping.size();
	std::stable_sort(mapping.begin(), mapping.end());
	// add necessary vars for bodies
	for (VarVec::const_iterator it = bodies.begin(), end = bodies.end(); it != end; ++it) {
		Literal gen = dep.getBody(*it).lit;
		if (generator.isFalse(gen))  { continue; }
		Mapping map(*it);
		if (!generator.seen(gen) && !generator.isTrue(gen)) {
			map.var = comp.addVar(Var_t::Atom);
			comp.setFrozen(map.var, true);
			generator.markSeen(gen);
		}
		else if (generator.isTrue(gen)) {
			map.ext = 1u;
		}
		else {
			map.ext = 2u;
			for (MapRange r = this->bodies(); r.first != r.second;) {
				--r.second;
				if (dep.getBody(r.second->node).lit == gen) {
					map.var = r.second->var;
					break;
				}
			}
		}
		assert(map.var <= comp.numVars() && (map.var || map.ext == 1u));
		mapping.push_back(map);
	}
	for (MapRange r = this->bodies(); r.first != r.second; ++r.first) {
		if (!r.first->eq()) {
			Var v = dep.getBody(r.first->node).lit.var();
			generator.clearSeen(v);
		}
	}
}

// Adds constraints stemming from the given atoms to the component program.
// 1. [up(a0) v ... v up(an-1)], where
//   - ai is an atom in P from the given atom set, and
//   - up(ai) is the corresponding output-atom in the component program C.
// 2. For each atom ai in atom set occurring in a proper disjunction, [hp(ai) <=> tp(ai), ~up(ai)], where
//   tp(ai), hp(ai), up(ai) are the input, aux, and output atoms in C.
void PrgDepGraph::NonHcfComponent::ComponentMap::addAtomConstraints(SharedContext& comp) {
	ClauseCreator cc1(comp.master()), cc2(comp.master());
	cc1.addDefaultFlags(ClauseCreator::clause_force_simplify);
	cc1.start();
	for (MapRange r = atoms(); r.first != r.second; ++r.first) {
		const Mapping& m = *r.first;
		cc1.add(m.up());
		if (m.disj()) {
			cc2.start().add(~m.tp()).add(m.up()).add(m.hp()).end(); // [~tp v up v hp]
			cc2.start().add(~m.hp()).add(m.tp()).end();  // [~hp v tp]
			cc2.start().add(~m.hp()).add(~m.up()).end(); // [~hp v ~up]
		}
	}
	cc1.end();
}

// Adds constraints stemming from the given bodies to the component program.
// For each atom ai and rule a0 | ai | ...| an :- B, s.th. B in bodies
//  [~up(ai) v fb(B) V hp(aj), j != i V up(p), p in B+ ^ C], where
// hp(ai), up(ai) are the aux and output atoms of ai in C.
void PrgDepGraph::NonHcfComponent::ComponentMap::addBodyConstraints(const Solver& generator, const SccGraph& dep, uint32 scc, SharedContext& comp) {
	ClauseCreator cc(comp.master());
	cc.addDefaultFlags(ClauseCreator::clause_force_simplify);
	ClauseCreator dc(comp.master());
	MapIt j = mapping.begin() + numAtoms;
	for (MapRange r = bodies(); r.first != r.second; ++r.first) {
		const BodyNode& B = dep.getBody(r.first->node);
		if (generator.isFalse(B.lit)) { continue; }
		if (B.extended())             { throw std::runtime_error("Extended bodies not supported - use '--trans-ext=weight'"); }
		for (const NodeId* hIt = B.heads_begin(), *hEnd = B.heads_end(); hIt != hEnd; ++hIt) {
			uint32 hScc = *hIt ? dep.getAtom(*hIt).scc : dep.getAtom(hIt[1]).scc;
			if (hScc != scc) {
				// the head is not relevant to this non-hcf - skip it
				if (!*hIt) { do { ++hIt; } while (*hIt); }
				continue;
			}
			// [fb(B) v ~up(a) V hp(o) for all o != a in B.disHead V up(b) for each b in B+ ^ C]
			cc.start().add(r.first->fb());
			if (B.scc == scc) { // add subgoals from same scc
				for (const NodeId* aIt = B.preds(); *aIt != idMax; ++aIt) {
					MapIt_c atMapped = findAtom(*aIt);
					cc.add(atMapped->up());
				}
			}
			if (*hIt) { // normal head
				MapIt_c atMapped = findAtom(*hIt);
				assert(atMapped != atoms().second);
				cc.add(~atMapped->up());
				cc.end();
			}
			else { // disjunctive head
				const NodeId* dHead = ++hIt;
				for (; *hIt; ++hIt) {
					dc.start();
					dc = cc;
					MapIt_c atMapped = findAtom(*hIt);
					dc.add(~atMapped->up());
					for (const NodeId* other = dHead; *other; ++other) {
						if (*other != *hIt) {
							assert(dep.getAtom(*other).scc == scc);
							atMapped = findAtom(*other);
							dc.add(atMapped->hp());
						}
					}
					dc.end();
				}
			}
		}
		if (!r.first->eq()) { *j++ = *r.first; }
	}
	mapping.erase(j, mapping.end());
}

// Maps the generator assignment given in s to a list of tester assumptions.
void PrgDepGraph::NonHcfComponent::ComponentMap::mapGeneratorAssignment(const Solver& s, const SccGraph& dep, LitVec& assume) const {
	Literal  gen;
	assume.clear(); assume.reserve(mapping.size());
	for (MapRange r = atoms(); r.first != r.second; ++r.first) {
		const Mapping& at = *r.first;
		gen = dep.getAtom(at.node).lit;
		if (at.hasTp()) {
			assume.push_back(at.tp() ^ (!s.isTrue(gen)));
		}
		if (s.isFalse(gen)) { assume.push_back(~at.up()); }
	}
	for (MapRange r = bodies(); r.first != r.second; ++r.first) {
		gen = dep.getBody(r.first->node).lit;
		assume.push_back(r.first->fb() ^ (!s.isFalse(gen)));
	}
}
// Maps the tester model given in s back to a list of unfounded atoms in the generator.
void PrgDepGraph::NonHcfComponent::ComponentMap::mapTesterModel(const Solver& s, VarVec& out) const {
	assert(s.numFreeVars() == 0);
	out.clear();
	for (MapRange r = atoms(); r.first != r.second; ++r.first) {
		if (s.isTrue(r.first->up())) {
			out.push_back(r.first->node);
		}
	}
}
bool PrgDepGraph::NonHcfComponent::ComponentMap::simplify(const Solver& generator, const SccGraph& dep, Solver& tester) {
	if (!tester.popRootLevel(UINT32_MAX)) { return false; }
	if (tester.sharedContext()->isShared() && (tester.sharedContext()->allowImplicit(Constraint_t::Conflict) || tester.sharedContext()->distributor.get())) {
		// Simplification not safe: top-level assignments of threads are
		// not necessarily synchronised at this point and clauses simplified
		// with top-level assignment of this thread might not (yet) be valid
		// wrt possible assumptions in other threads.
		return true;
	}
	const bool rem = !tester.sharedContext()->isShared();
	MapIt j        = rem ? mapping.begin() : mapping.end();
	for (MapIt_c it = mapping.begin(), aEnd = it + numAtoms, end = mapping.end(); it != end; ++it) {
		const Mapping& m = *it;
		const bool  atom = it < aEnd;
		Literal        g = atom ? dep.getAtom(m.node).lit : dep.getBody(m.node).lit;
		if (generator.topValue(g.var()) == value_free) {
			if (rem) { *j++ = m; }
			continue;
		}
		bool isFalse = generator.isFalse(g);
		bool ok      = atom || tester.force(isFalse ? m.fb() : ~m.fb());
		if (atom) {
			if (!isFalse){ ok = !m.hasTp() || tester.force(m.tp());  if (rem) { *j++ = m; } }
			else         { ok = tester.force(~m.up()) && (!m.hasTp() || tester.force(~m.tp())); numAtoms -= (ok && rem); }
		}
		if (!ok) {
			if (rem) { j = std::copy(it, end, j); }
			break;
		}
	}
	mapping.erase(j, mapping.end());
	return tester.simplify();
}
/////////////////////////////////////////////////////////////////////////////////////////
// class PrgDepGraph::NonHcfComponent
/////////////////////////////////////////////////////////////////////////////////////////
PrgDepGraph::NonHcfComponent::NonHcfComponent(uint32 id, const PrgDepGraph& dep, SharedContext& genCtx, Configuration* c, uint32 scc, const VarVec& atoms, const VarVec& bodies)
	: dep_(&dep)
	, prg_(new SharedContext())
	, comp_(new ComponentMap())
	, id_(id)
	, scc_(scc) {
	Solver& generator = *genCtx.master();
	prg_->setConcurrency(genCtx.concurrency(), SharedContext::resize_reserve);
	prg_->setConfiguration(c, Ownership_t::Retain);
	comp_->addVars(generator, dep, atoms, bodies, *prg_);
	prg_->startAddConstraints();
	comp_->addAtomConstraints(*prg_);
	comp_->addBodyConstraints(generator, dep, scc, *prg_);
	prg_->endInit(true);
}

PrgDepGraph::NonHcfComponent::~NonHcfComponent() {
	delete prg_;
	delete comp_;
}

void PrgDepGraph::NonHcfComponent::update(const SharedContext& generator) {
	for (uint32 i = 0; generator.hasSolver(i); ++i) {
		if (!prg_->hasSolver(i)) { prg_->attach(prg_->pushSolver());   }
		else                     { prg_->initStats(*prg_->solver(i)); }
	}
}

void PrgDepGraph::NonHcfComponent::assumptionsFromAssignment(const Solver& s, LitVec& assume) const {
	comp_->mapGeneratorAssignment(s, *dep_, assume);
}

bool PrgDepGraph::NonHcfComponent::test(const Solver& generator, const LitVec& assume, VarVec& unfoundedOut) const {
	assert(generator.id() < prg_->concurrency() && "Invalid id!");
	// Forwards to message handler of generator so that messages are
	// handled during long running tests.
	struct Tester : MessageHandler {
		Tester(Solver& s, MessageHandler* gen) : solver(&s), generator(gen) { if (gen) { s.addPost(this); } }
		~Tester() { if (generator) { solver->removePost(this); } }
		bool handleMessages()                            { return generator->handleMessages(); }
		bool propagateFixpoint(Solver&, PostPropagator*) { return Tester::handleMessages() || !terminate(); }
		bool terminate()                                 { solver->setStopConflict(); return true; }
		int test(const LitVec& assume) {
			return int(BasicSolve(*solver).satisfiable(assume, solver->stats.choices == 0) == false);
		}
		Solver*         solver;
		MessageHandler* generator;
	} tester(*prg_->solver(generator.id()), static_cast(generator.getPost(PostPropagator::priority_reserved_msg)));
	SolveTestEvent ev(*tester.solver, id_, generator.numFreeVars() != 0);
	tester.solver->stats.addTest(ev.partial);
	generator.sharedContext()->report(ev);
	ev.time = ThreadTime::getTime();
	if ((ev.result = tester.test(assume)) == 0) {
		tester.solver->stats.addModel(tester.solver->decisionLevel());
		comp_->mapTesterModel(*tester.solver, unfoundedOut);
	}
	ev.time = ThreadTime::getTime() - ev.time;
	tester.solver->stats.addCpuTime(ev.time);
	generator.sharedContext()->report(ev);
	return ev.result != 0;
}
bool PrgDepGraph::NonHcfComponent::simplify(const Solver& s) const {
	return comp_->simplify(s, *dep_, *prg_->solver(s.id()));
}
/////////////////////////////////////////////////////////////////////////////////////////
// class PrgDepGraph::NonHcfStats
/////////////////////////////////////////////////////////////////////////////////////////
struct PrgDepGraph::NonHcfStats::Data {
	typedef StatsVec ProblemVec;
	typedef StatsVec  SolverVec;
	struct ComponentStats {
		ProblemVec problem;
		SolverVec  solvers;
		SolverVec  accu;
	};
	Data(uint32 level, bool inc) : components(level > 1 ? new ComponentStats : 0) {
		if (inc) { solvers.multi = new SolverStats(); }
	}
	~Data() { delete components; delete solvers.multi; }
	void addHcc(const NonHcfComponent& c) {
		assert(components);
		ProblemVec&   hcc = components->problem;
		SolverVec& solver = components->solvers;
		SolverVec*   accu = solvers.multi ? &components->accu : 0;
		uint32 id = c.id();
		if (id >= hcc.size()) {
			hcc.growTo(id + 1);
			solver.growTo(id + 1);
			if (accu) { accu->growTo(id + 1); }
		}
		if (!hcc[id]) {
			hcc[id]    = new ProblemStats(c.ctx().stats());
			solver[id] = new SolverStats();
			if (accu) { (*accu)[id] = new SolverStats(); solver[id]->multi = (*accu)[id]; }
		}
	}
	void updateHcc(const NonHcfComponent& c) {
		c.ctx().accuStats(solvers);
		if (components && c.id() < components->solvers.size()) {
			CLASP_FAIL_IF(!components->solvers[c.id()], "component not added to stats!");
			c.ctx().accuStats(*components->solvers[c.id()]);
			components->solvers[c.id()]->flush();
		}
	}
	ProblemStats    hccs;
	SolverStats     solvers;
	ComponentStats* components;
};
PrgDepGraph::NonHcfStats::NonHcfStats(PrgDepGraph& g, uint32 l, bool inc) : graph_(&g), data_(new Data(l, inc)) {
	for (NonHcfIter it = g.nonHcfBegin(), end = g.nonHcfEnd(); it != end; ++it) {
		addHcc(**it);
	}
}
PrgDepGraph::NonHcfStats::~NonHcfStats() { delete data_; }
void PrgDepGraph::NonHcfStats::accept(StatsVisitor& out, bool final) const {
	if (!data_->solvers.multi) { final = false; }
	out.visitProblemStats(data_->hccs);
	out.visitSolverStats(final ? *data_->solvers.multi : data_->solvers);
	if (data_->components && out.visitHccs(StatsVisitor::Enter)) {
		const Data::SolverVec& solver = final ? data_->components->accu : data_->components->solvers;
		const Data::ProblemVec&   hcc = data_->components->problem;
		for (uint32 i = 0, end = sizeVec(hcc); i != end; ++i) {
			out.visitHcc(i, *hcc[i], *solver[i]);
		}
		out.visitHccs(StatsVisitor::Leave);
	}
}
void PrgDepGraph::NonHcfStats::startStep(uint32 statsLevel) {
	data_->solvers.reset();
	if (data_->components) { data_->components->solvers.reset(); }
	if (statsLevel > 1 && !data_->components) {
		data_->components = new Data::ComponentStats();
		for (NonHcfIter it = graph_->nonHcfBegin(), end = graph_->nonHcfEnd(); it != end; ++it) {
			data_->addHcc(**it);
		}
	}
}
void PrgDepGraph::NonHcfStats::endStep() {
	for (NonHcfIter it = graph_->nonHcfBegin(), end = graph_->nonHcfEnd(); it != end; ++it) {
		data_->updateHcc(**it);
	}
	data_->solvers.flush();
}
void PrgDepGraph::NonHcfStats::addHcc(const NonHcfComponent& c) {
	data_->hccs.accu(c.ctx().stats());
	if (data_->components) { data_->addHcc(c); }
}
void PrgDepGraph::NonHcfStats::removeHcc(const NonHcfComponent& c) {
	data_->updateHcc(c);
}
void PrgDepGraph::NonHcfStats::addTo(StatsMap& problem, StatsMap& solving, StatsMap* accu) const {
	data_->solvers.addTo("hccs", solving, accu);
	problem.add("hccs", StatisticObject::map(&data_->hccs));
	if (data_->components) {
		problem.add("hcc", data_->components->problem.toStats());
		solving.add("hcc", data_->components->solvers.toStats());
		if (accu) { accu->add("hcc", data_->components->accu.toStats()); }
	}
}
} // namespace Asp
/////////////////////////////////////////////////////////////////////////////////////////
// class ExtDepGraph
/////////////////////////////////////////////////////////////////////////////////////////
ExtDepGraph::ExtDepGraph(uint32) : maxNode_(0), comEdge_(0), genCnt_(0) {}
ExtDepGraph::~ExtDepGraph(){}
void ExtDepGraph::addEdge(Literal lit, uint32 startNode, uint32 endNode) {
	CLASP_FAIL_IF(!fwdArcs_.empty() && fwdArcs_.back().tail() == UINT32_MAX, "ExtDepGraph::update() not called!");
	fwdArcs_.push_back(Arc::create(lit, startNode, endNode));
	maxNode_ = std::max(std::max(startNode, endNode)+uint32(1), maxNode_);
	if (comEdge_ && std::min(startNode, endNode) < nodes_.size()) {
		invArcs_.clear();
		comEdge_ = 0;
		++genCnt_;
	}
}
bool ExtDepGraph::frozen() const {
	return !fwdArcs_.empty() && fwdArcs_.back().tail() == UINT32_MAX;
}
void ExtDepGraph::update() {
	if (frozen()) {
		fwdArcs_.pop_back();
	}
}
uint32 ExtDepGraph::finalize(SharedContext& ctx) {
	if (frozen()) {
		return comEdge_;
	}
	// sort by end node
	std::sort(fwdArcs_.begin() + comEdge_, fwdArcs_.end(), CmpArc<1>());
	invArcs_.reserve(fwdArcs_.size());
	Node sent = { UINT32_MAX, UINT32_MAX };
	nodes_.resize(maxNode_, sent);
	for (ArcVec::const_iterator it = fwdArcs_.begin() + comEdge_, end = fwdArcs_.end(); it != end;) {
		uint32 node = it->head();
		CLASP_FAIL_IF(comEdge_ && nodes_[node].invOff != UINT32_MAX, "ExtDepGraph: invalid incremental update!");
		Inv inv;
		nodes_[node].invOff = (uint32)invArcs_.size();
		do {
			inv.lit  = it->lit;
			inv.rep  = static_cast(it->tail() << 1) | 1u;
			invArcs_.push_back(inv);
			ctx.setFrozen(it->lit.var(), true);
		} while (++it != end && it->head() == node);
		invArcs_.back().rep ^= 1u;
	}
	// sort by start node
	std::sort(fwdArcs_.begin() + comEdge_, fwdArcs_.end(), CmpArc<0>());
	for (ArcVec::const_iterator it = fwdArcs_.begin() + comEdge_, end = fwdArcs_.end(); it != end;) {
		uint32 node = it->tail();
		CLASP_FAIL_IF(comEdge_ && nodes_[node].fwdOff != UINT32_MAX, "ExtDepGraph: invalid incremental update!");
		nodes_[node].fwdOff = static_cast(it - fwdArcs_.begin());
		it          = std::lower_bound(it, end, node + 1, CmpArc<0>());
	}
	comEdge_ = (uint32)fwdArcs_.size();
	fwdArcs_.push_back(Arc::create(lit_false(), UINT32_MAX, UINT32_MAX));
	return comEdge_;
}
uint64 ExtDepGraph::attach(Solver& s, Constraint& p, uint64 genId) {
	uint32 count = static_cast(genId >> 32);
	uint32 edges = static_cast(genId);
	uint32 update= count == genCnt_ ? 0 : edges;
	GenericWatch* w;
	for (uint32 i = (count == genCnt_ ? edges : 0), eId, end = comEdge_; i < end; ++i) {
		const Arc& a = fwdArcs_[i];
		if (a.head() != a.tail()) {
			if (s.topValue(a.lit.var()) == value_free) {
				if (!update || (w = s.getWatch(a.lit, &p)) == 0) {
					s.addWatch(a.lit, &p, i);
				}
				else {
					w->data = i;
					--update;
				}
			}
			else if (s.isTrue(a.lit)) {
				p.propagate(s, a.lit, (eId = i));
			}
		}
		else if (!s.force(~a.lit)) {
			break;
		}
	}
	return (static_cast(genCnt_) << 32) | comEdge_;
}
void ExtDepGraph::detach(Solver* s, Constraint& p) {
	if (s) {
		for (ArcVec::size_type i = fwdArcs_.size(); i--; ) {
			s->removeWatch(fwdArcs_[i].lit, &p);
		}
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// class AcyclicityCheck
/////////////////////////////////////////////////////////////////////////////////////////
struct AcyclicityCheck::ReasonStore {
	typedef PodVector::type NogoodMap;
	NogoodMap db;
	void getReason(Literal p, LitVec& out) {
		if (const LitVec* r = db[p.var()]) {
			out.insert(out.end(), r->begin(), r->end());
		}
	}
	void setReason(Literal p, LitVec::const_iterator first, LitVec::const_iterator end) {
		Var v = p.var();
		if (v >= db.size()) { db.resize(v+1, 0); }
		if (db[v] == 0)     { db[v] = new LitVec(first, end); }
		else                { db[v]->assign(first, end); }
	}
	~ReasonStore() {
		std::for_each(db.begin(), db.end(), DeleteObject());
	}
};
AcyclicityCheck::AcyclicityCheck(DependencyGraph* graph) : graph_(graph), solver_(0), nogoods_(0), strat_(bit_mask(config_bit)), tagCnt_(0), genId_(0)  {
}
AcyclicityCheck::~AcyclicityCheck() {
	delete nogoods_;
}

void AcyclicityCheck::setStrategy(Strategy p) {
	strat_ = p;
}
void AcyclicityCheck::setStrategy(const SolverParams& p) {
	if (p.acycFwd) { setStrategy(prop_fwd);  }
	else           { setStrategy(p.loopRep == LoopReason_t::Implicit ? prop_full_imp : prop_full); }
	store_set_bit(strat_, config_bit);
}

bool AcyclicityCheck::init(Solver& s) {
	if (!graph_) { graph_ = s.sharedContext()->extGraph.get(); }
	if (!graph_) { return true; }
	if (test_bit(strat_, config_bit)) {
		setStrategy(s.sharedContext()->configuration()->solver(s.id()));
	}
	tags_.resize(graph_->nodes(), 0);
	parent_.resize(graph_->nodes());
	todo_.clear();
	solver_ = &s;
	tagCnt_ = 0;
	genId_  = graph_->attach(s, *this, genId_);
	return true;
}

uint32 AcyclicityCheck::startSearch() {
	if (++tagCnt_ != 0) { return tagCnt_; }
	const uint32 last = tagCnt_ - 1;
	for (Var v = 0; v != tags_.size(); ++v) {
		tags_[v] = tags_[v] == last;
	}
	return tagCnt_ = 2;
}
void AcyclicityCheck::setReason(Literal p, LitVec::const_iterator first, LitVec::const_iterator end) {
	if (!nogoods_) { nogoods_ = new ReasonStore(); }
	nogoods_->setReason(p, first, end);
}
void AcyclicityCheck::addClauseLit(Solver& s, Literal p) {
	assert(s.isFalse(p));
	uint32 dl = s.level(p.var());
	if (dl && !s.seen(p)) {
		s.markSeen(p);
		s.markLevel(dl);
		reason_.push_back(p);
	}
}

void AcyclicityCheck::reset() {
	todo_.clear();
	reason_.clear();
}

bool AcyclicityCheck::valid(Solver& s) {
	if (todo_.empty()) { return true; }
	return AcyclicityCheck::propagateFixpoint(s, 0);
}
bool AcyclicityCheck::isModel(Solver& s) {
	return AcyclicityCheck::valid(s);
}

void AcyclicityCheck::destroy(Solver* s, bool detach) {
	if (s && detach) {
		s->removePost(this);
	}
	if (graph_) {
		graph_->detach(detach ? s : 0, *this);
	}
	PostPropagator::destroy(s, detach);
}
void AcyclicityCheck::reason(Solver&, Literal p, LitVec& out) {
	if (!reason_.empty() && reason_[0] == p) {
		out.insert(out.end(), reason_.begin()+1, reason_.end());
	}
	else if (nogoods_) {
		nogoods_->getReason(p, out);
	}
}

bool AcyclicityCheck::propagateFixpoint(Solver& s, PostPropagator*) {
	for (Arc x; !todo_.empty();) {
		x = todo_.pop_ret();
		if (!dfsForward(s, x) || (strategy() != prop_fwd && !dfsBackward(s, x))) {
			return false;
		}
	}
	todo_.clear();
	return true;
}
bool AcyclicityCheck::dfsForward(Solver& s, const Arc& root) {
	const uint32 tag = startSearch();
	nStack_.clear();
	pushVisit(root.head(), tag);
	for (Var node, next; !nStack_.empty();) {
		node = nStack_.back();
		nStack_.pop_back();
		for (const Arc* a = graph_->fwdBegin(node); a; a = graph_->fwdNext(a)) {
			if (s.isTrue(a->lit)) {
				next = a->head();
				if (next == root.tail()) {
					setParent(next, Parent::create(a->lit, node));
					reason_.assign(1, ~root.lit);
					for (Var n0 = next; n0 != root.head();) {
						Parent parent = parent_[n0];
						assert(s.isTrue(parent.lit));
						reason_.push_back(parent.lit);
						n0 = parent.node;
					}
					return s.force(~root.lit, this);
				}
				else if (!visited(next, tag)) {
					setParent(next, Parent::create(a->lit, node));
					pushVisit(next, tag);
				}
			}
		}
	}
	return true;
}
bool AcyclicityCheck::dfsBackward(Solver& s, const Arc& root) {
	const uint32 tag = startSearch();
	const uint32 fwd = tag - 1;
	nStack_.clear();
	pushVisit(root.tail(), tag);
	for (Var node, next; !nStack_.empty(); ) {
		node = nStack_.back();
		nStack_.pop_back();
		for (const Inv* a = graph_->invBegin(node); a; a = graph_->invNext(a)) {
			ValueRep val = s.value(a->lit.var());
			if (val == falseValue(a->lit) || visited(next = a->tail(), tag)) { continue; }
			if (visited(next, fwd)) { // a->lit would complete a cycle - force to false
				assert(val == value_free || s.level(a->lit.var()) == s.decisionLevel());
				reason_.assign(1, ~a->lit);
				addClauseLit(s, ~root.lit);
				for (Var n = next; n != root.head(); ) {
					Parent parent = parent_[n];
					assert(s.isTrue(parent.lit) && visited(parent.node, fwd));
					addClauseLit(s, ~parent.lit);
					n = parent.node;
				}
				for (Var n = node; n != root.tail(); ) {
					Parent parent = parent_[n];
					assert(s.isTrue(parent.lit)&& visited(parent.node, tag));
					addClauseLit(s, ~parent.lit);
					n = parent.node;
				}
				if (val == value_free && strategy() == prop_full) {
					ConstraintInfo info(Constraint_t::Loop);
					s.finalizeConflictClause(reason_, info, 0);
					ClauseCreator::create(s, reason_, ClauseCreator::clause_no_prepare, info);
				}
				else {
					for (uint32 i = 1; i != reason_.size(); ++i) {
						s.clearSeen(reason_[i].var());
						reason_[i] = ~reason_[i];
					}
					if (!s.force(~a->lit, this)) { return false; }
					setReason(~a->lit, reason_.begin()+1, reason_.end());
				}
				assert(s.isFalse(a->lit));
				if (!s.propagateUntil(this)) { return false; }
			}
			else if (val != value_free) { // follow true edge backward
				setParent(next, Parent::create(a->lit, node));
				pushVisit(next, tag);
			}
		}
	}
	return true;
}
}

clasp-3.2.2/libclasp/src/enumerator.cpp000066400000000000000000000302671304134206100200670ustar00rootroot00000000000000//
// Copyright (c) 2006-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// Enumerator - Shared Queue / Thread Queue
/////////////////////////////////////////////////////////////////////////////////////////
class Enumerator::SharedQueue : public mt::MultiQueue {
public:
	typedef mt::MultiQueue BaseType;
	explicit SharedQueue(uint32 m) : BaseType(m, releaseLits) { reserve(m + 1); }
	bool pushRelaxed(SharedLiterals* clause)  { unsafePublish(clause); return true; }
	static void releaseLits(SharedLiterals* x){ x->release(); }
};
class Enumerator::ThreadQueue {
public:
	explicit ThreadQueue(SharedQueue& q) : queue_(&q) { tail_ = q.addThread(); }
	bool         pop(SharedLiterals*& out){ return queue_->tryConsume(tail_, out); }
	ThreadQueue* clone()                  { return new ThreadQueue(*queue_); }
private:
	Enumerator::SharedQueue*          queue_;
	Enumerator::SharedQueue::ThreadId tail_;
};
/////////////////////////////////////////////////////////////////////////////////////////
// EnumerationConstraint
/////////////////////////////////////////////////////////////////////////////////////////
EnumerationConstraint::EnumerationConstraint() : mini_(0), flags_(0), root_(0) {
	setDisjoint(false);
}
EnumerationConstraint::~EnumerationConstraint() { }
void EnumerationConstraint::init(Solver& s, SharedMinimizeData* m, QueuePtr p) {
	mini_ = 0;
	queue_= p;
	if (m) {
		const SolverParams* c = s.sharedContext()->configuration() ? &s.sharedContext()->configuration()->solver(s.id()) : 0;
		MinimizeMode_t::Strategy st = c ? static_cast(c->optStrat) : MinimizeMode_t::opt_bb;
		mini_ = m->attach(s, st, c ? c->optParam : 0u);
		if (c && (c->optHeu & MinimizeMode_t::heu_sign) != 0) {
			for (const WeightLiteral* it = m->lits; !isSentinel(it->first); ++it) {
				s.setPref(it->first.var(), ValueSet::pref_value, falseValue(it->first));
			}
		}
		if (c && (c->optHeu & MinimizeMode_t::heu_model) != 0) { flags_ |= uint32(flag_model_heuristic); }
		else                                                   { flags_ &= ~uint32(flag_model_heuristic);}
	}
}
bool EnumerationConstraint::valid(Solver& s)         { return !optimize() || mini_->valid(s); }
void EnumerationConstraint::add(Constraint* c)       { if (c) { nogoods_.push_back(c); } }
bool EnumerationConstraint::integrateBound(Solver& s){ return !mini_ || mini_->integrate(s); }
bool EnumerationConstraint::optimize() const         { return mini_ && mini_->shared()->optimize(); }
void EnumerationConstraint::setDisjoint(bool x) {
	if (x) { flags_ |=  uint32(flag_path_disjoint); }
	else   { flags_ &= ~uint32(flag_path_disjoint); }
}
Constraint* EnumerationConstraint::cloneAttach(Solver& s) {
	EnumerationConstraint* c = clone();
	CLASP_FAIL_IF(c == 0, "Cloning not supported by Enumerator");
	c->init(s, mini_ ? const_cast(mini_->shared()) : 0, queue_.get() ? queue_->clone() : 0);
	return c;
}
void EnumerationConstraint::end(Solver& s) {
	if (mini_) { mini_->relax(s, disjointPath()); }
	flags_ = 0;
	next_.clear();
	if (s.rootLevel() > root_) { s.popRootLevel(s.rootLevel() - root_); }
}
bool EnumerationConstraint::start(Solver& s, const LitVec& path, bool disjoint) {
	flags_ = 0;
	root_  = s.rootLevel();
	setDisjoint(disjoint);
	if (s.pushRoot(path) && s.pushRoot(s.sharedContext()->stepLiteral())) {
		integrateBound(s);
		return true;
	}
	return false;
}
bool EnumerationConstraint::update(Solver& s) {
	ValueRep st = state();
	if (st == value_true) {
		if (s.restartOnModel()) { s.undoUntil(0); }
		if (optimize())         { s.strengthenConditional(); }
	}
	else if (st == value_false && !s.pushRoot(next_)) {
		if (!s.hasConflict()) { s.setStopConflict(); }
		return false;
	}
	flags_ &= uint32(clear_state_mask);
	next_.clear();
	do {
		if (!s.hasConflict() && doUpdate(s) && integrateBound(s) && integrateNogoods(s)) {
			if (st == value_true) { modelHeuristic(s); }
			return true;
		}
	} while (st != value_free && s.hasConflict() && s.resolveConflict());
	return false;
}
bool EnumerationConstraint::integrateNogoods(Solver& s) {
	if (!queue_.get() || s.hasConflict()) { return !s.hasConflict(); }
	const uint32 f = ClauseCreator::clause_no_add | ClauseCreator::clause_no_release | ClauseCreator::clause_explicit;
	for (SharedLiterals* clause; queue_->pop(clause); ) {
		ClauseCreator::Result res = ClauseCreator::integrate(s, clause, f);
		if (res.local) { add(res.local);}
		if (!res.ok()) { return false;  }
	}
	return true;
}
void EnumerationConstraint::destroy(Solver* s, bool x) {
	if (mini_) { mini_->destroy(s, x); mini_ = 0; }
	queue_ = 0;
	Clasp::destroyDB(nogoods_, s, x);
	Constraint::destroy(s, x);
}
bool EnumerationConstraint::simplify(Solver& s, bool reinit) {
	if (mini_) { mini_->simplify(s, reinit); }
	simplifyDB(s, nogoods_, reinit);
	return false;
}

bool EnumerationConstraint::commitModel(Enumerator& ctx, Solver& s) {
	if (state() == value_true)          { return !next_.empty() && (s.satPrepro()->extendModel(s.model, next_), true); }
	if (mini_ && !mini_->handleModel(s)){ return false; }
	if (!ctx.tentative())               { doCommitModel(ctx, s); }
	next_ = s.symmetric();
	flags_|= value_true;
	return true;
}
bool EnumerationConstraint::commitUnsat(Enumerator& ctx, Solver& s) {
	next_.clear();
	flags_ |= value_false;
	if (mini_) {
		mini_->handleUnsat(s, !disjointPath(), next_);
	}
	if (!ctx.tentative()) {
		doCommitUnsat(ctx, s);
	}
	return !s.hasConflict() || s.decisionLevel() != s.rootLevel();
}
void EnumerationConstraint::modelHeuristic(Solver& s) {
	const bool full      = (flags_ & uint32(flag_model_heuristic)) != 0;
	const bool heuristic = full || (s.queueSize() == 0 && s.decisionLevel() == s.rootLevel());
	if (optimize() && heuristic && s.propagate()) {
		for (const WeightLiteral* w = mini_->shared()->lits; !isSentinel(w->first); ++w) {
			if (s.value(w->first.var()) == value_free) {
				s.assume(~w->first);
				if (!full || !s.propagate()) { break; }
			}
		}
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// Enumerator
/////////////////////////////////////////////////////////////////////////////////////////
void Model::reset() { std::memset(this, 0, sizeof(Model)); }
Enumerator::Enumerator() : mini_(0), queue_(0) { model_.reset(); }
Enumerator::~Enumerator()                            { delete queue_; }
void Enumerator::setDisjoint(Solver& s, bool b)const { constraint(s)->setDisjoint(b);    }
void Enumerator::setIgnoreSymmetric(bool b)          { model_.sym = static_cast(b == false); }
void Enumerator::end(Solver& s)                const { constraint(s)->end(s); }
void Enumerator::doReset()                           {}
void Enumerator::reset() {
	if (mini_) { mini_ = 0; }
	if (queue_){ delete queue_; queue_ = 0; }
	model_.reset();
	model_.ctx  = this;
	model_.sym  = 1;
	model_.type = uint32(modelType());
	model_.sId  = 0;
	doReset();
}
int  Enumerator::init(SharedContext& ctx, OptMode oMode, int limit)  {
	ctx.master()->setEnumerationConstraint(0);
	reset();
	if (oMode != MinimizeMode_t::ignore){ mini_ = ctx.minimize(); }
	limit      = limit >= 0 ? limit : 1 - int(exhaustive());
	if (limit != 1) { ctx.setPreserveModels(true); }
	queue_     = new SharedQueue(ctx.concurrency());
	ConPtr c   = doInit(ctx, mini_, limit);
	bool cons  = model_.consequences();
	if      (tentative())        { model_.type = Model::Sat; }
	else if (cons && optimize()) { ctx.warn("Optimization: Consequences may depend on enumeration order."); }
	c->init(*ctx.master(), mini_, new ThreadQueue(*queue_));
	ctx.master()->setEnumerationConstraint(c);
	return limit;
}
Enumerator::ConPtr Enumerator::constraint(const Solver& s) const {
	return static_cast(s.enumerationConstraint());
}
bool Enumerator::start(Solver& s, const LitVec& path, bool disjointPath) const {
	return constraint(s)->start(s, path, disjointPath);
}
ValueRep Enumerator::commit(Solver& s) {
	if      (s.hasConflict() && s.decisionLevel() == s.rootLevel())         { return commitUnsat(s) ? value_free : value_false; }
	else if (s.numFreeVars() == 0 && s.queueSize() == 0 && !s.hasConflict()){ return commitModel(s) ? value_true : value_free;  }
	return value_free;
}
bool Enumerator::commitModel(Solver& s) {
	assert(s.numFreeVars() == 0 && !s.hasConflict() && s.queueSize() == 0 && constraint(s));
	if (constraint(s)->commitModel(*this, s)) {
		s.stats.addModel(s.decisionLevel());
		++model_.num;
		model_.sId    = s.id();
		model_.values = &s.model;
		model_.costs  = 0;
		model_.up     = 0;
		if (minimizer()) {
			costs_.resize(minimizer()->numRules());
			std::transform(minimizer()->adjust(), minimizer()->adjust()+costs_.size(), minimizer()->sum(), costs_.begin(), std::plus());
			model_.costs = &costs_;
		}
		return true;
	}
	return false;
}
bool Enumerator::commitSymmetric(Solver& s){ return model_.sym && !optimize() && commitModel(s); }
bool Enumerator::commitUnsat(Solver& s)    { return constraint(s)->commitUnsat(*this, s); }
bool Enumerator::commitClause(const LitVec& clause)  const {
	return queue_ && queue_->pushRelaxed(SharedLiterals::newShareable(clause, Constraint_t::Other));
}
bool Enumerator::commitComplete() {
	if (enumerated()) {
		if (tentative()) {
			mini_->markOptimal();
			model_.opt = 1;
			model_.num = 0;
			model_.type= uint32(modelType());
			return false;
		}
		else if (model_.consequences() || (!model_.opt && optimize())) {
			model_.opt = uint32(optimize());
			model_.def = uint32(model_.consequences());
			model_.num = 1;
		}
	}
	return true;
}
bool Enumerator::update(Solver& s) const {
	return constraint(s)->update(s);
}
bool Enumerator::supportsSplitting(const SharedContext& ctx) const {
	if (!optimize()) { return true; }
	const Configuration* config = ctx.configuration();
	bool ok = true;
	for (uint32 i = 0; i != ctx.concurrency() && ok; ++i) {
		if      (ctx.hasSolver(i) && constraint(*ctx.solver(i))){ ok = constraint(*ctx.solver(i))->minimizer()->supportsSplitting(); }
		else if (config && i < config->numSolver())             { ok = MinimizeMode_t::supportsSplitting(static_cast(config->solver(i).optStrat)); }
	}
	return ok;
}
int Enumerator::unsatType() const {
	return !optimize() ? unsat_stop : unsat_cont;
}
Model& Enumerator::model() {
	return model_;
}
/////////////////////////////////////////////////////////////////////////////////////////
// EnumOptions
/////////////////////////////////////////////////////////////////////////////////////////
Enumerator* EnumOptions::createEnumerator(const EnumOptions& opts) {
	if      (opts.models())      { return createModelEnumerator(opts);}
	else if (opts.consequences()){ return createConsEnumerator(opts); }
	else                         { return nullEnumerator(); }
}
Enumerator* EnumOptions::nullEnumerator() {
	struct NullEnum : Enumerator {
		ConPtr doInit(SharedContext&, SharedMinimizeData*, int) {
			struct Constraint : public EnumerationConstraint {
				Constraint() : EnumerationConstraint() {}
				ConPtr      clone()          { return new Constraint(); }
				bool        doUpdate(Solver&){ return true; }
			};
			return new Constraint();
		}
	};
	return new NullEnum;
}

const char* modelType(const Model& m) {
	switch (m.type) {
		case Model::Sat     : return "Model";
		case Model::Brave   : return "Brave";
		case Model::Cautious: return "Cautious";
		case Model::User    : return "User";
		default: return 0;
	}
}

}
clasp-3.2.2/libclasp/src/heuristics.cpp000066400000000000000000000764221304134206100200730ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// Lookback selection strategies
/////////////////////////////////////////////////////////////////////////////////////////
uint32 momsScore(const Solver& s, Var v) {
	uint32 sc;
	if (s.sharedContext()->numBinary()) {
		uint32 s1 = s.estimateBCP(posLit(v), 0) - 1;
		uint32 s2 = s.estimateBCP(negLit(v), 0) - 1;
		sc = ((s1 * s2)<<10) + (s1 + s2);
	}
	else {
		// problem does not contain binary constraints - fall back to counting watches
		uint32 s1 = s.numWatches(posLit(v));
		uint32 s2 = s.numWatches(negLit(v));
		sc = ((s1 * s2)<<10) + (s1 + s2);
	}
	return sc;
}
static void addOther(TypeSet& t, uint32 other) {
	if (other != HeuParams::other_no)  { t.addSet(Constraint_t::Loop); }
	if (other == HeuParams::other_all) { t.addSet(Constraint_t::Other); }
}
/////////////////////////////////////////////////////////////////////////////////////////
// Berkmin selection strategy
/////////////////////////////////////////////////////////////////////////////////////////
#define BERK_NUM_CANDIDATES 5
#define BERK_CACHE_GROW 2.0
#define BERK_MAX_MOMS_VARS 9999
#define BERK_MAX_MOMS_DECS 50
#define BERK_MAX_DECAY 65534

ClaspBerkmin::ClaspBerkmin(const HeuParams& params)
	: topConflict_(UINT32_MAX)
	, topOther_(UINT32_MAX)
	, front_(1)
	, cacheSize_(5)
	, numVsids_(0) {
	ClaspBerkmin::setConfig(params);
}

void ClaspBerkmin::setConfig(const HeuParams& params) {
	maxBerkmin_     = params.param == 0 ? UINT32_MAX : params.param;
	order_.nant     = params.nant != 0;
	order_.huang    = params.huang != 0;
	order_.resScore = params.score == HeuParams::score_auto ? static_cast(HeuParams::score_multi_set) : params.score;
	addOther(types_ = TypeSet(), params.other);
	if (params.moms) { types_.addSet(Constraint_t::Static); }
}

Var ClaspBerkmin::getMostActiveFreeVar(const Solver& s) {
	++numVsids_;
	// first: check for a cache hit
	for (Pos end = cache_.end(); cacheFront_ != end; ++cacheFront_) {
		if (s.value(*cacheFront_) == value_free) {
			return *cacheFront_;
		}
	}
	// Second: cache miss - refill cache with most active vars
	if (!cache_.empty() && cacheSize_ < s.numFreeVars()/10) {
		cacheSize_ = static_cast( (cacheSize_*BERK_CACHE_GROW) + .5 );
	}
	cache_.clear();
	Order::Compare  comp(&order_);
	// Pre: At least one unassigned var!
	for (; s.value( front_ ) != value_free; ++front_) {;}
	Var v = front_;
	LitVec::size_type cs = std::min(cacheSize_, s.numFreeVars());
	for (;;) { // add first cs free variables to cache
		cache_.push_back(v);
		std::push_heap(cache_.begin(), cache_.end(), comp);
		if (cache_.size() == cs) break;
		while ( s.value(++v) != value_free ) {;} // skip over assigned vars
	}
	for (v = (cs == cacheSize_ ? v+1 : s.numVars()+1); v <= s.numVars(); ++v) {
		// replace vars with low activity
		if (s.value(v) == value_free && comp(v, cache_[0])) {
			std::pop_heap(cache_.begin(), cache_.end(), comp);
			cache_.back() = v;
			std::push_heap(cache_.begin(), cache_.end(), comp);
		}
	}
	std::sort_heap(cache_.begin(), cache_.end(), comp);
	return *(cacheFront_ = cache_.begin());
}

Var ClaspBerkmin::getTopMoms(const Solver& s) {
	// Pre: At least one unassigned var!
	for (; s.value( front_ ) != value_free; ++front_) {;}
	Var var   = front_;
	uint32 ms = momsScore(s, var);
	uint32 ls = 0;
	for (Var v = var+1; v <= s.numProblemVars(); ++v) {
		if (s.value(v) == value_free && (ls = momsScore(s, v)) > ms) {
			var = v;
			ms  = ls;
		}
	}
	if (++numVsids_ >= BERK_MAX_MOMS_DECS || ms < 2) {
		// Scores are not relevant or too many moms-based decisions
		// - disable MOMS
		hasActivities(true);
	}
	return var;
}

void ClaspBerkmin::startInit(const Solver& s) {
	if (order_.score.empty()) {
		rng_.srand(s.rng.seed());
	}
	order_.score.resize(s.numVars()+1);
	initHuang(order_.huang);

	cache_.clear();
	cacheSize_ = 5;
	cacheFront_ = cache_.end();

	freeLits_.clear();
	freeOtherLits_.clear();
	topConflict_ = topOther_ = (uint32)-1;

	front_    = 1;
	numVsids_ = 0;
}

void ClaspBerkmin::endInit(Solver& s) {
	if (initHuang()) {
		const bool clearScore = types_.inSet(Constraint_t::Static);
		// initialize preferred values of vars
		cache_.clear();
		for (Var v = 1; v <= s.numVars(); ++v) {
			order_.decayedScore(v);
			if (order_.occ(v) != 0 && s.pref(v).get(ValueSet::saved_value) == value_free) {
				s.setPref(v, ValueSet::saved_value, order_.occ(v) > 0 ? value_true : value_false);
			}
			if   (clearScore) order_.score[v] = HScore(order_.decay);
			else cache_.push_back(v);
		}
		initHuang(false);
	}
	if (!types_.inSet(Constraint_t::Static) || s.numFreeVars() > BERK_MAX_MOMS_VARS) {
		hasActivities(true);
	}
	std::stable_sort(cache_.begin(), cache_.end(), Order::Compare(&order_));
	cacheFront_ = cache_.begin();
}

void ClaspBerkmin::updateVar(const Solver& s, Var v, uint32 n) {
	if (s.validVar(v)) { growVecTo(order_.score, v+n); }
	front_ = 1;
	cache_.clear();
	cacheFront_ = cache_.end();
}

void ClaspBerkmin::newConstraint(const Solver& s, const Literal* first, LitVec::size_type size, ConstraintType t) {
	if (t == Constraint_t::Conflict) { hasActivities(true); }
	if ((t == Constraint_t::Conflict && order_.resScore == HeuParams::score_min)
	 || (t == Constraint_t::Static   && order_.huang)) {
		for (const Literal* x = first, *end = first+size; x != end; ++x) {
			order_.inc(*x, s.varInfo(x->var()).nant());
		}
	}
	if (t != Constraint_t::Static && !order_.huang) {
		for (const Literal* x = first, *end = first+size; x != end; ++x) { order_.incOcc(*x); }
	}
}

void ClaspBerkmin::updateReason(const Solver& s, const LitVec& lits, Literal r) {
	if (order_.resScore > HeuParams::score_min) {
		const bool ms = order_.resScore == HeuParams::score_multi_set;
		for (LitVec::size_type i = 0, e = lits.size(); i != e; ++i) {
			if (ms || !s.seen(lits[i])) { order_.inc(~lits[i], s.varInfo(lits[i].var()).nant()); }
		}
	}
	if ((order_.resScore & 1u) != 0 && !isSentinel(r)) {
		order_.inc(r, s.varInfo(r.var()).nant());
	}
}

bool ClaspBerkmin::bump(const Solver& s, const WeightLitVec& lits, double adj) {
	for (WeightLitVec::const_iterator it = lits.begin(), end = lits.end(); it != end; ++it) {
		if (!order_.nant || s.varInfo(it->first.var()).nant()) {
			uint32 xf = order_.decayedScore(it->first.var()) + static_cast(it->second*adj);
			order_.score[it->first.var()].act = (uint16)std::min(xf, UINT32_MAX>>16);
		}
	}
	return true;
}

void ClaspBerkmin::undoUntil(const Solver&, LitVec::size_type) {
	topConflict_ = topOther_ = static_cast(-1);
	front_ = 1;
	cache_.clear();
	cacheFront_ = cache_.end();
	if (cacheSize_ > 5 && numVsids_ > 0 && (numVsids_*3) < cacheSize_) {
		cacheSize_ = static_cast(cacheSize_/BERK_CACHE_GROW);
	}
	numVsids_ = 0;
}

bool ClaspBerkmin::hasTopUnsat(Solver& s) {
	topConflict_  = std::min(s.numLearntConstraints(), topConflict_);
	topOther_     = std::min(s.numLearntConstraints(), topOther_);
	assert(topConflict_ <= topOther_);
	freeOtherLits_.clear();
	freeLits_.clear();
	TypeSet ts = types_;
	if (ts.m > 1) {
		while (topOther_ > topConflict_) {
			if (s.getLearnt(topOther_-1).isOpen(s, ts, freeLits_) != 0) {
				freeLits_.swap(freeOtherLits_);
				ts.m = 0;
				break;
			}
			--topOther_;
			freeLits_.clear();
		}
	}
	ts.addSet(Constraint_t::Conflict);
	uint32 stopAt = topConflict_ < maxBerkmin_ ? 0 : topConflict_ - maxBerkmin_;
	while (topConflict_ != stopAt) {
		uint32 x = s.getLearnt(topConflict_-1).isOpen(s, ts, freeLits_);
		if (x != 0) {
			if (x == Constraint_t::Conflict) { break; }
			topOther_  = topConflict_;
			freeLits_.swap(freeOtherLits_);
			ts.m = 0;
			ts.addSet(Constraint_t::Conflict);
		}
		--topConflict_;
		freeLits_.clear();
	}
	if (freeOtherLits_.empty())  topOther_ = topConflict_;
	if (freeLits_.empty())      freeOtherLits_.swap(freeLits_);
	return !freeLits_.empty();
}

Literal ClaspBerkmin::doSelect(Solver& s) {
	const uint32 decayMask = order_.huang ? 127 : 511;
	if ( ((s.stats.choices + 1)&decayMask) == 0 ) {
		if ((order_.decay += (1+!order_.huang)) == BERK_MAX_DECAY) {
			order_.resetDecay();
		}
	}
	if (hasTopUnsat(s)) {        // Berkmin based decision
		assert(!freeLits_.empty());
		Literal x = selectRange(s, &freeLits_[0], &freeLits_[0]+freeLits_.size());
		return selectLiteral(s, x.var(), false);
	}
	else if (hasActivities()) {  // Vsids based decision
		return selectLiteral(s, getMostActiveFreeVar(s), true);
	}
	else {                       // Moms based decision
		return selectLiteral(s, getTopMoms(s), true);
	}
}

Literal ClaspBerkmin::selectRange(Solver& s, const Literal* first, const Literal* last) {
	Literal candidates[BERK_NUM_CANDIDATES];
	candidates[0] = *first;
	uint32 c = 1;
	uint32  ms  = static_cast(-1);
	uint32  ls  = 0;
	for (++first; first != last; ++first) {
		Var v = first->var();
		assert(s.value(v) == value_free);
		int cmp = order_.compare(v, candidates[0].var());
		if (cmp > 0) {
			candidates[0] = *first;
			c = 1;
			ms  = static_cast(-1);
		}
		else if (cmp == 0) {
			if (ms == static_cast(-1)) ms = momsScore(s, candidates[0].var());
			if ( (ls = momsScore(s,v)) > ms) {
				candidates[0] = *first;
				c = 1;
				ms  = ls;
			}
			else if (ls == ms && c != BERK_NUM_CANDIDATES) {
				candidates[c++] = *first;
			}
		}
	}
	return c == 1 ? candidates[0] : candidates[rng_.irand(c)];
}

Literal ClaspBerkmin::selectLiteral(Solver& s, Var v, bool vsids) const {
	ValueSet pref = s.pref(v);
	int signScore = order_.occ(v);
	if (order_.huang && std::abs(signScore) > 32 && !pref.has(ValueSet::user_value)) {
		return Literal(v, signScore < 0);
	}
	// compute expensive sign score only if necessary
	if (vsids && !pref.has(ValueSet::user_value | ValueSet::pref_value | ValueSet::saved_value)) {
		int32 w0 = (int32)s.estimateBCP(posLit(v), 5);
		int32 w1 = (int32)s.estimateBCP(negLit(v), 5);
		if (w1 != 1 || w0 != w1) { signScore = w0 - w1; }
	}
	return DecisionHeuristic::selectLiteral(s, v, signScore);
}

void ClaspBerkmin::Order::resetDecay() {
	for (Scores::size_type i = 1, end = score.size(); i < end; ++i) {
		decayedScore(i);
		score[i].dec = 0;
	}
	decay = 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspVmtf selection strategy
/////////////////////////////////////////////////////////////////////////////////////////
ClaspVmtf::ClaspVmtf(const HeuParams& params) : decay_(0) {
	ClaspVmtf::setConfig(params);
}

void ClaspVmtf::setConfig(const HeuParams& params) {
	nMove_  = params.param ? std::max(params.param, uint32(2)) : 8u;
	scType_ = params.score != HeuParams::score_auto ? params.score : static_cast(HeuParams::score_min);
	nant_   = params.nant != 0;
	addOther(types_ = TypeSet(), params.other != HeuParams::other_auto ? params.other : static_cast(HeuParams::other_no));
	if (params.moms) { types_.addSet(Constraint_t::Static); }
	if (scType_ == HeuParams::score_min) { types_.addSet(Constraint_t::Conflict); }
}

void ClaspVmtf::startInit(const Solver& s) {
	score_.resize(s.numVars()+1, VarInfo(vars_.end()));
}

void ClaspVmtf::endInit(Solver& s) {
	bool moms = types_.inSet(Constraint_t::Static);
	for (Var v = 1; v <= s.numVars(); ++v) {
		if (s.value(v) == value_free && score_[v].pos_ == vars_.end()) {
			score_[v].activity(decay_);
			if (moms) {
				score_[v].activity_ = momsScore(s, v);
				score_[v].decay_    = decay_+1;
			}
			score_[v].pos_ = vars_.insert(vars_.end(), v);
		}
	}
	if (moms) {
		vars_.sort(LessLevel(s, score_));
		for (VarList::iterator it = vars_.begin(), end = vars_.end(); it != end; ++it) {
			if (score_[*it].decay_ != decay_) {
				score_[*it].activity_ = 0;
				score_[*it].decay_    = decay_;
			}
		}
	}
	front_ = vars_.begin();
}

void ClaspVmtf::updateVar(const Solver& s, Var v, uint32 n) {
	if (s.validVar(v)) {
		growVecTo(score_, v+n, VarInfo(vars_.end()));
		for (uint32 end = v+n; v != end; ++v) {
			if (score_[v].pos_ == vars_.end()) { score_[v].pos_ = vars_.insert(vars_.end(), v); }
			else                               { front_ = vars_.begin(); }
		}
	}
	else if (v < score_.size()) {
		if ((v + n) > score_.size()) { n = score_.size() - v; }
		for (uint32 x = v + n; x-- != v; ) {
			if (score_[x].pos_ != vars_.end()) {
				vars_.erase(score_[x].pos_);
				score_[x].pos_ = vars_.end();
			}
		}
	}
}

void ClaspVmtf::simplify(const Solver& s, LitVec::size_type i) {
	for (; i < s.numAssignedVars(); ++i) {
		if (score_[s.trail()[i].var()].pos_ != vars_.end()) {
			vars_.erase(score_[s.trail()[i].var()].pos_);
			score_[s.trail()[i].var()].pos_ = vars_.end();
		}
	}
	front_ = vars_.begin();
}

void ClaspVmtf::newConstraint(const Solver& s, const Literal* first, LitVec::size_type size, ConstraintType t) {
	if (t != Constraint_t::Static) {
		LessLevel comp(s, score_);
		const bool upAct = types_.inSet(t);
		const VarVec::size_type mtf = t == Constraint_t::Conflict ? nMove_ : (nMove_*uint32(upAct))/2;
		for (LitVec::size_type i = 0; i < size; ++i, ++first) {
			Var v = first->var();
			score_[v].occ_ += 1 - (((int)first->sign())<<1);
			if (upAct) { ++score_[v].activity(decay_); }
			if (mtf && (!nant_ || s.varInfo(v).nant())){
				if (mtf_.size() < mtf) {
					mtf_.push_back(v);
					std::push_heap(mtf_.begin(), mtf_.end(), comp);
				}
				else if (comp(v, mtf_[0])) {
					assert(s.level(v) <= s.level(mtf_[0]));
					std::pop_heap(mtf_.begin(), mtf_.end(), comp);
					mtf_.back() = v;
					std::push_heap(mtf_.begin(), mtf_.end(), comp);
				}
			}
		}
		for (VarVec::size_type i = 0; i != mtf_.size(); ++i) {
			Var v = mtf_[i];
			if (score_[v].pos_ != vars_.end()) {
				vars_.splice(vars_.begin(), vars_, score_[v].pos_);
			}
		}
		mtf_.clear();
		front_ = vars_.begin();
	}
}

void ClaspVmtf::undoUntil(const Solver&, LitVec::size_type) {
	front_ = vars_.begin();
}

void ClaspVmtf::updateReason(const Solver& s, const LitVec& lits, Literal r) {
	if (scType_ > HeuParams::score_min) {
		const bool  ms = scType_ == HeuParams::score_multi_set;
		const uint32 D = decay_;
		for (LitVec::size_type i = 0, e = lits.size(); i != e; ++i) {
			if (ms || !s.seen(lits[i])) { ++score_[lits[i].var()].activity(D); }
		}
	}
	if (scType_ & 1u) { ++score_[r.var()].activity(decay_); }
}

bool ClaspVmtf::bump(const Solver&, const WeightLitVec& lits, double adj) {
	for (WeightLitVec::const_iterator it = lits.begin(), end = lits.end(); it != end; ++it) {
		score_[it->first.var()].activity(decay_) += static_cast(it->second*adj);
	}
	return true;
}

Literal ClaspVmtf::doSelect(Solver& s) {
	decay_ += ((s.stats.choices + 1) & 511) == 0;
	for (; s.value(*front_) != value_free; ++front_) {;}
	Literal c;
	if (s.numFreeVars() > 1) {
		VarList::iterator v2 = front_;
		uint32 distance = 0;
		do {
			++v2;
			++distance;
		} while (s.value(*v2) != value_free);
		c = (score_[*front_].activity(decay_) + (distance<<1)+ 3) > score_[*v2].activity(decay_)
		    ? selectLiteral(s, *front_, score_[*front_].occ_)
		    : selectLiteral(s, *v2, score_[*v2].occ_);
	}
	else {
		c = selectLiteral(s, *front_, score_[*front_].occ_);
	}
	return c;
}

Literal ClaspVmtf::selectRange(Solver&, const Literal* first, const Literal* last) {
	Literal best = *first;
	for (++first; first != last; ++first) {
		if (score_[first->var()].activity(decay_) > score_[best.var()].activity(decay_)) {
			best = *first;
		}
	}
	return best;
}

/////////////////////////////////////////////////////////////////////////////////////////
// ClaspVsids selection strategy
/////////////////////////////////////////////////////////////////////////////////////////
static double initDecay(uint32 p) {
	double m = static_cast(p ? p : 0.95);
	while (m > 1.0) { m /= 10.0; }
	return m;
}

template 
ClaspVsids_t::ClaspVsids_t(const HeuParams& params)
	: vars_(CmpScore(score_))
	, inc_(1.0)
	, acids_(false) {
	ClaspVsids_t::setConfig(params);
}

template 
void ClaspVsids_t::setConfig(const HeuParams& params) {
	addOther(types_ = TypeSet(), params.other != HeuParams::other_auto ? params.other : static_cast(HeuParams::other_no));
	scType_ = params.score != HeuParams::score_auto ? params.score : static_cast(HeuParams::score_min);
	decay_  = Decay(params.decay.init ? initDecay(params.decay.init) : 0.0, initDecay(params.param), params.decay.bump, params.decay.freq);
	acids_  = params.acids != 0;
	nant_   = params.nant != 0;
	if (params.moms) { types_.addSet(Constraint_t::Static); }
	if (scType_ == HeuParams::score_min) { types_.addSet(Constraint_t::Conflict); }
}

template 
void ClaspVsids_t::startInit(const Solver& s) {
	score_.resize(s.numVars()+1);
	occ_.resize(s.numVars()+1);
	vars_.reserve(s.numVars() + 1);
}

template 
void ClaspVsids_t::endInit(Solver& s) {
	vars_.clear();
	initScores(s, types_.inSet(Constraint_t::Static));
	double mx = 0;
	for (Var v = 1; v <= s.numVars(); ++v) {
		if (s.value(v) != value_free) { continue; }
		mx = std::max(mx, score_[v].get());
		if (!vars_.is_in_queue(v)) { vars_.push(v); }
	}
	if (acids_ && mx > inc_) {
		inc_ = std::ceil(mx);
	}
}
template 
void ClaspVsids_t::updateVarActivity(const Solver& s, Var v, double f) {
	if (!nant_ || s.varInfo(v).nant()) {
		double o = score_[v].get(), n;
		f = ScoreType::applyFactor(score_, v, f);
		if      (!acids_)  { n = o + (f * inc_); }
		else if (f == 1.0) { n = (o + inc_) / 2.0; }
		else if (f != 0.0) { n = std::max( (o + inc_ + f) / 2.0, f + o ); }
		else               { return; }
		score_[v].set(n);
		if (n > 1e100) { normalize(); }
		if (vars_.is_in_queue(v)) {
			if (n >= o) { vars_.increase(v); }
			else        { vars_.decrease(v); }
		}
	}
}
template 
void ClaspVsids_t::updateVar(const Solver& s, Var v, uint32 n) {
	if (s.validVar(v)) {
		growVecTo(score_, v+n);
		growVecTo(occ_, v+n);
		for (uint32 end = v+n; v != end; ++v) { vars_.update(v); }
	}
	else {
		for (uint32 end = v+n; v != end; ++v) { vars_.remove(v); }
	}
}
template 
void ClaspVsids_t::initScores(Solver& s, bool moms) {
	if (!moms) { return; }
	double maxS = 0.0, ms;
	for (Var v = 1; v <= s.numVars(); ++v) {
		if (s.value(v) == value_free && score_[v].get() == 0.0 && (ms = (double)momsScore(s, v)) != 0.0) {
			maxS      = std::max(maxS, ms);
			score_[v].set(-ms);
		}
	}
	for (Var v = 1; v <= s.numVars(); ++v) {
		double d = score_[v].get();
		if (d < 0) {
			d *= -1.0;
			d /= maxS;
			score_[v].set(d);
		}
	}
}
template 
void ClaspVsids_t::simplify(const Solver& s, LitVec::size_type i) {
	for (; i < s.numAssignedVars(); ++i) {
		vars_.remove(s.trail()[i].var());
	}
}

template 
void ClaspVsids_t::normalize() {
	const double min  = std::numeric_limits::min();
	const double minD = min * 1e100;
	inc_             *= 1e-100;
	for (LitVec::size_type i = 0; i != score_.size(); ++i) {
		double d = score_[i].get();
		if (d > 0) {
			// keep relative ordering but
			// actively avoid denormals
			d += minD;
			d *= 1e-100;
		}
		score_[i].set(d);
	}
}
template 
void ClaspVsids_t::newConstraint(const Solver& s, const Literal* first, LitVec::size_type size, ConstraintType t) {
	if (t != Constraint_t::Static) {
		const bool upAct = types_.inSet(t);
		for (LitVec::size_type i = 0; i < size; ++i, ++first) {
			incOcc(*first);
			if (upAct) {
				updateVarActivity(s, first->var());
			}
		}
		if (t == Constraint_t::Conflict) {
			if (decay_.next && --decay_.next == 0 && decay_.lo < decay_.hi) {
				decay_.lo  += decay_.bump / 100.0;
				decay_.next = decay_.freq;
				decay_.df   = 1.0 / decay_.lo;
			}
			if (!acids_) { inc_ *= decay_.df; }
			else         { inc_ += 1.0; }
		}
	}
}
template 
void ClaspVsids_t::updateReason(const Solver& s, const LitVec& lits, Literal r) {
	if (scType_ > HeuParams::score_min) {
		const bool ms = scType_ == HeuParams::score_multi_set;
		for (LitVec::size_type i = 0, end = lits.size(); i != end; ++i) {
			if (ms || !s.seen(lits[i])) { updateVarActivity(s, lits[i].var()); }
		}
	}
	if ((scType_ & 1u) != 0 && r.var() != 0) { updateVarActivity(s, r.var()); }
}
template 
bool ClaspVsids_t::bump(const Solver& s, const WeightLitVec& lits, double adj) {
	double mf = 1.0, f;
	for (WeightLitVec::const_iterator it = lits.begin(), end = lits.end(); it != end; ++it) {
		updateVarActivity(s, it->first.var(), (f = it->second*adj));
		if (acids_ && f > mf) { mf = f; }
	}
	if (acids_ && mf > 1.0) {
		inc_ = std::ceil(mf + inc_);
	}
	return true;
}
template 
void ClaspVsids_t::undoUntil(const Solver& s , LitVec::size_type st) {
	const LitVec& a = s.trail();
	for (; st < a.size(); ++st) {
		if (!vars_.is_in_queue(a[st].var())) {
			vars_.push(a[st].var());
		}
	}
}
template 
Literal ClaspVsids_t::doSelect(Solver& s) {
	while ( s.value(vars_.top()) != value_free ) {
		vars_.pop();
	}
	return selectLiteral(s, vars_.top(), occ(vars_.top()));
}
template 
Literal ClaspVsids_t::selectRange(Solver&, const Literal* first, const Literal* last) {
	Literal best = *first;
	for (++first; first != last; ++first) {
		if (vars_.key_compare()(first->var(), best.var())) {
			best = *first;
		}
	}
	return best;
}
template class ClaspVsids_t;

/////////////////////////////////////////////////////////////////////////////////////////
// DomainHeuristic selection strategy
/////////////////////////////////////////////////////////////////////////////////////////
DomainHeuristic::DomainHeuristic(const HeuParams& params) : ClaspVsids_t(params), domSeen_(0), defMax_(0), defMod_(0), defPref_(0) {
	frames_.push_back(Frame(0,DomAction::UNDO_NIL));
	setDefaultMod(static_cast(params.domMod), params.domPref);
}
DomainHeuristic::~DomainHeuristic() {}

void DomainHeuristic::setConfig(const HeuParams& params) {
	ClaspVsids_t::setConfig(params);
	setDefaultMod(static_cast(params.domMod), params.domPref);
}
void DomainHeuristic::setDefaultMod(HeuParams::DomMod mod, uint32 prefSet) {
	defMod_ = (uint16)mod;
	defPref_= prefSet;
}
void DomainHeuristic::detach(Solver& s) {
	if (!actions_.empty()) {
		for (DomainTable::iterator it = s.sharedContext()->heuristic.begin(), end = s.sharedContext()->heuristic.end(); it != end; ++it) {
			if (it->hasCondition()) {
				s.removeWatch(it->cond(), this);
			}
		}
	}
	while (frames_.back().dl != 0) {
		s.removeUndoWatch(frames_.back().dl, this);
		frames_.pop_back();
	}
	Var end = std::min(static_cast(score_.size()), static_cast(s.numVars() + 1));
	for (Var v = 1; v != end; ++v) {
		if (score_[v].sign) { s.setPref(v, ValueSet::user_value, value_free); }
	}
	actions_.clear();
	prios_.clear();
	domSeen_ = 0;
	defMax_  = 0;
}
void DomainHeuristic::startInit(const Solver& s) {
	BaseType::startInit(s);
	domSeen_ = std::min(domSeen_, s.sharedContext()->heuristic.size());
}
void DomainHeuristic::initScores(Solver& s, bool moms) {
	const DomainTable& domTab = s.sharedContext()->heuristic;
	BaseType::initScores(s, moms);
	uint32 nKey = (uint32)prios_.size();
	if (defMax_) {
		defMax_ = std::min(defMax_, s.numVars()) + 1;
		for (Var v = 1; v != defMax_; ++v) {
			if (score_[v].domP >= nKey) {
				bool sign = score_[v].sign;
				score_[v] = DomScore(score_[v].value);
				if (sign) { s.setPref(v, ValueSet::user_value, value_free); }
			}
		}
		defMax_ = 0;
	}
	if (domSeen_ < domTab.size()) {
		// apply new domain modifications
		VarScoreVec saved;
		Literal lastW = lit_true();
		uint32 dKey = nKey;
		for (DomainTable::iterator it = domTab.begin() + domSeen_, end = domTab.end(); it != end; ++it) {
			if (s.topValue(it->var()) != value_free || s.isFalse(it->cond())) {
				continue;
			}
			if (score_[it->var()].domP >= nKey){
				score_[it->var()].setDom(nKey++);
				prios_.push_back(DomPrio());
				prios_.back().clear();
			}
			uint32 k = addDomAction(*it, s, saved, lastW);
			if (k > dKey) { dKey = k; }
		}
		for (VarScoreVec::value_type x; !saved.empty(); saved.pop_back()) {
			x = saved.back();
			score_[x.first].value += x.second;
			score_[x.first].init   = 0;
		}
		if (!actions_.empty()) {
			actions_.back().next = 0;
		}
		if ((nKey - dKey) > dKey && s.sharedContext()->solveMode() == SharedContext::solve_once) {
			PrioVec(prios_.begin(), prios_.begin()+dKey).swap(prios_);
		}
		domSeen_ = domTab.size();
	}
	// apply default modification
	if (defMod_) {
		typedef HeuParams Dom;
		MinimizeConstraint* m = s.enumerationConstraint() ? static_cast(s.enumerationConstraint())->minimizer() : 0;
		const uint32 prefSet  = defPref_, graphSet = Dom::pref_scc | Dom::pref_hcc | Dom::pref_disj;
		const uint32 userKey  = nKey, graphKey = userKey + 1, minKey = userKey + 2, showKey = userKey + 3;
		if ((prefSet & Dom::pref_show) != 0) {
			const OutputTable& out = s.outputTable();
			for (OutputTable::pred_iterator it = out.pred_begin(), end = out.pred_end(); it != end; ++it) {
				addDefAction(s, it->cond, Dom::pref_show, showKey);
			}
			for (OutputTable::range_iterator it = out.vars_begin(), end = out.vars_end(); it != end; ++it) {
				addDefAction(s, posLit(*it), Dom::pref_show, showKey);
			}
		}
		if ((prefSet & Dom::pref_min) != 0 && m) {
			weight_t w = -1;
			int16    x = Dom::pref_show;
			for (const WeightLiteral* it = m->shared()->lits; !isSentinel(it->first); ++it) {
				if (x > 4 && it->second != w) {
					--x;
					w = it->second;
				}
				addDefAction(s, it->first, x, minKey);
			}
		}
		if ((prefSet & graphSet) != 0 && s.sharedContext()->sccGraph.get()) {
			for (uint32 i = 0; i !=  s.sharedContext()->sccGraph->numAtoms(); ++i) {
				const PrgDepGraph::AtomNode& a = s.sharedContext()->sccGraph->getAtom(i);
				int16 lev = 0;
				if      ((prefSet & Dom::pref_disj) != 0 && a.inDisjunctive()){ lev = 3; }
				else if ((prefSet & Dom::pref_hcc) != 0 && a.inNonHcf())      { lev = 2; }
				else if ((prefSet & Dom::pref_scc) != 0)                      { lev = 1; }
				addDefAction(s, a.lit, lev, graphKey);
			}
		}
		if (!prefSet) {
			for (Var v = 1, end = s.numVars() + 1; v != end; ++v) {
				if ((s.varInfo(v).type() & Var_t::Atom) != 0) { addDefAction(s, posLit(v), 1, userKey); }
			}
		}
	}
	if (&s == s.sharedContext()->master() && domTab.domRec) {
		LitVec& min = *domTab.domRec;
		for (Var v = 1, end = s.numVars() + 1; v != end; ++v) {
			if (score_[v].sign && score_[v].level > 0 && s.value(v) == value_free) {
				ValueRep val = s.pref(v).get(ValueSet::user_value);
				if (val != value_false) { min.push_back(negLit(v)); }
				if (val != value_true)  { min.push_back(posLit(v)); }
			}
		}
	}
}

uint32 DomainHeuristic::addDomAction(const DomMod& e, Solver& s, VarScoreVec& initOut, Literal& lastW) {
	if (e.comp()) {
		DomMod level(e.var(), DomModType::Level, e.bias(), e.prio(), e.cond());
		DomMod sign(e.var(), DomModType::Sign, e.type() == DomModType::True ? 1 : -1, e.prio(), e.cond());
		uint32 k1 = addDomAction(level, s, initOut, lastW);
		uint32 k2 = addDomAction(sign, s, initOut, lastW);
		return std::max(k1, k2);
	}
	bool isStatic = !e.hasCondition() || s.topValue(e.cond().var()) == trueValue(e.cond());
	uint16& sPrio = prio(e.var(), e.type());
	if (e.prio() < sPrio || (!isStatic && e.type() == DomModType::Init)) {
		return 0;
	}
	if (e.type() == DomModType::Init) {
		if (score_[e.var()].init == 0) {
			initOut.push_back(std::make_pair(e.var(), score_[e.var()].value));
			score_[e.var()].init = 1;
		}
		score_[e.var()].value = e.bias();
		return 0;
	}
	DomAction a = { e.var(), (uint32)e.type(), DomAction::UNDO_NIL, uint32(0), e.bias(), e.prio() };
	if (a.mod == DomModType::Sign && a.bias != 0) {
		a.bias = a.bias > 0 ? value_true : value_false;
	}
	CLASP_FAIL_IF(e.type() != a.mod, "Invalid dom modifier!");
	if (isStatic) {
		applyAction(s, a, sPrio);
		score_[e.var()].sign |= static_cast(e.type() == DomModType::Sign);
		return 0;
	}
	if (e.cond() != lastW) {
		s.addWatch(lastW = e.cond(), this, (uint32)actions_.size());
	}
	else {
		actions_.back().next = 1;
	}
	actions_.push_back(a);
	return score_[e.var()].domP + 1;
}

void DomainHeuristic::addDefAction(Solver& s, Literal x, int16 lev, uint32 domKey) {
	if (s.value(x.var()) != value_free || score_[x.var()].domP < domKey) { return; }
	const bool signMod = defMod_ <  HeuParams::mod_init && ((defMod_ & HeuParams::mod_init) != 0);
	const bool valMod  = defMod_ >= HeuParams::mod_init || ((defMod_ & HeuParams::mod_level)!= 0);
	if (score_[x.var()].domP > domKey && lev && valMod) {
		if      (defMod_ < HeuParams::mod_init) { score_[x.var()].level += lev; }
		else if (defMod_ == HeuParams::mod_init) { score_[x.var()].value += (lev*100); }
		else if (defMod_ == HeuParams::mod_factor) {
			int16 f = 1;
			while (lev >>= 2) { ++f; }
			score_[x.var()].factor += f;
		}
	}
	if (signMod && score_[x.var()].sign == 0) {
		s.setPref(x.var(), ValueSet::user_value, (defMod_ & HeuParams::mod_spos) != 0 ? trueValue(x) : falseValue(x));
		score_[x.var()].sign = 1;
	}
	if (x.var() > defMax_) {
		defMax_ = x.var();
	}
	score_[x.var()].setDom(domKey);
}


Literal DomainHeuristic::doSelect(Solver& s) {
	Literal x = BaseType::doSelect(s);
	s.stats.addDomChoice(score_[x.var()].isDom());
	return x;
}

Constraint::PropResult DomainHeuristic::propagate(Solver& s, Literal, uint32& aId) {
	uint32 n = aId;
	uint32 D = s.decisionLevel();
	do {
		DomAction& a = actions_[n];
		uint16& prio = this->prio(a.var, a.mod);
		if (s.value(a.var) == value_free && a.prio >= prio) {
			applyAction(s, a, prio);
			if (D != frames_.back().dl) {
				s.addUndoWatch(D, this);
				frames_.push_back(Frame(D, DomAction::UNDO_NIL));
			}
			pushUndo(frames_.back().head, n);
		}
	} while (actions_[n++].next);
	return PropResult(true, true);
}

void DomainHeuristic::applyAction(Solver& s, DomAction& a, uint16& gPrio) {
	std::swap(gPrio, a.prio);
	switch (a.mod) {
		default: assert(false); break;
		case DomModType::Factor: std::swap(score_[a.var].factor, a.bias); break;
		case DomModType::Level:
			std::swap(score_[a.var].level, a.bias);
			if (vars_.is_in_queue(a.var)) { vars_.update(a.var); }
			break;
		case DomModType::Sign:
			int16 old = s.pref(a.var).get(ValueSet::user_value);
			s.setPref(a.var, ValueSet::user_value, ValueRep(a.bias));
			a.bias    = old;
			break;
	}
}
void DomainHeuristic::pushUndo(uint32& head, uint32 actionId) {
	actions_[actionId].undo = head;
	head = actionId;
}

void DomainHeuristic::undoLevel(Solver& s) {
	while (frames_.back().dl >= s.decisionLevel()) {
		for (uint32 n = frames_.back().head; n != DomAction::UNDO_NIL;) {
			DomAction& a = actions_[n];
			n            = a.undo;
			applyAction(s, a, prio(a.var, a.mod));
		}
		frames_.pop_back();
	}
}
template class ClaspVsids_t;
}
clasp-3.2.2/libclasp/src/logic_program.cpp000066400000000000000000002245001304134206100205250ustar00rootroot00000000000000//
// Copyright (c) 2013-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp { namespace Asp {
/////////////////////////////////////////////////////////////////////////////////////////
// Statistics
/////////////////////////////////////////////////////////////////////////////////////////
#define RK(x) RuleStats::x
const char* RuleStats::toStr(int k) {
	CLASP_FAIL_IF(k < 0 || uint32(k) > numKeys(), "Invalid key");
	switch (k) {
		case Normal   : return "Normal";
		case Choice   : return "Choice";
		case Minimize : return "Minimize";
		case Acyc     : return "Acyc";
		case Heuristic: return "Heuristic";
		default:        return "None";
	}
}
uint32 RuleStats::sum() const {
	return std::accumulate(key, key + numKeys(), uint32(0));
}
const char* BodyStats::toStr(int t) {
	CLASP_FAIL_IF(t < 0 || uint32(t) >= numKeys(), "Invalid body type!");
	switch (t) {
		default           : return "Normal";
		case Body_t::Count: return "Count";
		case Body_t::Sum  : return "Sum";
	}
}
uint32 BodyStats::sum() const {
	return std::accumulate(key, key + numKeys(), uint32(0));
}

namespace {
template 
double sumBodies(const LpStats* self) { return self->bodies[i].sum(); }
template 
double sumRules(const LpStats* self) { return self->rules[i].sum(); }
double sumEqs(const LpStats* self)   { return self->eqs(); }
}
#define LP_STATS( APPLY )                                        \
	APPLY("atoms"               , VALUE(atoms))                  \
	APPLY("atoms_aux"           , VALUE(auxAtoms))               \
	APPLY("disjunctions"        , VALUE(disjunctions[0]))        \
	APPLY("disjunctions_non_hcf", VALUE(disjunctions[1]))        \
	APPLY("bodies"              , FUNC(sumBodies<0>))            \
	APPLY("bodies_tr"           , FUNC(sumBodies<1>))            \
	APPLY("sum_bodies"          , VALUE(bodies[0][Body_t::Sum])) \
	APPLY("sum_bodies_tr"       , VALUE(bodies[1][Body_t::Sum])) \
	APPLY("count_bodies"        , VALUE(bodies[0][Body_t::Count]))\
	APPLY("count_bodies_tr"     , VALUE(bodies[1][Body_t::Count]))\
	APPLY("sccs"                , VALUE(sccs))                   \
	APPLY("sccs_non_hcf"        , VALUE(nonHcfs))                \
	APPLY("gammas"              , VALUE(gammas))                 \
	APPLY("ufs_nodes"           , VALUE(ufsNodes))               \
	APPLY("rules"               , FUNC(sumRules<0>))             \
	APPLY("rules_normal"        , VALUE(rules[0][RK(Normal)]))   \
	APPLY("rules_choice"        , VALUE(rules[0][RK(Choice)]))   \
	APPLY("rules_minimize"      , VALUE(rules[0][RK(Minimize)])) \
	APPLY("rules_acyc"          , VALUE(rules[0][RK(Acyc)]))     \
	APPLY("rules_heuristic"     , VALUE(rules[0][RK(Heuristic)]))\
	APPLY("rules_tr"            , FUNC(sumRules<1>))             \
	APPLY("rules_tr_normal"     , VALUE(rules[1][RK(Normal)]))   \
	APPLY("rules_tr_choice"     , VALUE(rules[1][RK(Choice)]))   \
	APPLY("rules_tr_minimize"   , VALUE(rules[1][RK(Minimize)])) \
	APPLY("rules_tr_acyc"       , VALUE(rules[1][RK(Acyc)]))     \
	APPLY("rules_tr_heuristic"  , VALUE(rules[1][RK(Heuristic)]))\
	APPLY("eqs"                 , FUNC(sumEqs))                  \
	APPLY("eqs_atom"            , VALUE(eqs_[Var_t::Atom-1]))    \
	APPLY("eqs_body"            , VALUE(eqs_[Var_t::Body-1]))    \
	APPLY("eqs_other"           , VALUE(eqs_[Var_t::Hybrid-1]))

void LpStats::reset() {
	std::memset(this, 0, sizeof(LpStats));
}

void LpStats::accu(const LpStats& o) {
	atoms    += o.atoms;
	auxAtoms += o.auxAtoms;
	ufsNodes += o.ufsNodes;
	if (sccs == PrgNode::noScc || o.sccs == PrgNode::noScc) {
		sccs    = o.sccs;
		nonHcfs = o.nonHcfs;
	}
	else {
		sccs   += o.sccs;
		nonHcfs+= o.nonHcfs;
	}
	for (int i = 0; i != 2; ++i) {
		disjunctions[i] += o.disjunctions[i];
		for (uint32 k = 0; k != BodyStats::numKeys(); ++k) {
			bodies[i][k] += o.bodies[i][k];
		}
		for (uint32 k = 0; k != RuleStats::numKeys(); ++k) {
			rules[i][k] += o.rules[i][k];
		}
	}
	for (int i = 0; i != sizeof(eqs_)/sizeof(eqs_[0]); ++i) {
		eqs_[i] += o.eqs_[i];
	}
}

static const char* lpStats_s[] = {
#define KEY(x, y) x,
	LP_STATS(KEY)
#undef KEY
	"lp"
};
uint32 LpStats::size() {
	return (sizeof(lpStats_s)/sizeof(const char*))-1;
}
const char* LpStats::key(uint32 i) {
	return i < size() ? lpStats_s[i] : throw std::out_of_range("LpStats::key");
}
StatisticObject LpStats::at(const char* k) const {
#define MAP_IF(x, A) if (std::strcmp(k, x) == 0)  return A;
#define VALUE(X) StatisticObject::value(&(X))
#define FUNC(F) StatisticObject::value(this)
	LP_STATS(MAP_IF)
#undef VALUE
#undef FUNC
#undef MAP_IF
	throw std::out_of_range("LpStats::at");
}
#undef LP_STATS
/////////////////////////////////////////////////////////////////////////////////////////
// class LogicProgram
/////////////////////////////////////////////////////////////////////////////////////////
static PrgAtom trueAtom_g(0, false);
static const uint32 falseId = PrgNode::noNode;
static const uint32 bodyId  = PrgNode::noNode + 1;
static bool init_trueAtom_g = (trueAtom_g.setEq(0), true);
inline bool isAtom(Id_t uid) { return Potassco::atom(Potassco::lit(uid)) < bodyId; }
inline bool isBody(Id_t uid) { return Potassco::atom(Potassco::lit(uid)) >= bodyId; }
inline Id_t nodeId(Id_t uid) { return Potassco::atom(Potassco::lit(uid)) - (isAtom(uid) ? 0 : bodyId); }
inline bool signId(Id_t uid) { return Potassco::lit(uid) < 0; }

namespace {
typedef std::pair AtomVal;
inline uint32 encodeExternal(Atom_t a, Potassco::Value_t value) {
	return (a << 2) | static_cast(value);
}
inline AtomVal decodeExternal(uint32 x) {
	return AtomVal(x >> 2, static_cast(x & 3u));
}
struct LessBodySize {
	LessBodySize(const BodyList& bl) : bodies_(&bl) {}
	bool operator()(Id_t b1, Id_t b2 ) const {
		return (*bodies_)[b1]->size() < (*bodies_)[b2]->size()
			|| ((*bodies_)[b1]->size() == (*bodies_)[b2]->size() && (*bodies_)[b1]->type() < (*bodies_)[b2]->type());
	}
private:
	const BodyList* bodies_;
};
// Adds nogoods representing this node to the solver.
template 
bool toConstraint(NT* node, const LogicProgram& prg, ClauseCreator& c) {
	if (node->value() != value_free && !prg.ctx()->addUnary(node->trueLit())) {
    	return false;
	}
	return !node->relevant() || node->addConstraints(prg, c);
}
}

LogicProgram::LogicProgram() : theory_(0), input_(1, UINT32_MAX), auxData_(0), incData_(0) {
	CLASP_FAIL_IF(!init_trueAtom_g, "invalid static init");
}
LogicProgram::~LogicProgram() { dispose(true); }
LogicProgram::Incremental::Incremental() : startScc(0) {}
void LogicProgram::dispose(bool force) {
	// remove rules
	std::for_each(bodies_.begin(), bodies_.end(), DestroyObject());
	std::for_each(disjunctions_.begin(), disjunctions_.end(), DestroyObject());
	std::for_each(extended_.begin(), extended_.end(), DeleteObject());
	std::for_each(minimize_.begin(), minimize_.end(), DeleteObject());
	PodVector::destruct(show_);
	delete auxData_; auxData_ = 0;
	MinList().swap(minimize_);
	RuleList().swap(extended_);
	BodyList().swap(bodies_);
	DisjList().swap(disjunctions_);
	bodyIndex_.clear();
	disjIndex_.clear();
	VarVec().swap(initialSupp_);
	if (theory_) {
		theory_->reset();
	}
	if (force || !incData_) {
		deleteAtoms(0);
		AtomList().swap(atoms_);
		AtomState().swap(atomState_);
		delete theory_;
		delete incData_;
		VarVec().swap(propQ_);
		stats.reset();
		incData_ = 0;
		theory_  = 0;
		input_   = AtomRange(1, UINT32_MAX);
		statsId_ = 0;
	}
	rule_.clear();
}
void LogicProgram::deleteAtoms(uint32 start) {
	for (AtomList::const_iterator it = atoms_.begin() + start, end = atoms_.end(); it != end; ++it) {
		if (*it != &trueAtom_g) { delete *it; }
	}
}
bool LogicProgram::doStartProgram() {
	dispose(true);
	// atom 0 is always true
	PrgAtom* trueAt = new PrgAtom(0, false);
	atoms_.push_back(trueAt);
	trueAt->assignValue(value_true);
	trueAt->setInUpper(true);
	trueAt->setLiteral(lit_true());
	atomState_.set(0, AtomState::fact_flag);
	auxData_ = new Aux();
	return true;
}
void LogicProgram::setOptions(const AspOptions& opts) {
	opts_ = opts;
	if (opts.suppMod) { opts_.noSCC = 1; }
	if (opts.suppMod && ctx() && ctx()->sccGraph.get()) {
		ctx()->warn("'supp-models' ignored for non-tight programs.");
		opts_.suppMod = 0;
		opts_.noSCC   = 0;
	}
}
ProgramParser* LogicProgram::doCreateParser() {
	return new AspParser(*this);
}
bool LogicProgram::doUpdateProgram() {
	if (!incData_) { incData_ = new Incremental(); }
	if (!frozen()) { return true; }
	// delete bodies/disjunctions...
	dispose(false);
	setFrozen(false);
	auxData_ = new Aux();
	if (theory_) { theory_->update(); }
	incData_->unfreeze.clear();
	input_.hi = std::min(input_.hi, endAtom());
	// reset prop queue and add supported atoms from previous steps
	// {ai | ai in P}.
	PrgBody* support = input_.hi > 1 ? getTrueBody() : 0;
	propQ_.clear();
	for (Atom_t i = 1, end = startAuxAtom(); i != end; ++i) {
		if (getRootId(i) >= end) {
			// atom is equivalent to some aux atom - make i the new root
			uint32 r = getRootId(i);
			std::swap(atoms_[i], atoms_[r]);
			atoms_[r]->setEq(i);
		}
		// remove dangling references
		PrgAtom* a = atoms_[i];
		a->clearSupports();
		a->clearDeps(PrgAtom::dep_all);
		a->setIgnoreScc(false);
		if (a->relevant() || a->frozen()) {
			ValueRep v = a->value();
			a->setValue(value_free);
			a->resetId(i, !a->frozen());
			if (ctx()->master()->value(a->var()) != value_free && !a->frozen()) {
				v = ctx()->master()->isTrue(a->literal()) ? value_true : value_false;
			}
			if (v != value_free) { assignValue(a, v, PrgEdge::noEdge()); }
			if (!a->frozen() && a->value() != value_false) {
				a->setIgnoreScc(true);
				support->addHead(a, PrgEdge::GammaChoice);
			}
		}
		else if (a->removed() || (!a->eq() && a->value() == value_false)) {
			a->resetId(i, true);
			a->setValue(value_false);
			atomState_.set(i, AtomState::false_flag);
		}
	}
	// delete any introduced aux atoms
	// this is safe because aux atoms are never part of the input program
	// it is necessary in order to free their ids, i.e. the id of an aux atom
	// from step I might be needed for a program atom in step I+1
	deleteAtoms(startAuxAtom());
	atoms_.erase(atoms_.begin()+startAuxAtom(), atoms_.end());
	uint32 nAtoms = (uint32)atoms_.size();
	atomState_.resize(nAtoms);
	input_ = AtomRange(nAtoms, UINT32_MAX);
	stats.reset();
	statsId_ = 0;
	return true;
}
bool LogicProgram::doEndProgram() {
	if (!frozen() && ctx()->ok()) {
		prepareProgram(!opts_.noSCC);
		addConstraints();
		addDomRules();
		addAcycConstraint();
	}
	return ctx()->ok();
}

bool LogicProgram::clone(SharedContext& oCtx) {
	assert(frozen());
	if (&oCtx == ctx()) {
		return true;
	}
	for (Var v = oCtx.numVars() + 1; ctx()->validVar(v); ++v) {
		oCtx.addVar(Var_t::Atom, ctx()->varInfo(v).rep);
	}
	SharedContext* t = ctx();
	setCtx(&oCtx);
	bool ok = addConstraints();
	if (ok) {
		oCtx.output    = ctx()->output;
		oCtx.heuristic = t->heuristic;
	}
	setCtx(t);
	return ok;
}

void LogicProgram::addMinimize() {
	CLASP_ASSERT_CONTRACT(frozen());
	for (MinList::iterator it = minimize_.begin(), end = minimize_.end(); it != end; ++it) {
		const LpWLitVec& lits = (*it)->lits;
		const weight_t   prio = (*it)->prio;
		for (LpWLitVec::const_iterator xIt = lits.begin(), xEnd = lits.end(); xIt != xEnd; ++xIt) {
			addMinLit(prio, WeightLiteral(getLiteral(Potassco::id(xIt->lit)), xIt->weight));
		}
		// Make sure minimize constraint is not empty
		if (lits.empty()) addMinLit(prio, WeightLiteral(lit_false(), 1));
	}
}
static void outRule(Potassco::AbstractProgram& out, const Rule& r) {
	if (r.normal()) { out.rule(r.ht, r.head, r.cond); }
	else            { out.rule(r.ht, r.head, r.agg.bound, r.agg.lits); }
}

void LogicProgram::accept(Potassco::AbstractProgram& out) {
	if (!ok()) {
		out.rule(Head_t::Disjunctive, Potassco::toSpan(), Potassco::toSpan());
		return;
	}
	// visit external directives
	for (VarVec::const_iterator it = auxData_->external.begin(), end = auxData_->external.end(); it != end; ++it) {
		AtomVal x = decodeExternal(*it);
		out.external(x.first, x.second);
	}
	// visit eq- and assigned atoms
	for (Atom_t i = startAtom(); i < atoms_.size(); ++i) {
		if (atoms_[i]->eq()) {
			Potassco::AtomSpan head = Potassco::toSpan(&i, 1);
			Potassco::Lit_t    body = Potassco::lit(getRootId(i));
			if (isFact(Potassco::atom(body))) {
				out.rule(Head_t::Disjunctive, head, Potassco::toSpan());
			}
			else if (inProgram(Potassco::atom(body))) {
				out.rule(Head_t::Disjunctive, head, Potassco::toSpan(&body, 1));
			}
		}
		else if (!atomState_.isFact(i) && atoms_[i]->value() != value_free) {
			Potassco::AtomSpan head = Potassco::toSpan();
			Potassco::Lit_t    body = Potassco::neg(i);
			if (atoms_[i]->value() != value_false) {
				out.rule(Head_t::Disjunctive, head, Potassco::toSpan(&body, 1));
			}
			else if (inProgram(i)) {
				body = Potassco::neg(body);
				out.rule(Head_t::Disjunctive, head, Potassco::toSpan(&body, 1));
			}
		}
	}
	// visit program rules
	const bool simp = frozen();
	using Potassco::Lit_t;
	VarVec choice;
	for (BodyList::iterator bIt = bodies_.begin(); bIt != bodies_.end(); ++bIt) {
		rule_.clear();
		choice.clear();
		Atom_t head;
		Lit_t  auxB;
		PrgBody* b = *bIt;
		if (b->relevant() && (b->inRule() || b->value() == value_false) && b->toData(*this, rule_)) {
			if (b->value() == value_false) {
				outRule(out, rule_.rule());
				continue;
			}
			uint32 numDis = 0;
			Rule r = rule_.rule();
			for (PrgBody::head_iterator hIt = b->heads_begin(); hIt != b->heads_end(); ++hIt) {
				if (hIt->isGamma() || (simp && !getHead(*hIt)->hasVar())) { continue; }
				if (hIt->isAtom() && hIt->node() && inProgram(hIt->node())) {
					if      (hIt->isNormal()) { r.head = Potassco::toSpan(&(head = hIt->node()), 1); outRule(out, r); }
					else if (hIt->isChoice()) { choice.push_back(hIt->node()); }
					if (simp && getRootAtom(hIt->node())->var() == b->var() && !r.normal()) {
						// replace complex body with head atom
						auxB = Potassco::lit(hIt->node());
						if (getRootAtom(hIt->node())->literal() != b->literal()) { auxB *= -1; }
						r.bt   = Body_t::Normal;
						r.cond = Potassco::toSpan(&auxB, 1);
					}
				}
				else if (hIt->isDisj()) { ++numDis; }
			}
			if (!choice.empty()) {
				r.head = Potassco::toSpan(choice);
				r.ht   = Head_t::Choice;
				outRule(out, r);
			}
			for (PrgBody::head_iterator hIt = b->heads_begin(); hIt != b->heads_end() && numDis; ++hIt) {
				if (hIt->isDisj()) {
					PrgDisj* d = getDisj(hIt->node());
					r.head = Potassco::toSpan(d->begin(), d->size());
					r.ht   = Head_t::Disjunctive;
					outRule(out, r);
					--numDis;
				}
			}
		}
	}
	LpWLitVec wlits;
	for (MinList::iterator it = minimize_.begin(), end = minimize_.end(); it != end; ++it) {
		Potassco::WeightLitSpan ws = Potassco::toSpan((*it)->lits);
		for (const Potassco::WeightLit_t* x = Potassco::begin(ws), *xEnd = Potassco::end(ws); x != xEnd; ++x) {
			if (x->weight == 0 || !inProgram(Potassco::atom(*x))) { // simplify literals
				wlits.assign(Potassco::begin(ws), x);
				for (; x != xEnd; ++x) {
					if (x->weight != 0 && (x->weight < 0 || x->lit < 0 || inProgram(Potassco::atom(*x)))) {
						wlits.push_back(*x);
					}
				}
				ws = Potassco::toSpan(wlits);
				break;
			}
		}
		out.minimize((*it)->prio, ws);
	}
	Potassco::LitVec lits;
	// visit output directives
	for (ShowVec::const_iterator it = show_.begin(); it != show_.end(); ++it) {
		if (extractCondition(it->first, lits)) {
			out.output(Potassco::toSpan(it->second.c_str(), std::strlen(it->second.c_str())), Potassco::toSpan(lits));
		}
	}
	// visit projection directives
	if (!auxData_->project.empty()) {
		out.project(auxData_->project.back() ? Potassco::toSpan(auxData_->project) : Potassco::toSpan());
	}
	// visit assumptions
	if (!auxData_->assume.empty()) {
		out.assume(Potassco::toSpan(auxData_->assume));
	}
	// visit heuristics
	if (!auxData_->dom.empty()) {
		for (DomRules::const_iterator it = auxData_->dom.begin(), end = auxData_->dom.end(); it != end; ++it) {
			if (extractCondition(it->cond, lits)) {
				out.heuristic(it->atom, static_cast(it->type), it->bias, it->prio, Potassco::toSpan(lits));
			}
		}
	}
	// visit acyc edges
	if (!auxData_->acyc.empty()) {
		for (AcycRules::const_iterator it = auxData_->acyc.begin(), end = auxData_->acyc.end(); it != end; ++it) {
			if (extractCondition(it->cond, lits)) {
				out.acycEdge(it->node[0], it->node[1], Potassco::toSpan(lits));
			}
		}
	}
	if (theory_ && theory_->numAtoms()) {
		struct This : public Potassco::TheoryData::Visitor {
			This(const Asp::LogicProgram& p, Potassco::AbstractProgram& o, Potassco::LitVec& c) : self(&p), out(&o), cond(&c) {}
			virtual void visit(const Potassco::TheoryData& data, Potassco::Id_t termId, const Potassco::TheoryTerm& t) {
				if (!addSeen(termId, 1)) { return; }
				data.accept(t, *this);
				Potassco::print(*out, termId, t);
			}
			virtual void visit(const Potassco::TheoryData& data, Potassco::Id_t elemId, const Potassco::TheoryElement& e) {
				if (!addSeen(elemId, 2)) { return; }
				data.accept(e, *this);
				cond->clear();
				if (e.condition()) { self->extractCondition(e.condition(), *cond); }
				out->theoryElement(elemId, e.terms(), Potassco::toSpan(*cond));
			}
			virtual void visit(const Potassco::TheoryData& data, const Potassco::TheoryAtom& a) {
				data.accept(a, *this);
				Potassco::print(*out, a);
				const Atom_t id = a.atom();
				if (self->validAtom(id) && self->atomState_.isSet(id, AtomState::false_flag) && !self->inProgram(id)) {
					Potassco::Lit_t x = Potassco::lit(id);
					out->rule(Head_t::Disjunctive, Potassco::toSpan(), Potassco::toSpan(&x, 1));
				}
			}
			bool addSeen(Potassco::Id_t id, unsigned char n) {
				if (id >= seen.size()) { seen.resize(id + 1, 0); }
				unsigned char old = seen[id];
				return (seen[id] |= n) != old;
			}
			typedef PodVector::type IdSet;
			const Asp::LogicProgram*   self;
			Potassco::AbstractProgram* out;
			Potassco::LitVec*          cond;
			IdSet                      seen;
		} self(*this, out, lits);
		theory_->accept(self);
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// Program mutating functions
/////////////////////////////////////////////////////////////////////////////////////////
#define check_not_frozen() CLASP_ASSERT_CONTRACT_MSG(!frozen(), "Can't update frozen program!")
#define check_modular(x, atomId) (void)( (!!(x)) || (throw RedefinitionError((atomId), this->findName((atomId))), 0))
RedefinitionError::RedefinitionError(unsigned atomId, const char* name)
	: std::logic_error(ClaspStringBuffer().appendFormat("redefinition of atom <'%s',%u>", name && *name ? name : "_", atomId).c_str()) {
}

Atom_t LogicProgram::newAtom() {
	check_not_frozen();
	Atom_t id = static_cast(atoms_.size());
	atoms_.push_back( new PrgAtom(id) );
	return id;
}
Id_t LogicProgram::newCondition(const Potassco::LitSpan& cond) {
	check_not_frozen();
	SRule meta;
	if (simplifyNormal(Head_t::Disjunctive, Potassco::toSpan(), cond, rule_, meta)) {
		Rule r = rule_.rule();
		if (r.cond.size == 0) { return 0; }
		if (r.cond.size == 1) { return Potassco::id(r.cond[0]); }
		PrgBody* b = getBodyFor(r, meta);
		b->markFrozen();
		return static_cast(Clasp::Asp::bodyId | b->id());
	}
	return static_cast(Clasp::Asp::falseId);
}
LogicProgram& LogicProgram::addOutput(const ConstString& str, const Potassco::LitSpan& cond) {
	if (!ctx()->output.filter(str)) {
		CLASP_FAIL_IF(cond.size == 1 && Potassco::atom(cond[0]) >= bodyId, "Atom out of bounds");
		show_.push_back(ShowPair(cond.size == 1 ? Potassco::id(cond[0]) : newCondition(cond), str));
	}
	return *this;
}
LogicProgram& LogicProgram::addOutput(const ConstString& str, Id_t id) {
	if (!ctx()->output.filter(str) && id != falseId) {
		show_.push_back(ShowPair(id, str));
	}
	return *this;
}

LogicProgram& LogicProgram::addProject(const Potassco::AtomSpan& atoms) {
	check_not_frozen();
	VarVec& pro = auxData_->project;
	if (!Potassco::empty(atoms)) {
		if (!pro.empty() && pro.back() == 0) { pro.pop_back(); }
		pro.insert(pro.end(), Potassco::begin(atoms), Potassco::end(atoms));
	}
	else if (pro.empty()) {
		pro.push_back(0);
	}
	return *this;
}

TheoryData& LogicProgram::theoryData() {
	if (!theory_) { theory_ = new TheoryData(); }
	return *theory_;
}

void LogicProgram::pushFrozen(PrgAtom* atom, ValueRep value) {
	if (!atom->frozen()) { frozen_.push_back(atom->id()); }
	atom->markFrozen(value);
}

LogicProgram& LogicProgram::addExternal(Atom_t atomId, Potassco::Value_t value) {
	check_not_frozen();
	PrgAtom* a = resize(atomId);
	if (a->supports() == 0 && (isNew(a->id()) || a->frozen())) {
		ValueRep fv = static_cast(value);
		if (value == Potassco::Value_t::Release) {
			// add dummy edge - will be removed once we update the set of frozen atoms
			a->addSupport(PrgEdge::noEdge());
			fv = value_free;
		}
		pushFrozen(a, fv);
		auxData_->external.push_back(encodeExternal(a->id(), value));
	}
	return *this;
}

LogicProgram& LogicProgram::freeze(Atom_t atomId, ValueRep value) {
	CLASP_ASSERT_CONTRACT(value < value_weak_true);
	return addExternal(atomId, static_cast(value));
}

LogicProgram& LogicProgram::unfreeze(Atom_t atomId) {
	return addExternal(atomId, Potassco::Value_t::Release);
}
void LogicProgram::setMaxInputAtom(uint32 n) {
	check_not_frozen();
	resize(n++);
	CLASP_ASSERT_CONTRACT_MSG(n >= startAtom(), "invalid input range");
	input_.hi = n;
}
Atom_t LogicProgram::startAuxAtom() const {
	return validAtom(input_.hi) ? input_.hi : (uint32)atoms_.size();
}
bool LogicProgram::supportsSmodels() const {
	if (incData_ || theory_)        { return false; }
	if (!auxData_->dom.empty())     { return false; }
	if (!auxData_->acyc.empty())    { return false; }
	if (!auxData_->assume.empty())  { return false; }
	if (!auxData_->project.empty()) { return false; }
	for (ShowVec::const_iterator it = show_.begin(), end = show_.end(); it != end; ++it) {
		Potassco::Lit_t lit = Potassco::lit(it->first);
		if (lit <= 0 || static_cast(lit) >= bodyId) { return false; }
	}
	return true;
}

bool LogicProgram::isExternal(Atom_t aId) const {
	if (!aId || !validAtom(aId)) { return false; }
	PrgAtom* a = getRootAtom(aId);
	return a->frozen() && (a->supports() == 0 || frozen());
}
bool LogicProgram::isFact(Atom_t aId) const {
	return validAtom(aId) && (atomState_.isFact(aId) || atomState_.isFact(getRootId(aId)));
}
bool LogicProgram::isDefined(Atom_t aId) const {
	if (!validAtom(aId) || getAtom(aId)->removed()) {
		return false;
	}
	PrgAtom* a = getAtom(aId);
	return isFact(aId) || (a->relevant() && a->supports() && !isExternal(aId));
}
bool LogicProgram::inProgram(Atom_t id) const {
	if (PrgAtom* a = (validAtom(id) ? getAtom(id) : 0)) {
		return a->relevant() && (a->supports() || a->frozen() || !isNew(id));
	}
	return false;
}
LogicProgram& LogicProgram::addAssumption(const Potassco::LitSpan& lits) {
	auxData_->assume.insert(auxData_->assume.end(), Potassco::begin(lits), Potassco::end(lits));
	return *this;
}

LogicProgram& LogicProgram::addAcycEdge(uint32 n1, uint32 n2, Id_t condId) {
	if (condId != falseId) {
		AcycArc arc = { condId, {n1, n2} };
		auxData_->acyc.push_back(arc);
	}
	upStat(RK(Acyc), 1);
	return *this;
}

LogicProgram& LogicProgram::addDomHeuristic(Atom_t atom, DomModType t, int bias, unsigned prio) {
	return addDomHeuristic(atom, t, bias, prio, Potassco::toSpan());
}
LogicProgram& LogicProgram::addDomHeuristic(Atom_t atom, DomModType type, int bias, unsigned prio, Id_t cond) {
	static_assert(sizeof(DomRule) == sizeof(uint32[3]), "Invalid DomRule size");
	if (cond != falseId) {
		auxData_->dom.push_back(DomRule());
		DomRule& x = auxData_->dom.back();
		x.atom = atom;
		x.type = type;
		x.cond = cond;
		x.bias = (int16)Range(INT16_MIN, INT16_MAX).clamp(bias);
		x.prio = (uint16)Range(unsigned(0), unsigned(~uint16(0)) ).clamp(prio);
	}
	upStat(RK(Heuristic), 1);
	return *this;
}
LogicProgram& LogicProgram::addRule(const Rule& rule) {
	check_not_frozen();
	SRule meta;
	if (simplifyRule(rule, rule_, meta)) {
		Rule sRule = rule_.rule();
		upStat(sRule.ht);
		if (handleNatively(sRule)) { // and can be handled natively
			addRule(sRule, meta);
		}
		else {
			upStat(sRule.bt);
			if (Potassco::size(sRule.head) <= 1 && transformNoAux(sRule)) {
				// rule transformation does not require aux atoms - do it now
				int oId  = statsId_;
				statsId_ = 1;
				RuleTransform tm(*this);
				upStat(sRule.bt, -1);
				upStat(rule.ht, -1);
				tm.transform(sRule, RuleTransform::strategy_select_no_aux);
				statsId_ = oId;
			}
			else {
				// make sure we have all head atoms
				for (Potassco::AtomSpan::iterator it = Potassco::begin(sRule.head), end = Potassco::end(sRule.head); it != end; ++it) {
					resize(*it);
				}
				extended_.push_back(new RuleBuilder(rule_));
			}
		}
	}
	rule_.clear();
	return *this;
}

LogicProgram& LogicProgram::addRule(Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body) {
	return addRule(Rule::normal(ht, head, body));
}
LogicProgram& LogicProgram::addRule(Head_t ht, const Potassco::AtomSpan& head, Potassco::Weight_t bound, const Potassco::WeightLitSpan& lits) {
	return addRule(Rule::sum(ht, head, bound, lits));
}
LogicProgram& LogicProgram::addRule(Potassco::RuleBuilder& rb) {
	LogicProgramAdapter prg(*this);
	rb.end(&prg);
	return *this;
}
LogicProgram& LogicProgram::addMinimize(weight_t prio, const Potassco::WeightLitSpan& lits) {
	SingleOwnerPtr n(new Min());
	n->prio = prio;
	MinList::iterator it = std::lower_bound(minimize_.begin(), minimize_.end(), n.get(), CmpMin());
	if (it == minimize_.end() || (*it)->prio != prio) {
		n->lits.assign(Potassco::begin(lits), Potassco::end(lits));
		minimize_.insert(it, n.get());
		n.release();
		upStat(RuleStats::Minimize);
	}
	else {
		(*it)->lits.insert((*it)->lits.end(), Potassco::begin(lits), Potassco::end(lits));
	}
	return *this;
}
#undef check_not_frozen
/////////////////////////////////////////////////////////////////////////////////////////
// Query functions
/////////////////////////////////////////////////////////////////////////////////////////
bool LogicProgram::isFact(PrgAtom* a) const {
	uint32 eqId = getRootId(a->id());
	if (atomState_.isFact(eqId)) {
		return true;
	}
	if (a->value() == value_true) {
		for (PrgAtom::sup_iterator it = a->supps_begin(), end = a->supps_end(); it != end; ++it) {
			if (it->isBody() && it->isNormal() && getBody(it->node())->bound() == 0) {
				return true;
			}
		}
	}
	return false;
}
Literal LogicProgram::getLiteral(Id_t id) const {
	Literal out = lit_false();
	Potassco::Id_t nId = nodeId(id);
	if (isAtom(id) && validAtom(nId)) {
		out = getRootAtom(nId)->literal();
	}
	else if (isBody(id)) {
		CLASP_FAIL_IF(!validBody(nId), "Invalid condition");
		out = getBody(getEqBody(nId))->literal();
	}
	return out ^ signId(id);
}
Literal LogicProgram::getDomLiteral(Atom_t atomId) const {
	IndexMap::const_iterator it = domEqIndex_.find(atomId);
	return it == domEqIndex_.end() ? getLiteral(atomId) : posLit(it->second);
}

void LogicProgram::doGetAssumptions(LitVec& out) const {
	for (VarVec::const_iterator it = frozen_.begin(), end = frozen_.end(); it != end; ++it) {
		Literal lit = getRootAtom(*it)->assumption();
		if (lit != lit_true()) { out.push_back( lit ); }
	}
	for (Potassco::LitVec::const_iterator it = auxData_->assume.begin(), end = auxData_->assume.end(); it != end; ++it) {
		out.push_back(getLiteral(Potassco::id(*it)));
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// Program definition - private
/////////////////////////////////////////////////////////////////////////////////////////
void LogicProgram::addRule(const Rule& r, const SRule& meta) {
	if (Potassco::size(r.head) <= 1 && r.ht == Head_t::Disjunctive) {
		if      (Potassco::empty(r.head))        { addIntegrity(r, meta); return; }
		else if (r.normal() && r.cond.size == 0) { addFact(r.head); return; }
	}
	PrgBody* b = getBodyFor(r, meta);
	// only a non-false body can define atoms
	if (b->value() != value_false) {
		bool const disjunctive = Potassco::size(r.head) > 1 && r.ht == Head_t::Disjunctive;
		const EdgeType t = r.ht == Head_t::Disjunctive ? PrgEdge::Normal : PrgEdge::Choice;
		uint32 headHash = 0;
		bool ignoreScc  = opts_.noSCC || b->size() == 0;
		for (Potassco::AtomSpan::iterator it = Potassco::begin(r.head), end = Potassco::end(r.head); it != end; ++it) {
			PrgAtom* a = resize(*it);
			check_modular(isNew(*it) || a->frozen() || a->value() == value_false, *it);
			if (!disjunctive) {
				// Note: b->heads may now contain duplicates. They are removed in PrgBody::simplifyHeads.
				b->addHead(a, t);
				if (ignoreScc) { a->setIgnoreScc(ignoreScc); }
			}
			else {
				headHash += hashLit(posLit(*it));
				atomState_.addToHead(*it);
			}
		}
		if (disjunctive) {
			PrgDisj* d = getDisjFor(r.head, headHash);
			b->addHead(d, t);
		}
	}
}
void LogicProgram::addFact(const Potassco::AtomSpan& head) {
	PrgBody* tb = 0;
	for (Potassco::AtomSpan::iterator it = Potassco::begin(head), end = Potassco::end(head); it != end; ++it) {
		PrgAtom* a = resize(*it);
		check_modular(isNew(*it) || a->frozen() || a->value() == value_false, *it);
		if (*it != a->id() || atomState_.isFact(*it)) { continue; }
		a->setIgnoreScc(true);
		atomState_.set(*it, AtomState::fact_flag);
		if (!a->hasDep(PrgAtom::dep_all) && !a->frozen()) {
			if (!a->assignValue(value_true) || !a->propagateValue(*this, false)) {
				setConflict();
			}
			for (PrgAtom::sup_iterator bIt = a->supps_begin(), bEnd = a->supps_end(); bIt != bEnd; ++bIt) {
				if      (bIt->isBody()) { getBody(bIt->node())->markHeadsDirty(); }
				else if (bIt->isDisj()) { getDisj(bIt->node())->markDirty(); }
			}
			atoms_[*it] = &trueAtom_g;
			delete a;
		}
		else {
			if (!tb) tb = getTrueBody();
			tb->addHead(a, PrgEdge::Normal);
			assignValue(a, value_true, PrgEdge::newEdge(*tb, PrgEdge::Normal));
		}
	}
}
void LogicProgram::addIntegrity(const Rule& r, const SRule& meta) {
	if (r.sum() || r.cond.size != 1 || meta.bid != varMax) {
		PrgBody* B = getBodyFor(r, meta);
		if (!B->assignValue(value_false) || !B->propagateValue(*this, true)) {
			setConflict();
		}
	}
	else {
		PrgAtom* a = resize(Potassco::atom(r.cond[0]));
		ValueRep v = r.cond[0] > 0 ? value_false : value_weak_true;
		assignValue(a, v, PrgEdge::noEdge());
	}
}
bool LogicProgram::assignValue(PrgAtom* a, ValueRep v, PrgEdge reason) {
	if (a->eq()) { a = getRootAtom(a->id()); }
	ValueRep old = a->value();
	if (old == value_weak_true && v != value_weak_true) old = value_free;
	if (!a->assignValue(v)) { setConflict(); return false; }
	if (old == value_free)  { propQ_.push_back(a->id());  }
	if (v == value_false) {
		atomState_.set(a->id(), AtomState::false_flag);
	}
	else if (v == value_true && reason.isBody() && reason.isNormal() && getBody(reason.node())->bound() == 0) {
		atomState_.set(a->id(), AtomState::fact_flag);
	}
	return true;
}
bool LogicProgram::assignValue(PrgHead* h, ValueRep v, PrgEdge reason) {
	return !h->isAtom() || assignValue(static_cast(h), v, reason);
}

bool LogicProgram::handleNatively(const Rule& r) const {
	ExtendedRuleMode m = opts_.erMode;
	if (m == mode_native || (r.normal() && r.ht == Head_t::Disjunctive)) {
		return true;
	}
	else if (m == mode_transform_integ || m == mode_transform_scc || m == mode_transform_nhcf) {
		return true;
	}
	else if (m == mode_transform) {
		return false;
	}
	else if (m == mode_transform_dynamic) {
		return r.normal() || transformNoAux(r) == false;
	}
	else if (m == mode_transform_choice) {
		return r.ht != Head_t::Choice;
	}
	else if (m == mode_transform_card)   {
		return r.bt != Body_t::Count;
	}
	else if (m == mode_transform_weight) {
		return r.normal();
	}
	assert(false && "unhandled extended rule mode");
	return true;
}

bool LogicProgram::transformNoAux(const Rule& r) const {
	return r.ht == Head_t::Disjunctive && r.sum() && (r.agg.bound == 1 || (Potassco::size(r.agg.lits) <= 6 && choose(toU32(Potassco::size(r.agg.lits)), r.agg.bound) <= 15));
}

void LogicProgram::transformExtended() {
	uint32 a = numAtoms();
	RuleTransform tm(*this);
	for (RuleList::size_type i = 0; i != extended_.size(); ++i) {
		Rule r = extended_[i]->rule();
		upStat(r.ht, -1);
		upStat(r.bt, -1);
		if (r.normal() || (r.ht == Head_t::Disjunctive && Potassco::size(r.head) < 2)) {
			tm.transform(r);
		}
		else {
			using Potassco::Lit_t;
			Atom_t aux = newAtom();
			Lit_t auxB = Potassco::lit(aux);
			Rule rAux1 = r; // aux :- body
			rAux1.ht   = Head_t::Disjunctive;
			rAux1.head = Potassco::toSpan(&aux, 1);
			Rule rAux2 = Rule::normal(r.ht, r.head, Potassco::toSpan(&auxB, 1));  // head :- auxB
			if (handleNatively(rAux1)) { addRule(rAux1); }
			else {
				RuleTransform::Strategy st = transformNoAux(rAux1) ? RuleTransform::strategy_select_no_aux : RuleTransform::strategy_default;
				tm.transform(rAux1, st);
			}
			if (handleNatively(rAux2)) { addRule(rAux2); }
			else                       { tm.transform(rAux2); }
		}
		delete extended_[i];
	}
	extended_.clear();
	incTrAux(numAtoms() - a);
}

void LogicProgram::transformIntegrity(uint32 nAtoms, uint32 maxAux) {
	if (stats.bodies[1][Body_t::Count] == 0) { return; }
	// find all constraint rules that are integrity constraints
	BodyList integrity;
	for (uint32 i = 0, end = static_cast(bodies_.size()); i != end; ++i) {
		PrgBody* b = bodies_[i];
		if (b->relevant() && b->type() == Body_t::Count && b->value() == value_false) {
			integrity.push_back(b);
		}
	}
	if (!integrity.empty() && (integrity.size() == 1 || (nAtoms/double(bodies_.size()) > 0.5 && integrity.size() / double(bodies_.size()) < 0.01))) {
		uint32 aux = static_cast(atoms_.size());
		RuleTransform tr(*this);
		RuleBuilder temp;
		// transform integrity constraints
		for (BodyList::size_type i = 0; i != integrity.size(); ++i) {
			PrgBody* b = integrity[i];
			uint32 est = b->bound()*( b->sumW()-b->bound() );
			if (est > maxAux) {
				// reached limit on aux atoms - stop transformation
				break;
			}
			if (b->toData(*this, temp) && temp.bodyType() != Body_t::Normal) {
				maxAux -= est;
				// transform rule
				setFrozen(false);
				upStat(Head_t::Disjunctive, -1);
				upStat(Body_t::Count, -1);
				tr.transform(Rule::sum(Head_t::Disjunctive, Potassco::toSpan(), temp.bound(), Potassco::toSpan(temp.sum(), temp.bodySize())));
				setFrozen(true);
				// propagate integrity condition to new rules
				propagate(true);
				b->markRemoved();
			}
			temp.clear();
		}
		// create vars for new atoms/bodies
		for (uint32 i = aux; i != atoms_.size(); ++i) {
			PrgAtom* a = atoms_[i];
			for (PrgAtom::sup_iterator it = a->supps_begin(); it != a->supps_end(); ++it) {
				PrgBody* nb = bodies_[it->node()];
				assert(nb->value() != value_false);
				nb->assignVar(*this);
			}
			a->assignVar(*this, a->supports() ? *a->supps_begin() : PrgEdge::noEdge());
		}
		incTrAux(static_cast(atoms_.size()) - aux);
	}
}

void LogicProgram::prepareExternals() {
	if (auxData_->external.empty()) { return; }
	VarVec& external = auxData_->external;
	VarVec::iterator j = external.begin();
	for (VarVec::const_iterator it = j, end = external.end(); it != end; ++it) {
		Atom_t id = getRootId(decodeExternal(*it).first);
		const PrgAtom* atom = getAtom(id);
		if (!atomState_.inHead(id) && (atom->supports() == 0 || *atom->supps_begin() == PrgEdge::noEdge())) {
			Potassco::Value_t value = atom->supports() == 0 ? static_cast(atom->freezeValue()) : Potassco::Value_t::Release;
			atomState_.addToHead(id);
			*j++ = encodeExternal(id, value);
		}
	}
	for (VarVec::const_iterator it = external.begin(), end = external.end(); it != end; ++it) {
		atomState_.clearRule(decodeExternal(*it).first);
	}
}
void LogicProgram::updateFrozenAtoms() {
	if (frozen_.empty()) { return; }
	PrgBody* support   = 0;
	VarVec::iterator j = frozen_.begin();
	for (VarVec::const_iterator it = j, end = frozen_.end(); it != end; ++it) {
		Id_t id = getRootId(*it);
 		PrgAtom* a = getAtom(id);
		assert(a->frozen());
		a->resetId(id, false);
		if (a->supports() == 0) {
			assert(a->relevant());
			CLASP_ASSERT_CONTRACT_MSG(id < startAuxAtom(), "frozen atom shall be an input atom");
			if (!support) { support = getTrueBody(); }
			a->setIgnoreScc(true);
			support->addHead(a, PrgEdge::GammaChoice);
			*j++ = id; // still frozen
		}
		else {
			a->clearFrozen();
			if (*a->supps_begin() == PrgEdge::noEdge()) {
				// remove dummy edge added in unfreeze()
				a->removeSupport(PrgEdge::noEdge());
			}
			if (!isNew(id) && incData_) {
				// add to unfreeze so that we can later perform completion
				incData_->unfreeze.push_back(id);
			}
		}
	}
	frozen_.erase(j, frozen_.end());
}

void LogicProgram::prepareProgram(bool checkSccs) {
	assert(!frozen());
	prepareExternals();
	// Given that freezeTheory() might introduce otherwise
	// unused atoms, it must be called before we fix the
	// number of input atoms.
	freezeTheory();
	uint32 nAtoms = (input_.hi = std::min(input_.hi, endAtom()));
	stats.auxAtoms += endAtom() - nAtoms;
	for (uint32 i = 0; i != RuleStats::numKeys(); ++i) {
		stats.rules[1][i] += stats.rules[0][i];
	}
	for (uint32 i = 0; i != BodyStats::numKeys(); ++i) {
		stats.bodies[1][i] += stats.bodies[0][i];
	}
	statsId_ = 1;
	transformExtended();
	updateFrozenAtoms();
	PrgAtom* suppAtom = 0;
	if (opts_.suppMod) {
		VarVec h;
		suppAtom  = getAtom(newAtom());
		h.assign(1, suppAtom->id());
		addRule(Head_t::Choice, Potassco::toSpan(h), Potassco::toSpan());
		Potassco::Lit_t body = Potassco::lit(suppAtom->id());
		h.clear();
		for (Atom_t v = startAtom(), end = suppAtom->id(); v != end; ++v) {
			if (atoms_[v]->supports() != 0) { h.push_back(v); }
		}
		addRule(Head_t::Choice, Potassco::toSpan(h), Potassco::toSpan(&body, 1));
	}
	setFrozen(true);
	Preprocessor p;
	if (hasConflict() || !propagate(true) || !p.preprocess(*this, opts_.iters != 0 ? Preprocessor::full_eq : Preprocessor::no_eq, opts_.iters, opts_.dfOrder != 0)) {
		setConflict();
		return;
	}
	if (suppAtom && (!assignValue(suppAtom, value_false, PrgEdge::noEdge()) || !propagate(true))) {
		setConflict();
		return;
	}
	if (opts_.erMode == mode_transform_integ || opts_.erMode == mode_transform_dynamic) {
		nAtoms -= startAtom();
		transformIntegrity(nAtoms, std::min(uint32(15000), nAtoms*2));
	}
	addMinimize();
	uint32 sccs = 0;
	if (checkSccs) {
		uint32 startScc = incData_ ? incData_->startScc : 0;
		SccChecker c(*this, auxData_->scc, startScc);
		sccs       = c.sccs();
		stats.sccs = (sccs-startScc);
		if (incData_) { incData_->startScc = c.sccs(); }
		if (!disjunctions_.empty() || (opts_.erMode == mode_transform_scc && sccs)) {
			// reset node ids changed by scc checking
			for (uint32 i = 0; i != bodies_.size(); ++i) {
				if (getBody(i)->relevant()) { getBody(i)->resetId(i, true); }
			}
			for (uint32 i = 0; i != atoms_.size(); ++i) {
				if (getAtom(i)->relevant()) { getAtom(i)->resetId(i, true); }
			}
		}
	}
	else { stats.sccs = PrgNode::noScc; }
	finalizeDisjunctions(p, sccs);
	prepareComponents();
	prepareOutputTable();
	if (theory_) {
		TFilter f = { this };
		theory_->filter(f);
	}
	stats.atoms = static_cast(atoms_.size()) - startAtom();
	bodyIndex_.clear();
	disjIndex_.clear();
}
void LogicProgram::freezeTheory() {
	if (theory_) {
		for (TheoryData::atom_iterator it = theory_->currBegin(), end = theory_->end(); it != end; ++it) {
			const Potassco::TheoryAtom& a = **it;
			if (isFact(a.atom()) || !isNew(a.atom())) { continue; }
			PrgAtom* atom = resize(a.atom());
			if (!atom->frozen() && atom->supports() == 0 && atom->relevant()) {
				pushFrozen(atom, value_free);
			}
		}
	}
}
bool LogicProgram::TFilter::operator()(const Potassco::TheoryAtom& a) const {
	Atom_t id = a.atom();
	if (self->getLiteral(id) != lit_false() && self->getRootAtom(id)->value() != value_false) {
		self->ctx()->setFrozen(self->getLiteral(id).var(), true);
		return false;
	}
	PrgAtom* at = self->getRootAtom(id);
	return !at->frozen();
}
struct LogicProgram::DlpTr : public RuleTransform::ProgramAdapter {
	DlpTr(LogicProgram* x, EdgeType et) : self(x), type(et), scc(PrgNode::noScc) {}
	Atom_t newAtom() {
		Atom_t x   = self->newAtom();
		PrgAtom* a = self->getAtom(x);
		a->setScc(scc);
		a->setSeen(true);
		atoms.push_back(x);
		if (scc != PrgNode::noScc) { self->auxData_->scc.push_back(a); }
		return x;
	}
	virtual void addRule(const Rule& r) {
		SRule meta;
		if (!self->simplifyRule(r, rule, meta)) { return; }
		bool gamma = type == PrgEdge::Gamma;
		Rule rs = rule.rule();
		PrgAtom* a = self->getAtom(rs.head[0]);
		PrgBody* B = self->assignBodyFor(rs, meta, type, gamma);
		if (B->value() != value_false && !B->hasHead(a, PrgEdge::Normal)) {
			B->addHead(a, type);
			self->stats.gammas += uint32(gamma);
		}
	}
	void assignAuxAtoms() {
		self->incTrAux(sizeVec(atoms));
		while (!atoms.empty()) {
			PrgAtom* ax = self->getAtom(atoms.back());
			atoms.pop_back();
			if (ax->supports()) {
				ax->setInUpper(true);
				ax->assignVar(*self, *ax->supps_begin());
			}
			else { self->assignValue(ax, value_false, PrgEdge::noEdge()); }
		}
	}
	LogicProgram* self;
	EdgeType      type;
	uint32        scc;
	VarVec        atoms;
	RuleBuilder   rule;
};

// replace disjunctions with gamma (shifted) and delta (component-shifted) rules
void LogicProgram::finalizeDisjunctions(Preprocessor& p, uint32 numSccs) {
	if (disjunctions_.empty()) { return; }
	VarVec head; BodyList supports;
	disjIndex_.clear();
	SccMap sccMap;
	sccMap.resize(numSccs, 0);
	enum SccFlag { seen_scc = 1u, is_scc_non_hcf = 128u };
	// replace disjunctions with shifted rules and non-hcf-disjunctions
	DisjList disj; disj.swap(disjunctions_);
	setFrozen(false);
	uint32 shifted = 0;
	stats.nonHcfs  = uint32(nonHcfs_.size());
	Literal bot    = lit_false();
	DlpTr tr(this, PrgEdge::Gamma);
	RuleTransform shifter(tr);
	Potassco::LitVec rb;
	VarVec rh;
	for (uint32 id = 0, maxId = sizeVec(disj); id != maxId; ++id) {
		PrgDisj* d = disj[id];
		Literal dx = d->inUpper() ? d->literal() : bot;
		d->resetId(id, true); // id changed during scc checking
		PrgEdge e  = PrgEdge::newEdge(*d, PrgEdge::Choice);
		// remove from program and
		// replace with shifted rules or component-shifted disjunction
		head.clear(); supports.clear();
		for (PrgDisj::atom_iterator it = d->begin(), end = d->end(); it != end; ++it) {
			uint32  aId = *it;
			PrgAtom* at = getAtom(aId);
			at->removeSupport(e);
			if (dx == bot) { continue; }
			if (at->eq())  {
				at = getAtom(aId = getRootId(aId));
			}
			if (isFact(at)){
				dx = bot;
				continue;
			}
			if (at->inUpper()) {
				head.push_back(aId);
				if (at->scc() != PrgNode::noScc){ sccMap[at->scc()] = seen_scc; }
			}
		}
		EdgeVec temp;
		d->clearSupports(temp);
		for (EdgeVec::iterator it = temp.begin(), end = temp.end(); it != end; ++it) {
			PrgBody* b = getBody(it->node());
			if (b->relevant() && b->value() != value_false) { supports.push_back(b); }
			b->removeHead(d, PrgEdge::Normal);
		}
		d->destroy();
		// create shortcut for supports to avoid duplications during shifting
		Literal supportLit = dx != bot ? getEqAtomLit(dx, supports, p, sccMap) : dx;
		// create shifted rules and split disjunctions into non-hcf components
		for (VarVec::iterator hIt = head.begin(), hEnd = head.end(); hIt != hEnd; ++hIt) {
			uint32 scc = getAtom(*hIt)->scc();
			if (scc == PrgNode::noScc || (sccMap[scc] & seen_scc) != 0) {
				if (scc != PrgNode::noScc) { sccMap[scc] &= ~seen_scc; }
				else                       { scc = UINT32_MAX; }
				rh.assign(1, *hIt);
				rb.clear();
				if (supportLit.var() != 0) { rb.push_back(toInt(supportLit)); }
				else if (supportLit.sign()){ continue; }
				for (VarVec::iterator oIt = head.begin(); oIt != hEnd; ++oIt) {
					if (oIt != hIt) {
						if (getAtom(*oIt)->scc() == scc) { rh.push_back(*oIt); }
						else                             { rb.push_back(Potassco::neg(*oIt)); }
					}
				}
				SRule meta;
				if (!simplifyRule(Rule::normal(Head_t::Disjunctive, Potassco::toSpan(rh), Potassco::toSpan(rb)), rule_, meta)) {
					continue;
				}
				Rule sr = rule_.rule();
				PrgBody* B = assignBodyFor(sr, meta, PrgEdge::Normal, true);
				if (B->value() != value_false && Potassco::size(sr.head) == 1) {
					++shifted;
					B->addHead(getAtom(sr.head[0]), PrgEdge::Normal);
				}
				else if (B->value() != value_false && Potassco::size(sr.head) > 1) {
					PrgDisj* x = getDisjFor(sr.head, 0);
					B->addHead(x, PrgEdge::Normal);
					x->assignVar(*this, *x->supps_begin());
					x->setInUpper(true);
					x->setSeen(true);
					if ((sccMap[scc] & is_scc_non_hcf) == 0) {
						sccMap[scc] |= is_scc_non_hcf;
						nonHcfs_.add(scc);
					}
					if (!options().noGamma) {
						tr.scc = scc;
						shifter.transform(sr, RuleTransform::strategy_select_no_aux);
					}
					else {
						// only add support edge
						for (PrgDisj::atom_iterator a = x->begin(), end = x->end(); a != end; ++a) {
							B->addHead(getAtom(*a), PrgEdge::GammaChoice);
						}
					}
				}
			}
		}
	}
	tr.assignAuxAtoms();
	if (!disjunctions_.empty() && nonHcfs_.config == 0) {
		nonHcfs_.config = ctx()->configuration()->config("tester");
	}
	upStat(RK(Normal), shifted);
	stats.nonHcfs = uint32(nonHcfs_.size()) - stats.nonHcfs;
	rh.clear();
	setFrozen(true);
}
// optionally transform extended rules in sccs
void LogicProgram::prepareComponents() {
	int trRec = opts_.erMode == mode_transform_scc;
	// HACK: force transformation of extended rules in non-hcf components
	// REMOVE this once minimality check supports aggregates
	if (!disjunctions_.empty() && trRec != 1) {
		trRec = 2;
	}
	if (trRec != 0) {
		DlpTr tr(this, PrgEdge::Normal);
		RuleTransform trans(tr);
		RuleBuilder temp;
		setFrozen(false);
		EdgeVec heads;
		// find recursive aggregates
		for (uint32 bIdx = 0, bEnd = numBodies(); bIdx != bEnd; ++bIdx) {
			PrgBody* B = bodies_[bIdx];
			if (B->type() == Body_t::Normal || !B->hasVar() || B->value() == value_false) { continue; } // not aggregate or not relevant
			tr.scc = B->scc(*this);
			if (tr.scc == PrgNode::noScc || (trRec == 2 && !nonHcfs_.find(tr.scc))) { continue; } // not recursive
			// transform all rules a :- B, where scc(a) == scc(B):
			heads.clear();
			for (PrgBody::head_iterator hIt = B->heads_begin(), hEnd = B->heads_end(); hIt != hEnd; ++hIt) {
				assert(hIt->isAtom());
				if (getAtom(hIt->node())->scc() == tr.scc) { heads.push_back(*hIt); }
			}
			if (heads.empty()) { continue; }
			using Potassco::Lit_t;
			Head_t ht = !isChoice(heads[0].type()) ? Head_t::Disjunctive : Head_t::Choice;
			Atom_t  h = heads[0].node();
			Lit_t aux = 0;
			if (heads.size() > 1) { // more than one head, make body eq to some new aux atom
				ht  = Head_t::Disjunctive;
				h   = tr.newAtom();
				aux = Potassco::lit(h);
			}
			temp.clear();
			if (!B->toData(*this, temp) || temp.bodyType() == Body_t::Normal) {
				B->simplify(*this, true, 0);
				continue;
			}
			trans.transform(Rule::sum(ht, Potassco::toSpan(&h, 1), temp.bound(), Potassco::toSpan(temp.sum(), temp.bodySize())));
			for (EdgeVec::const_iterator hIt = heads.begin(); hIt != heads.end(); ++hIt) {
				B->removeHead(getAtom(hIt->node()), hIt->type());
				if (h != hIt->node()) {
					ht = !isChoice(hIt->type()) ? Head_t::Disjunctive : Head_t::Choice;
					h  = hIt->node();
					tr.addRule(Rule::normal(ht, Potassco::toSpan(&h, 1), Potassco::toSpan(&aux, 1)));
				}
			}
		}
		tr.assignAuxAtoms();
		setFrozen(true);
	}
}
void LogicProgram::prepareOutputTable() {
	OutputTable& out = ctx()->output;
	// add new output predicates in program order to output table
	std::stable_sort(show_.begin(), show_.end(), compose22(std::less(), select1st(), select1st()));
	for (ShowVec::iterator it = show_.begin(), end = show_.end(); it != end; ++it) {
		Literal lit = getLiteral(it->first);
		bool isAtom = it->first < startAuxAtom();
		if      (!isSentinel(lit))  { out.add(it->second, lit, it->first); if (isAtom) ctx()->setOutput(lit.var(), true); }
		else if (lit == lit_true()) { out.add(it->second); }
	}
	if (!auxData_->project.empty()) {
		for (VarVec::const_iterator it = auxData_->project.begin(), end = auxData_->project.end(); it != end; ++it) {
			out.addProject(getLiteral(*it));
		}
	}
}
// add (completion) nogoods
bool LogicProgram::addConstraints() {
	ClauseCreator gc(ctx()->master());
	if (options().iters == 0) {
		gc.addDefaultFlags(ClauseCreator::clause_force_simplify);
	}
	ctx()->startAddConstraints();
	// handle initial conflict, if any
	if (!ctx()->ok() || !ctx()->addUnary(getTrueAtom()->trueLit())) {
		return false;
	}
	if (options().noGamma && !disjunctions_.empty()) {
		// add "rule" nogoods for disjunctions
		for (DisjList::const_iterator it = disjunctions_.begin(); it != disjunctions_.end(); ++it) {
			gc.start().add(~(*it)->literal());
			for (PrgDisj::atom_iterator a = (*it)->begin(); a != (*it)->end(); ++a) {
				gc.add(getAtom(*a)->literal());
			}
			if (!gc.end()) { return false; }
		}
	}
	// add bodies from this step
	for (BodyList::const_iterator it = bodies_.begin(); it != bodies_.end(); ++it) {
		if (!toConstraint((*it), *this, gc)) { return false; }
	}
	// add atoms thawed in this step
	for (VarIter it = unfreeze_begin(), end = unfreeze_end(); it != end; ++it) {
		if (!toConstraint(getAtom(*it), *this, gc)) { return false; }
	}
	// add atoms from this step
	const bool freezeAll = incData_ && ctx()->satPrepro.get() != 0;
	const uint32 hiAtom  = startAuxAtom();
	uint32 id = startAtom();
	for (AtomList::const_iterator it = atoms_.begin()+startAtom(), end = atoms_.end(); it != end; ++it, ++id) {
		if (!toConstraint(*it, *this, gc)) { return false; }
		if (id < hiAtom && (*it)->hasVar()){
			if (freezeAll) { ctx()->setFrozen((*it)->var(), true); }
			ctx()->setInput((*it)->var(), true);
		}
	}
	if (!auxData_->scc.empty()) {
		if (ctx()->sccGraph.get() == 0) {
			ctx()->sccGraph = new PrgDepGraph(static_cast(opts_.oldMap == 0));
		}
		uint32 oldNodes = ctx()->sccGraph->nodes();
		ctx()->sccGraph->addSccs(*this, auxData_->scc, nonHcfs_);
		stats.ufsNodes  = ctx()->sccGraph->nodes()-oldNodes;
	}
	return true;
}
void LogicProgram::addDomRules() {
	if (auxData_->dom.empty()) { return; }
	VarVec domVec;
	EqVec eqVec;
	DomRules&  doms = auxData_->dom;
	Solver const& s = *ctx()->master();
	// mark any previous domain atoms so that we can decide
	// whether existing variables can be used for the atoms in doms
	if (incData_) {
		domVec.swap(incData_->doms);
		for (VarVec::const_iterator it = domVec.begin(); it != domVec.end(); ++it) {
			if (s.value(*it) == value_free) { ctx()->mark(posLit(*it)); }
		}
	}
	DomRules::iterator j;
	IndexMap::const_iterator eq;
	DomRule r;
	for (DomRules::iterator it = (j = doms.begin()), end = doms.end(); it != end; ++it) {
		Literal cond = getLiteral(it->cond);
		Literal slit = getLiteral(it->atom);
		Var     svar = slit.var();
		if (s.isFalse(cond) || s.value(svar) != value_free) { continue; }
		if (s.isTrue(cond)) { it->cond = 0; cond = lit_true(); }
		// check if atom is the root for its var
		if (!atomState_.isSet(it->atom, AtomState::dom_flag)) {
			if (!ctx()->marked(posLit(svar))) {
				// var(it->atom) is not yet used - make it->atom its root
				ctx()->mark(posLit(svar));
				atomState_.set(it->atom, AtomState::dom_flag);
				domVec.push_back(svar);
			}
			else if ((eq = domEqIndex_.find(it->atom)) != domEqIndex_.end()) {
				// var(it->atom) is used but we already created a new var for it->atom
				slit = posLit(svar = eq->second);
			}
			else {
				// var(it->atom) is used - introduce new aux var and make it eq to lit(atom)
				Eq n = { ctx()->addVar(Var_t::Atom, VarInfo::Nant), slit };
				eqVec.push_back(n);
				svar = n.var;
				slit = posLit(svar);
				domEqIndex_.insert(IndexMap::value_type(static_cast(it->atom), svar));
			}
		}
		*j++ = (r = *it);
		if (slit.sign()) {
			if      (r.type == DomModType::Sign)  { r.bias = r.bias != 0 ? -r.bias : 0; }
			else if (r.type == DomModType::True)  { r.type = DomModType::False; }
			else if (r.type == DomModType::False) { r.type = DomModType::True; }
		}
		ctx()->heuristic.add(svar, static_cast(r.type), r.bias, r.prio, cond);
	}
	if (j != doms.end()) {
		upStat(RK(Heuristic), -static_cast(doms.end() - j));
		doms.erase(j, doms.end());
	}
	// cleanup var flags
	for (VarVec::const_iterator it = domVec.begin(); it != domVec.end(); ++it) {
		ctx()->unmark(*it);
	}
	if (incData_) {
		incData_->doms.swap(domVec);
	}
	if (!eqVec.empty()) {
		ctx()->startAddConstraints();
		for (EqVec::const_iterator it = eqVec.begin(), end = eqVec.end(); it != end; ++it) {
			// it->var == it->lit
			ctx()->addBinary(~it->lit, posLit(it->var));
			ctx()->addBinary( it->lit, negLit(it->var));
		}
	}
}

void LogicProgram::addAcycConstraint() {
	AcycRules& acyc = auxData_->acyc;
	if (acyc.empty()) { return; }
	SharedContext& ctx = *this->ctx();
	ExtDepGraph* graph = ctx.extGraph.get();
	const Solver&    s = *ctx.master();
	if (graph) { graph->update(); }
	else       { ctx.extGraph = (graph = new ExtDepGraph()); }
	for (AcycRules::const_iterator it = acyc.begin(), end = acyc.end(); it != end; ++it) {
		Literal lit = getLiteral(it->cond);
		if (!s.isFalse(lit)) {
			graph->addEdge(lit, it->node[0], it->node[1]);
		}
		else {
			upStat(RK(Acyc), -1);
		}
	}
	if (graph->finalize(ctx) == 0) { ctx.extGraph = 0; }
}
#undef check_modular
/////////////////////////////////////////////////////////////////////////////////////////
// misc/helper functions
/////////////////////////////////////////////////////////////////////////////////////////
PrgAtom* LogicProgram::resize(Atom_t atomId) {
	while (atoms_.size() <= AtomList::size_type(atomId)) {
		newAtom();
	}
	return getRootAtom(atomId);
}

bool LogicProgram::propagate(bool backprop) {
	assert(frozen());
	bool oldB = opts_.backprop != 0;
	opts_.backprop = backprop;
	for (VarVec::size_type i = 0; i != propQ_.size(); ++i) {
		PrgAtom* a = getAtom(propQ_[i]);
		if (!a->relevant()) { continue; }
		if (!a->propagateValue(*this, backprop)) {
			setConflict();
			return false;
		}
		if (a->hasVar() && a->id() < startAtom() && !ctx()->addUnary(a->trueLit())) {
			setConflict();
			return false;
		}
	}
	opts_.backprop = oldB;
	propQ_.clear();
	return true;
}
ValueRep LogicProgram::litVal(const PrgAtom* a, bool pos) const {
	if (a->value() != value_free || !a->relevant()) {
		bool vSign = a->value() == value_false || !a->relevant();
		if  (vSign == pos) { return value_false; }
		return a->value() != value_weak_true ? value_true : value_free;
	}
	return value_free;
}

// Simplifies the given normal rule H :- l1, ..., ln
//  - removes true and duplicate literals from body: {T,a,b,a} -> {a, b}.
//  - checks for contradictions and false literals in body: {a, not a} -> F
//  - checks for satisfied head and removes false atoms from head
// POST: if true out contains the simplified normal rule.
bool LogicProgram::simplifyNormal(Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body, RuleBuilder& out, SRule& meta) {
	out.clear();
	out.startBody();
	meta = SRule();
	bool ok = true;
	for (Potassco::LitSpan::iterator it = Potassco::begin(body), end = Potassco::end(body); it != end; ++it) {
		CLASP_FAIL_IF(Potassco::atom(*it) >= bodyId, "Atom out of bounds");
		PrgAtom* a = resize(Potassco::atom(*it));
		Literal  p = Literal(a->id(), *it < 0);// replace any eq atoms
		ValueRep v = litVal(a, !p.sign());
		if (v == value_false || atomState_.inBody(~p)) {
			ok = false;
			break;
		}
		else if (v != value_true  && !atomState_.inBody(p)) {
			atomState_.addToBody(p);
			out.addGoal(toInt(p));
			meta.pos  += !p.sign();
			meta.hash += hashLit(p);
		}
	}
	uint32_t bs = out.bodySize();
	meta.bid = ok ? findBody(meta.hash, Body_t::Normal, bs) : varMax;
	ok = ok && pushHead(ht, head, 0, out);
	for (const Potassco::Lit_t* it = out.body(); bs--;) {
		atomState_.clearRule(Potassco::atom(*it++));
	}
	return ok;
}

struct IsLit {
	IsLit(Potassco::Lit_t x) : lhs(x) {}
	template 
	bool operator()(const P& rhs) const { return lhs == Potassco::lit(rhs); }
	Potassco::Lit_t lhs;
};

// Simplifies the given sum rule: H :- lb { l1 = w1 ... ln = wn }.
//  - removes assigned literals and updates lb accordingly
//  - removes literals li with weight wi = 0
//  - reduces weights wi > bound() to bound
//  - merges duplicate literals in sum, i.e. lb {a=w1, b=w2, a=w3} -> lb {a=w1+w3, b=w2}
//  - checks for contradiction, i.e. sum contains both p and not p and both are needed
//  - replaces sum with count if all weights are equal
//  - replaces sum with normal body if all literals must be true for the sum to be satisfied
// POST: if true out contains the simplified rule.
bool LogicProgram::simplifySum(Head_t ht, const Potassco::AtomSpan& head, const Potassco::Sum_t& body, RuleBuilder& out, SRule& meta) {
	meta = SRule();
	weight_t bound = body.bound, maxW = 1, minW = CLASP_WEIGHT_T_MAX, sumW = 0, dirty = 0;
	out.clear();
	out.startSum(bound);
	for (Potassco::WeightLitSpan::iterator it = Potassco::begin(body.lits), end = Potassco::end(body.lits); it != end && bound > 0; ++it) {
		CLASP_ASSERT_CONTRACT_MSG(it->weight >= 0, "Non-negative weight expected!");
		CLASP_FAIL_IF(Potassco::atom(*it) >= bodyId, "Atom out of bounds");
		if (it->weight == 0) continue; // skip irrelevant lits
		PrgAtom* a = resize(Potassco::atom(*it));
		Literal  p = Literal(a->id(), Potassco::lit(*it) < 0);// replace any eq atoms
		ValueRep v = litVal(a, !p.sign());
		weight_t w = Potassco::weight(*it);
		if (v == value_true) { bound -= w; }
		else if (v != value_false) {
			CLASP_ASSERT_CONTRACT_MSG((CLASP_WEIGHT_T_MAX-sumW)>= w, "Integer overflow!");
			sumW += w;
			if (!atomState_.inBody(p)) {
				atomState_.addToBody(p);
				out.addGoal(toInt(p), w);
				meta.pos += !p.sign();
				meta.hash += hashLit(p);
			}
			else { // Merge duplicate lits
				w = (std::find_if(out.sum(), out.sum() + out.bodySize(), IsLit(Potassco::lit(*it)))->weight += w);
				++dirty;
			}
			if (w > maxW) { maxW = w; }
			if (w < minW) { minW = w; }
			dirty += static_cast(atomState_.inBody(~p));
		}
	}
	weight_t sumR = sumW;
	if (bound > 0 && (dirty || maxW > bound)) {
		sumR = 0, minW = CLASP_WEIGHT_T_MAX;
		for (Potassco::WeightLit_t* it = out.sum(), *end = out.sum() + out.bodySize(); it != end; ++it) {
			Literal  p = toLit(it->lit);
			weight_t w = it->weight;
			if (w > bound) { sumW -= (w - bound); it->weight = (maxW = w = bound); }
			if (w < minW) { minW = w; }
			sumR += w;
			if (p.sign() && atomState_.inBody(~p)) {
				// body contains p and ~p: we can achieve at most max(weight(p), weight(~p))
				sumR -= std::min(w, std::find_if(out.sum(), end, IsLit(Potassco::neg(it->lit)))->weight);
			}
		}
	}
	out.setBound(bound);
	if (bound <= 0 || sumR < bound) {
		for (const Potassco::WeightLit_t* it = out.sum(), *end = out.sum() + out.bodySize(); it != end; ++it) { atomState_.clearRule(Potassco::atom(*it)); }
		return bound <= 0 && simplifyNormal(ht, head, Potassco::toSpan(), out, meta);
	}
	else if ((sumW - minW) < bound) {
		out.weaken(Body_t::Normal);
		meta.bid = findBody(meta.hash, Body_t::Normal, out.bodySize());
		bool ok = pushHead(ht, head, 0, out);
		for (const Potassco::Lit_t* it = out.body(), *end = it + out.bodySize(); it != end; ++it) {
			atomState_.clearRule(Potassco::atom(*it));
		}
		return ok;
	}
	else if (minW == maxW) {
		out.weaken(Body_t::Count, maxW != 1);
		bound = out.bound();
	}
	meta.bid = findBody(meta.hash, out.bodyType(), out.bodySize(), out.bound(), out.sum());
	bool ok  = pushHead(ht, head, sumW - out.bound(), out);
	for (const Potassco::WeightLit_t* it = out.sum(), *end = it + out.bodySize(); it != end; ++it) {
		atomState_.clearRule(Potassco::atom(*it));
	}
	return ok;
}

// Pushes the given rule head to the body given in out.
// Pre: Body literals are marked and lits is != 0 if body is a sum.
bool LogicProgram::pushHead(Head_t ht, const Potassco::AtomSpan& head, weight_t slack, RuleBuilder& out) {
	const uint8 ignoreMask = AtomState::false_flag|AtomState::head_flag;
	uint32 hs = 0;
	bool sat = false, sum = out.bodyType() == Body_t::Sum;
	out.start(ht);
	for (Potassco::AtomSpan::iterator it = Potassco::begin(head), end = Potassco::end(head); it != end; ++it) {
		if (!atomState_.isSet(*it, AtomState::simp_mask)) {
			out.addHead(*it);
			atomState_.addToHead(*it);
			++hs;
		}
		else if (!atomState_.isSet(*it, ignoreMask)) { // h occurs in B+ and/or B- or is true
			weight_t wp = weight_t(atomState_.inBody(posLit(*it))), wn = weight_t(atomState_.inBody(negLit(*it)));
			if (wp && sum) { wp = std::find_if(out.sum(), out.sum() + out.bodySize(), IsLit(Potassco::lit(*it)))->weight; }
			if (wn && sum) { wn = std::find_if(out.sum(), out.sum() + out.bodySize(), IsLit(Potassco::neg(*it)))->weight; }
			if (atomState_.isFact(*it) || wp > slack) { sat = true; }
			else if (wn <= slack) {
				out.addHead(*it);
				atomState_.addToHead(*it);
				++hs;
			}
		}
	}
	for (const Atom_t* it = out.head(), *end = it + hs; it != end; ++it) {
		atomState_.clearRule(*it);
	}
	return !sat || (ht == Head_t::Choice && hs);
}

bool LogicProgram::simplifyRule(const Rule& r, Potassco::RuleBuilder& out, SRule& meta) {
	return r.normal()
		? simplifyNormal(r.ht, r.head, r.cond, out, meta)
		: simplifySum(r.ht, r.head, r.agg, out, meta);
}
// create new atom aux representing supports, i.e.
// aux == S1 v ... v Sn
Literal LogicProgram::getEqAtomLit(Literal lit, const BodyList& supports, Preprocessor& p, const SccMap& sccMap) {
	if (supports.empty() || lit == lit_false()) {
		return lit_false();
	}
	else if (supports.size() == 1 && supports[0]->size() < 2) {
		return supports[0]->size() == 0 ? lit_true() : supports[0]->goal(0);
	}
	else if (p.getRootAtom(lit) != varMax) {
		return posLit(p.getRootAtom(lit));
	}
	incTrAux(1);
	Atom_t auxV  = newAtom();
	PrgAtom* aux = getAtom(auxV);
	uint32 scc   = PrgNode::noScc;
	aux->setLiteral(lit);
	aux->setSeen(true);
	p.setRootAtom(aux->literal(), auxV);
	for (BodyList::const_iterator sIt = supports.begin(); sIt != supports.end(); ++sIt) {
		PrgBody* b = *sIt;
		if (b->relevant() && b->value() != value_false) {
			for (uint32 g = 0; scc == PrgNode::noScc && g != b->size() && !b->goal(g).sign(); ++g) {
				uint32 aScc = getAtom(b->goal(g).var())->scc();
				if (aScc != PrgNode::noScc && (sccMap[aScc] & 1u)) { scc = aScc; }
			}
			b->addHead(aux, PrgEdge::Normal);
			if (b->value() != value_free && !assignValue(aux, b->value(), PrgEdge::newEdge(*b, PrgEdge::Normal))) {
				break;
			}
			aux->setInUpper(true);
		}
	}
	if (!aux->inUpper()) {
		aux->setValue(value_false);
		return lit_false();
	}
	else if (scc != PrgNode::noScc) {
		aux->setScc(scc);
		auxData_->scc.push_back(aux);
	}
	return posLit(auxV);
}

PrgBody* LogicProgram::getBodyFor(const Rule& r, const SRule& meta, bool addDeps) {
	if (meta.bid < bodies_.size()) {
		return getBody(meta.bid);
	}
	// no corresponding body exists, create a new object
	PrgBody* b = PrgBody::create(*this, numBodies(), r, meta.pos, addDeps);
	bodyIndex_.insert(IndexMap::value_type(meta.hash, b->id()));
	bodies_.push_back(b);
	if (b->isSupported()) {
		initialSupp_.push_back(b->id());
	}
	upStat(r.bt);
	return b;
}
PrgBody* LogicProgram::getTrueBody() {
	uint32 id = findBody(0, Body_t::Normal, 0);
	if (id < bodies_.size()) {
		return getBody(id);
	}
	return getBodyFor(Rule::normal(Head_t::Choice, Potassco::toSpan(), Potassco::toSpan()), SRule());
}
PrgBody* LogicProgram::assignBodyFor(const Rule& r, const SRule& meta, EdgeType depEdge, bool simpStrong) {
	PrgBody* b = getBodyFor(r, meta, depEdge != PrgEdge::Gamma);
	if (!b->hasVar() && !b->seen()) {
		uint32 eqId;
		b->markDirty();
		b->simplify(*this, simpStrong, &eqId);
		if (eqId != b->id()) {
			assert(b->id() == bodies_.size()-1);
			removeBody(b, meta.hash);
			bodies_.pop_back();
			if (depEdge != PrgEdge::Gamma) {
				for (uint32 i = 0; i != b->size(); ++i) {
					getAtom(b->goal(i).var())->removeDep(b->id(), !b->goal(i).sign());
				}
			}
			b->destroy();
			b = bodies_[eqId];
		}
	}
	b->setSeen(true);
	b->assignVar(*this);
	return b;
}

bool LogicProgram::equalLits(const PrgBody& b, const WeightLitSpan& lits) const {
	WeightLitSpan::iterator lBeg = Potassco::begin(lits), lEnd = Potassco::end(lits);
	for (uint32 i = 0, end = b.size(); i != end; ++i) {
		Potassco::WeightLit_t wl = { toInt(b.goal(i)), b.weight(i) };
		if (!std::binary_search(lBeg, lEnd, wl)) { return false; }
	}
	return true;
}

// Pre: all literals in body are marked.
uint32 LogicProgram::findBody(uint32 hash, Body_t type, uint32 size, weight_t bound, Potassco::WeightLit_t* sum) {
	IndexRange bodies = bodyIndex_.equal_range(hash);
	bool sorted = false;
	if (type == Body_t::Normal) { bound = static_cast(size); }
	for (IndexIter it = bodies.first; it != bodies.second; ++it) {
		const PrgBody& b = *getBody(it->second);
		if (!checkBody(b, type, size, bound) || !atomState_.inBody(b.goals_begin(), b.goals_end())) {
			continue;
		}
		else if (!b.hasWeights()) {
			return b.id();
		}
		else if (sum) {
			if (!sorted) {
				std::sort(sum, sum + size);
				sorted = true;
			}
			if (equalLits(b, Potassco::toSpan(sum, size))) { return b.id(); }
		}
	}
	return varMax;
}

uint32 LogicProgram::findEqBody(const PrgBody* b, uint32 hash) {
	IndexRange bodies = bodyIndex_.equal_range(hash);
	if (bodies.first == bodies.second)  { return varMax;  }
	uint32 eqId = varMax, n = 0;
	for (IndexIter it = bodies.first; it != bodies.second && eqId == varMax; ++it) {
		const PrgBody& rhs = *getBody(it->second);
		if (!checkBody(rhs, b->type(), b->size(), b->bound())) { continue; }
		else if (b->size() == 0)  { eqId = rhs.id(); }
		else if (b->size() == 1)  { eqId = b->goal(0) == rhs.goal(0) && b->weight(0) == rhs.weight(0) ? rhs.id() : varMax; }
		else {
			if (++n == 1) { std::for_each(b->goals_begin(), b->goals_end(), std::bind1st(std::mem_fun(&AtomState::addToBody), &atomState_)); }
			if      (!atomState_.inBody(rhs.goals_begin(), rhs.goals_end())) { continue; }
			else if (!b->hasWeights()) { eqId = rhs.id(); }
			else {
				if (n == 1 || rule_.bodySize() == 0) {
					rule_.clear();
					if (!b->toData(*this, rule_) || rule_.bodyType() != Body_t::Sum) {
						rule_.clear();
						continue;
					}
					std::sort(rule_.sum(), rule_.sum() + rule_.bodySize());
				}
				if (equalLits(rhs, Potassco::toSpan(rule_.sum(), rule_.bodySize()))) { eqId = rhs.id(); }
			}
		}
	}
	if (n) {
		rule_.clear();
		std::for_each(b->goals_begin(), b->goals_end(), std::bind1st(std::mem_fun(&AtomState::clearBody), &atomState_));
	}
	return eqId;
}

PrgDisj* LogicProgram::getDisjFor(const Potassco::AtomSpan& head, uint32 headHash) {
	PrgDisj* d = 0;
	if (headHash) {
		LogicProgram::IndexRange eqRange = disjIndex_.equal_range(headHash);
		for (; eqRange.first != eqRange.second; ++eqRange.first) {
			PrgDisj& o = *disjunctions_[eqRange.first->second];
			if (o.relevant() && o.size() == Potassco::size(head) && atomState_.allMarked(o.begin(), o.end(), AtomState::head_flag)) {
				assert(o.id() == eqRange.first->second);
				d = &o;
				break;
			}
		}
		for (Potassco::AtomSpan::iterator it = Potassco::begin(head), end = Potassco::end(head); it != end; ++it) {
			atomState_.clearRule(*it);
		}
	}
	if (!d) {
		// no corresponding disjunction exists, create a new object
		// and link it to all atoms
		++stats.disjunctions[statsId_];
		d = PrgDisj::create((uint32)disjunctions_.size(), head);
		disjunctions_.push_back(d);
		PrgEdge edge = PrgEdge::newEdge(*d, PrgEdge::Choice);
		for (Potassco::AtomSpan::iterator it = Potassco::begin(head), end = Potassco::end(head); it != end; ++it) {
			getAtom(*it)->addSupport(edge);
		}
		if (headHash) {
			disjIndex_.insert(IndexMap::value_type(headHash, d->id()));
		}
	}
	return d;
}

// body has changed - update index
uint32 LogicProgram::update(PrgBody* body, uint32 oldHash, uint32 newHash) {
	uint32 id   = removeBody(body, oldHash);
	if (body->relevant()) {
		uint32 eqId = findEqBody(body, newHash);
		if (eqId == varMax) {
			// No equivalent body found.
			// Add new entry to index
			bodyIndex_.insert(IndexMap::value_type(newHash, id));
		}
		return eqId;
	}
	return varMax;
}

// body b has changed - remove old entry from body node index
uint32 LogicProgram::removeBody(PrgBody* b, uint32 hash) {
	IndexRange ra = bodyIndex_.equal_range(hash);
	uint32 id     = b->id();
	for (; ra.first != ra.second; ++ra.first) {
		if (bodies_[ra.first->second] == b) {
			id = ra.first->second;
			bodyIndex_.erase(ra.first);
			break;
		}
	}
	return id;
}

PrgAtom* LogicProgram::mergeEqAtoms(PrgAtom* a, Id_t rootId) {
	PrgAtom* root = getAtom(rootId = getRootId(rootId));
	ValueRep mv   = getMergeValue(a, root);
	assert(!a->eq() && !root->eq() && !a->frozen());
	if (a->ignoreScc()) { root->setIgnoreScc(true); }
	if (mv != a->value()    && !assignValue(a, mv, PrgEdge::noEdge()))   { return 0; }
	if (mv != root->value() && !assignValue(root, mv, PrgEdge::noEdge())){ return 0; }
	a->setEq(rootId);
	incEqs(Var_t::Atom);
	return root;
}

// returns whether posSize(root) <= posSize(body)
bool LogicProgram::positiveLoopSafe(PrgBody* body, PrgBody* root) const {
	uint32 i = 0, end = std::min(body->size(), root->size());
	while (i != end && body->goal(i).sign() == root->goal(i).sign()) { ++i; }
	return i == root->size() || root->goal(i).sign();
}

PrgBody* LogicProgram::mergeEqBodies(PrgBody* b, Id_t rootId, bool hashEq, bool atomsAssigned) {
	PrgBody* root = getBody(rootId = getEqNode(bodies_, rootId));
	bool     bp   = options().backprop != 0;
	if (b == root) { return root; }
	assert(!b->eq() && !root->eq() && (hashEq || b->literal() == root->literal()));
	if (!b->simplifyHeads(*this, atomsAssigned) || (b->value() != root->value() && (!mergeValue(b, root) || !root->propagateValue(*this, bp) || !b->propagateValue(*this, bp)))) {
		setConflict();
		return 0;
	}
	if (hashEq || positiveLoopSafe(b, root)) {
		b->setLiteral(root->literal());
		if (!root->mergeHeads(*this, *b, atomsAssigned, !hashEq)) {
			setConflict();
			return 0;
		}
		incEqs(Var_t::Body);
		b->setEq(rootId);
		return root;
	}
	return b;
}

const char* LogicProgram::findName(Atom_t x) const {
	for (OutputTable::pred_iterator it = ctx()->output.pred_begin(), end = ctx()->output.pred_end(); it != end; ++it) {
		if (it->user == x) { return it->name; }
	}
	for (ShowVec::const_iterator it = show_.begin(), end = show_.end(); it != end; ++it) {
		if (it->first == x){ return it->second; }
	}
	return "";
}
VarVec& LogicProgram::getSupportedBodies(bool sorted) {
	if (sorted) {
		std::stable_sort(initialSupp_.begin(), initialSupp_.end(), LessBodySize(bodies_));
	}
	return initialSupp_;
}

Atom_t LogicProgram::falseAtom() {
	Atom_t aFalse = 0;
	for (Var i = 1; i < atoms_.size() && !aFalse; ++i) {
		if (atoms_[i]->value() == value_false || atomState_.isSet(i, AtomState::false_flag)) {
			aFalse = i;
		}
	}
	if (!aFalse) {
		bool s = frozen();
		setFrozen(false);
		aFalse = newAtom();
		assignValue(getAtom(aFalse), value_false, PrgEdge::noEdge());
		setFrozen(s);
	}
	return aFalse;
}

bool LogicProgram::extractCondition(Id_t id, Potassco::LitVec& out) const {
	out.clear();
	if (id == Clasp::Asp::falseId || (frozen() && getLiteral(id) == lit_false())) { return false; }
	if (!id || isAtom(id)) {
		out.assign(id != 0, Potassco::lit(id));
		return true;
	}
	Id_t bId = nodeId(id);
	CLASP_FAIL_IF(!validBody(bId), "Invalid literal");
	const PrgBody* B = getBody(getEqBody(bId));
	out.reserve(B->size());
	for (PrgBody::goal_iterator it = B->goals_begin(), end = B->goals_end(); it != end; ++it) {
		out.push_back( toInt(*it) );
	}
	return true;
}
#undef RT
/////////////////////////////////////////////////////////////////////////////////////////
// class LogicProgramAdapter
/////////////////////////////////////////////////////////////////////////////////////////
LogicProgramAdapter::LogicProgramAdapter(LogicProgram& prg) : lp_(&prg), inc_(false) {}
void LogicProgramAdapter::initProgram(bool inc) {
	inc_ = inc;
}
void LogicProgramAdapter::beginStep() {
	if (inc_ || lp_->frozen()) { lp_->updateProgram(); }
}
void LogicProgramAdapter::endStep() {

}
void LogicProgramAdapter::rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body) {
	lp_->addRule(ht, head, body);
}
void LogicProgramAdapter::rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, Potassco::Weight_t bound, const Potassco::WeightLitSpan& body) {
	lp_->addRule(ht, head, bound, body);
}
void LogicProgramAdapter::minimize(Potassco::Weight_t prio, const Potassco::WeightLitSpan& lits) {
	lp_->addMinimize(prio, lits);
}
void LogicProgramAdapter::project(const Potassco::AtomSpan& atoms) {
	lp_->addProject(atoms);
}
void LogicProgramAdapter::output(const Potassco::StringSpan& str, const Potassco::LitSpan& cond) {
	lp_->addOutput(ConstString(str), cond);
}
void LogicProgramAdapter::external(Potassco::Atom_t a, Potassco::Value_t v) {
	lp_->addExternal(a, v);
}
void LogicProgramAdapter::assume(const Potassco::LitSpan& lits) {
	lp_->addAssumption(lits);
}
void LogicProgramAdapter::heuristic(Potassco::Atom_t a, Potassco::Heuristic_t t, int bias, unsigned prio, const Potassco::LitSpan& cond) {
	lp_->addDomHeuristic(a, t, bias, prio, cond);
}
void LogicProgramAdapter::acycEdge(int s, int t, const Potassco::LitSpan& cond) {
	lp_->addAcycEdge(static_cast(s), static_cast(t), cond);
}
void LogicProgramAdapter::theoryTerm(Potassco::Id_t termId, int number) {
	lp_->theoryData().addTerm(termId, number);
}
void LogicProgramAdapter::theoryTerm(Potassco::Id_t termId, const Potassco::StringSpan& name) {
	lp_->theoryData().addTerm(termId, name);
}
void LogicProgramAdapter::theoryTerm(Potassco::Id_t termId, int cId, const Potassco::IdSpan& args) {
	if (cId >= 0) { lp_->theoryData().addTerm(termId, static_cast(cId), args); }
	else { lp_->theoryData().addTerm(termId, static_cast(cId), args); }
}
void LogicProgramAdapter::theoryElement(Potassco::Id_t elementId, const Potassco::IdSpan& terms, const Potassco::LitSpan& cond) {
	lp_->theoryData().addElement(elementId, terms, lp_->newCondition(cond));
}
void LogicProgramAdapter::theoryAtom(Potassco::Id_t atomOrZero, Potassco::Id_t termId, const Potassco::IdSpan& elements) {
	lp_->theoryData().addAtom(atomOrZero, termId, elements);
}
void LogicProgramAdapter::theoryAtom(Potassco::Id_t atomOrZero, Potassco::Id_t termId, const Potassco::IdSpan& elements, Potassco::Id_t op, Potassco::Id_t rhs) {
	lp_->theoryData().addAtom(atomOrZero, termId, elements, op, rhs);
}
} } // end namespace Asp

clasp-3.2.2/libclasp/src/logic_program_types.cpp000066400000000000000000001356341304134206100217620ustar00rootroot00000000000000//
// Copyright (c) 2006-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 

namespace Clasp {
namespace Asp {
static_assert((bk_lib::detail::same_type::value), "unexpected weight type");
static_assert((bk_lib::detail::same_type::value)       , "unexpected atom type");
static_assert((bk_lib::detail::same_type::value)      , "unexpected id type");
static_assert((bk_lib::detail::same_type::value)      , "unexpected literal type");
static_assert((bk_lib::detail::same_type::value)   , "unexpected weight type");
/////////////////////////////////////////////////////////////////////////////////////////
// class RuleTransform
//
// class for transforming extended rules to normal rules
/////////////////////////////////////////////////////////////////////////////////////////
struct RuleTransform::Impl {
	Impl() : adapt_(0), prg_(0) { }
	struct TodoItem {
		TodoItem(uint32 i, weight_t w, Atom_t v) : idx(i), bound(w), head(v) {}
		uint32   idx;
		weight_t bound;
		Atom_t   head;
	};
	struct CmpW {
		template 
		bool operator()(const P& lhs, const P& rhs) const {
			return Potassco::weight(lhs) > Potassco::weight(rhs);
		}
	};
	typedef PodQueue TodoQueue;
	typedef Potassco::LitVec  LitVec;
	typedef Potassco::WLitVec WLitVec;
	ProgramAdapter* adapt_;
	LogicProgram*   prg_;
	LitVec          lits_;
	WLitVec         agg_;
	SumVec          sumR_;
	VarVec          aux_;
	TodoQueue       todo_;
	weight_t        bound_;
	Atom_t newAtom() const { return prg_ ? prg_->newAtom() : adapt_->newAtom(); }
	uint32 addRule(const Rule& r) const {
		if (prg_){ prg_->addRule(r); }
		else     { adapt_->addRule(r); }
		return 1;
	}
	uint32 addRule(Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& b) const {
		return addRule(Rule::normal(ht, head, b));
	}
	uint32 addRule(Atom_t h, const Potassco::LitSpan& b) const {
		return addRule(Head_t::Disjunctive, Potassco::toSpan(&h, static_cast(h != 0)), b);
	}
	uint32 transform(Atom_t head, weight_t bound, const Potassco::WeightLitSpan& lits, Strategy s);
	uint32 transformSelect(Atom_t head);
	uint32 transformSplit(Atom_t head);
	uint32 transformChoice(const Potassco::AtomSpan& r);
	uint32 transformDisjunction(const Potassco::AtomSpan& r);
	uint32 addRule(Atom_t head, bool add, uint32 idx, weight_t bound);
	Atom_t getAuxVar(uint32 idx, weight_t bound) {
		assert(bound > 0 && idx < agg_.size());
		uint32 k = static_cast(bound - 1);
		if (aux_[k] == 0) {
			todo_.push(TodoItem(idx, bound, aux_[k] = newAtom()));
		}
		return aux_[k];
	}
};

RuleTransform::RuleTransform(ProgramAdapter& prg) : impl_(new Impl()) {
	impl_->adapt_ = &prg;
}
RuleTransform::RuleTransform(LogicProgram& prg) : impl_(new Impl()) {
	impl_->prg_ = &prg;
}
RuleTransform::~RuleTransform() {
	delete impl_;
}

uint32 RuleTransform::transform(const Rule& r, Strategy s) {
	if (r.sum()) {
		Atom_t h = !Potassco::empty(r.head) ? r.head[0] : 0;
		bool aux = r.ht == Head_t::Choice || size(r.head) > 1;
		if (aux) {
			h = impl_->newAtom();
			Potassco::Lit_t bl = Potassco::lit(h);
			impl_->addRule(r.ht, r.head, Potassco::toSpan(&bl, 1));
		}
		return uint32(aux) + impl_->transform(h, r.agg.bound, r.agg.lits, s);
	}
	else if (size(r.head) > static_cast(r.ht == Head_t::Disjunctive)) {
		impl_->lits_.clear();
		uint32 nAux = (size(r.cond) > 1) && (size(r.head) > 1) && s != strategy_select_no_aux;
		if (nAux) {
			// make body eq to a new aux atom
			Atom_t auxB = impl_->newAtom();
			impl_->addRule(auxB, r.cond);
			impl_->lits_.push_back(Potassco::lit(auxB));
		}
		else {
			impl_->lits_.assign(begin(r.cond), end(r.cond));
		}
		return nAux + (r.ht == Head_t::Choice ? impl_->transformChoice(r.head) : impl_->transformDisjunction(r.head));
	}
	return impl_->addRule(r);
}

// A choice rule {h1,...hn} :- BODY is replaced with:
// h1   :- BODY, not aux1.
// aux1 :- not h1.
// ...
// hn   :- BODY, not auxN.
// auxN :- not hn.
uint32 RuleTransform::Impl::transformChoice(const Potassco::AtomSpan& atoms) {
	uint32 nRule = 0;
	Potassco::Lit_t   bLit = 0;
	Potassco::LitSpan bAux = Potassco::toSpan(&bLit, 1);
	Atom_t hAux;
	for (Potassco::AtomSpan::iterator it = Potassco::begin(atoms), end = Potassco::end(atoms); it != end; ++it) {
		hAux = newAtom();
		bLit = Potassco::neg(*it);
		lits_.push_back(Potassco::neg(hAux));
		nRule += addRule(*it, Potassco::toSpan(lits_));
		nRule += addRule(hAux, bAux);
		lits_.pop_back();
	}
	return nRule;
}

// A disjunctive rule h1|...|hn :- BODY is replaced with:
// hi   :- BODY, {not hj | 1 <= j != i <= n}.
uint32 RuleTransform::Impl::transformDisjunction(const Potassco::AtomSpan& atoms) {
	uint32 bIdx = sizeVec(lits_);
	for (Potassco::AtomSpan::iterator it = Potassco::begin(atoms) + 1, end = Potassco::end(atoms); it != end; ++it) {
		lits_.push_back(Potassco::neg(*it));
	}
	uint32 nRule = 0;
	for (Potassco::AtomSpan::iterator it = Potassco::begin(atoms), end = Potassco::end(atoms);;) {
		nRule += addRule(*it, Potassco::toSpan(lits_));
		if (++it == end) { break; }
		lits_[bIdx++] = Potassco::neg(*(it-1));
	}
	return nRule;
}

uint32 RuleTransform::Impl::transform(Atom_t head, weight_t bound, const Potassco::WeightLitSpan& wlits, Strategy s) {
	bound_ = bound;
	agg_.assign(begin(wlits), end(wlits));
	if (!isSorted(agg_.begin(), agg_.end(), CmpW())) {
		std::stable_sort(agg_.begin(), agg_.end(), CmpW());
	}
	wsum_t sum = 0;
	sumR_.resize(agg_.size());
	for (WLitVec::size_type i = agg_.size(); i--;) {
		agg_[i].weight = std::min(agg_[i].weight, bound_);
		sumR_[i] = (sum += agg_[i].weight);
		CLASP_FAIL_IF(agg_[i].weight < 0 || sum > CLASP_WEIGHT_T_MAX, "invalid weight rule");
	}
	if      (bound_ > sum) { return 0; }
	else if (bound_ <= 0)  { return addRule(head, Potassco::toSpan()); }
	else if ((sum - agg_.back().weight) < bound_) { // normal rule
		lits_.clear();
		for (WLitVec::const_iterator it = agg_.begin(), end = agg_.end(); it != end; ++it) {
			lits_.push_back(lit(*it));
		}
		return addRule(head, Potassco::toSpan(lits_));
	}
	else {
		return ((s == strategy_select_no_aux || (sum < 6 && s == strategy_default))
			? transformSelect(head)
			: transformSplit(head));
	}
}

// Exponential transformation of cardinality and weight constraint.
// Creates minimal subsets, no aux atoms.
// E.g. a rule h = 2 {a,b,c,d} is translated into the following six rules:
// h :- a, b.
// h :- a, c.
// h :- a, d.
// h :- b, c.
// h :- b, d.
// h :- c, d.
uint32 RuleTransform::Impl::transformSelect(Atom_t h) {
	lits_.clear();
	uint32 nRule = 0;
	wsum_t cw = 0;
	assert(sumR_[0] >= bound_ && cw < bound_);
	aux_.clear();
	for (uint32 it = 0, end = (uint32)agg_.size();;) {
		while (cw < bound_) {
			cw += Potassco::weight(agg_[it]);
			lits_.push_back(Potassco::lit(agg_[it]));
			aux_.push_back(it++);
		}
		nRule += addRule(h, Potassco::toSpan(lits_));
		do {
			if (aux_.empty()) { return nRule; }
			it = aux_.back();
			aux_.pop_back();
			lits_.pop_back();
			cw -= Potassco::weight(agg_[it]);
		} while (++it == end || (cw + sumR_[it]) < bound_);
	}
}
// Quadratic transformation of cardinality and weight constraint.
// Introduces aux atoms.
// E.g. a rule h = 2 {a,b,c,d} is translated into the following eight rules:
// h       :- a, aux_1_1.
// h       :- aux_1_2.
// aux_1_1 :- b.
// aux_1_1 :- aux_2_1.
// aux_1_2 :- b, aux_2_1.
// aux_1_2 :- c, d.
// aux_2_1 :- c.
// aux_2_1 :- d.
uint32 RuleTransform::Impl::transformSplit(Atom_t h) {
	const weight_t bound = bound_;
	uint32 nRule = 0;
	uint32 level = 0;
	aux_.resize(bound, 0);
	todo_.clear();
	todo_.push(TodoItem(0, bound, h));
	while (!todo_.empty()) {
		TodoItem i = todo_.pop_ret();
		if (i.idx > level) {
			// We are about to start a new level of the tree - reset aux_
			level = i.idx;
			aux_.assign(bound, 0);
		}
		// For a todo item i with head h and lit x = agg_[i.idx] create at most two rules:
		// r1: h :- x, aux(i.idx+1, i.bound-weight(x))
		// r2: h :- aux(i.idx+1, i.bound).
		// The first rule r1 represents the case where x is true, while
		// the second rule encodes the case where the literal is false.
		nRule += addRule(i.head, true,  i.idx, i.bound - agg_[i.idx].weight);
		nRule += addRule(i.head, false, i.idx, i.bound);
	}
	return nRule;
}

// Creates a rule head :- agg_[idx], aux(idx+1, bound) or head :- aux(idx+1, bound) or depending on add.
uint32 RuleTransform::Impl::addRule(Atom_t head, bool add, uint32 bIdx, weight_t bound) {
	const weight_t minW = agg_.back().weight;
	const wsum_t   maxW = sumR_[bIdx + 1];
	if (bound <= 0) {
		assert(add);
		lits_.assign(1, agg_[bIdx].lit);
		return addRule(head, Potassco::toSpan(lits_));
	}
	if ((maxW - minW) < bound) {
		// remaining literals are all needed to satisfy bound
		bIdx += static_cast(!add);
		if (maxW >= bound) {
			lits_.clear();
			for (; bIdx != agg_.size(); ++bIdx) { lits_.push_back(agg_[bIdx].lit); }
			return addRule(head, Potassco::toSpan(lits_));
		}
		return 0;
	}
	lits_.clear();
	if (add) { lits_.push_back(agg_[bIdx].lit); }
	lits_.push_back(Potassco::lit(getAuxVar(bIdx + 1, bound)));
	return addRule(head, Potassco::toSpan(lits_));
}
/////////////////////////////////////////////////////////////////////////////////////////
// class SccChecker
//
// SCC/cycle checking
/////////////////////////////////////////////////////////////////////////////////////////
SccChecker::SccChecker(LogicProgram& prg, AtomList& sccAtoms, uint32 startScc)
	: prg_(&prg), sccAtoms_(&sccAtoms), count_(0), sccs_(startScc) {
	for (uint32 i = 0; i != prg.numAtoms(); ++i) {
		visit(prg.getAtom(i));
	}
	for (uint32 i = 0; i != prg.numBodies(); ++i) {
		visit(prg.getBody(i));
	}
}

void SccChecker::visitDfs(PrgNode* node, NodeType t) {
	if (!prg_ || !doVisit(node)) {
		return;
	}
	callStack_.clear();
	nodeStack_.clear();
	count_ = 0;
	addCall(node, t, 0);
	while (!callStack_.empty()) {
		Call c = callStack_.back();
		callStack_.pop_back();
		if (!recurse(c)) {
			node = unpackNode(c.node);
			if (c.min < node->id()) {
				node->resetId( c.min, true );
			}
			else if (c.node == nodeStack_.back()) {
				// node is trivially-connected; all such nodes are in the same Pseudo-SCC
				if (isNode(nodeStack_.back(), PrgNode::Atom)) {
					static_cast(node)->setScc(PrgNode::noScc);
				}
				node->resetId(PrgNode::noNode, true);
				nodeStack_.pop_back();
			}
			else { // non-trivial SCC
				PrgNode* succVertex;
				do {
					succVertex = unpackNode(nodeStack_.back());
					if (isNode(nodeStack_.back(), PrgNode::Atom)) {
						static_cast(succVertex)->setScc(sccs_);
						sccAtoms_->push_back(static_cast(succVertex));
					}
					nodeStack_.pop_back();
					succVertex->resetId(PrgNode::noNode, true);
				} while (succVertex != node);
				++sccs_;
			}
		}
	}
}

bool SccChecker::recurse(Call& c) {
	PrgNode* n = unpackNode(c.node);
	if (!n->seen()) {
		nodeStack_.push_back(c.node);
		c.min = count_++;
		n->resetId(c.min, true);
	}
	if (isNode(c.node, PrgNode::Body)) {
		PrgBody* b = static_cast(n);
		PrgHead* h = 0; NodeType t;
		for (PrgBody::head_iterator it = b->heads_begin() + c.next, end = b->heads_end(); it != end; ++it) {
			if   (it->isAtom()){ h = prg_->getAtom(it->node()); t = PrgNode::Atom; }
			else               { h = prg_->getDisj(it->node()); t = PrgNode::Disj; }
			if (doVisit(h, false) && onNode(h, t, c, static_cast(it-b->heads_begin()))) {
				return true;
			}
		}
	}
	else if (isNode(c.node, PrgNode::Atom)) {
		PrgAtom* a = static_cast(n);
		for (PrgAtom::dep_iterator it = a->deps_begin() + c.next, end = a->deps_end(); it != end; ++it) {
			if (it->sign()) continue;
			PrgBody* bn = prg_->getBody(it->var());
			if (doVisit(bn, false) && onNode(bn, PrgNode::Body, c, static_cast(it-a->deps_begin()))) {
				return true;
			}
		}
	}
	else if (isNode(c.node, PrgNode::Disj)) {
		PrgDisj* d = static_cast(n);
		for (PrgDisj::atom_iterator it = d->begin() + c.next, end = d->end(); it != end; ++it) {
			PrgAtom* a = prg_->getAtom(*it);
			if (doVisit(a, false) && onNode(a, PrgNode::Atom, c, static_cast(it-d->begin()))) {
				return true;
			}
		}
	}
	return false;
}

bool SccChecker::onNode(PrgNode* n, NodeType t, Call& c, uint32 data) {
	if (!n->seen()) {
		Call rec = {c.node, c.min, data};
		callStack_.push_back(rec);
		addCall(n, t, 0);
		return true;
	}
	if (n->id() < c.min) {
		c.min = n->id();
	}
	return false;
}
/////////////////////////////////////////////////////////////////////////////////////////
PrgNode::PrgNode(uint32 id, bool checkScc)
	: litId_(noLit), noScc_(uint32(!checkScc)), id_(id), val_(value_free), eq_(0), seen_(0) {
	static_assert(sizeof(PrgNode) == sizeof(uint64), "Unsupported Alignment");
	CLASP_FAIL_IF(id_ != id, "Id out of range");
}
/////////////////////////////////////////////////////////////////////////////////////////
// class PrgHead
/////////////////////////////////////////////////////////////////////////////////////////
PrgHead::PrgHead(uint32 id, NodeType t, uint32 data, bool checkScc)
	: PrgNode(id, checkScc)
	, data_(data), upper_(0), dirty_(0), freeze_(0), isAtom_(t == PrgNode::Atom)  {
	struct X { uint64 x; EdgeVec y; uint32 z; };
	static_assert(sizeof(PrgHead) == sizeof(X), "Unsupported Alignment");
}
// Adds the node with given id as a support to this head
// and marks the head as dirty so that any duplicates/false/eq
// supports are removed once simplify() is called.
void PrgHead::addSupport(PrgEdge r, Simplify s) {
	supports_.push_back(r);
	if (s == force_simplify) { dirty_ = (supports_.size() > 1); }
}
// Removes the given node from the set of supports of this head.
void PrgHead::removeSupport(PrgEdge r) {
	if (relevant()) {
		supports_.erase(std::remove(supports_.begin(), supports_.end(), r), supports_.end());
	}
	dirty_ = 1;
}

void PrgHead::clearSupports() {
	supports_.clear();
	upper_  = 0;
	dirty_  = 0;
}
// Simplifies the set of predecessors supporting this head.
// Removes false/eq supports and returns the number of
// different supporting literals in numDiffSupps.
bool PrgHead::simplifySupports(LogicProgram& prg, bool strong, uint32* numDiffSupps) {
	uint32 numLits = supports();
	uint32 choices = 0;
	if (dirty_ == 1) {
		dirty_                  = 0;
		numLits                 = 0;
		SharedContext& ctx      = *prg.ctx();
		EdgeVec::iterator it,n,j= supports_.begin();
		for (it = supports_.begin(); it != supports_.end(); ++it) {
			PrgNode* x = prg.getSupp(*it);
			if (x->relevant() && x->value() != value_false && (!strong || x->hasVar())) {
				if      (!x->seen()) { *j++ = *it; x->setSeen(true); }
				else if (!choices)   { continue; }
				else                 {
					for (n = supports_.begin(); n != it && n->node() != it->node(); ++n) {;}
					if (*it < *n)      { *n = *it; }
					else               { continue; }
				}
				choices += (it->isBody() && it->isChoice());
				if (strong && !ctx.marked(x->literal())) {
					++numLits;
					ctx.mark(x->literal());
				}
			}
		}
		supports_.erase(j, supports_.end());
		uint32 dis = 0;
		choices    = 0;
		for (it = supports_.begin(); it != supports_.end(); ++it) {
			PrgNode* x = prg.getSupp(*it);
			x->setSeen(false);
			if (strong && ctx.marked(x->literal())) { ctx.unmark(x->var()); }
			if (it->isChoice()) {
				++choices;
				dis += it->isDisj();
			}
		}
		numLits += choices;
	}
	if (numDiffSupps) { *numDiffSupps = numLits; }
	return supports() > 0 || prg.assignValue(this, value_false, PrgEdge::noEdge());
}

// Assigns a variable to this head.
// No support: no var and value false
// More than one support or type not normal or no eq: new var
// Exactly one support that is normal: use that
void PrgHead::assignVar(LogicProgram& prg, PrgEdge support, bool allowEq) {
	if (hasVar() || !relevant()) { return; }
	uint32 numS = supports();
	if (numS == 0 && support == PrgEdge::noEdge()) {
		prg.assignValue(this, value_false, support);
	}
	else {
		PrgNode* sup = prg.getSupp(support);
		bool  newVar = numS > 1 || (!allowEq && Var_t::isAtom(prg.ctx()->varInfo(sup->var()).type()));
		if (support.isNormal() && sup->hasVar() && (!newVar || sup->value() == value_true)) {
			// head is equivalent to sup
			setLiteral(sup->literal());
			prg.ctx()->setVarEq(var(), true);
			prg.incEqs(Var_t::Hybrid);
		}
		else {
			setLiteral(posLit(prg.ctx()->addVar(Var_t::Atom, 0)));
		}
	}
}

// Backpropagates the value of this head to its supports.
bool PrgHead::backpropagate(LogicProgram& prg, ValueRep val, bool bpFull) {
	bool ok = true;
	if (val == value_false) {
		// a false head can't have supports
		EdgeVec temp; temp.swap(supports_);
		markDirty();
		for (EdgeIterator it = temp.begin(), end = temp.end(); it != end && ok; ++it) {
			if (it->isBody()) {
				ok = prg.getBody(it->node())->propagateAssigned(prg, this, it->type());
			}
			else { assert(it->isDisj());
				ok = prg.getDisj(it->node())->propagateAssigned(prg, this, it->type());
			}
		}
	}
	else if (val != value_free && supports() == 1 && bpFull) {
		// head must be true and only has one support, thus the only support must
		// be true, too.
		PrgBody* b   = 0;
		if (supports_[0].isBody()) {
			b   = prg.getBody(supports_[0].node());
		}
		else if (supports_[0].isDisj()) {
			PrgDisj* d = prg.getDisj(supports_[0].node());
			if (d->supports() == 1) { b = prg.getBody(d->supps_begin()->node()); }
		}
		ok = !b || b->value() == val || (b->assignValue(val) && b->propagateValue(prg, bpFull));
	}
	return ok;
}

/////////////////////////////////////////////////////////////////////////////////////////
// class PrgAtom
/////////////////////////////////////////////////////////////////////////////////////////
PrgAtom::PrgAtom(uint32 id, bool checkScc)
	: PrgHead(id, PrgNode::Atom, PrgNode::noScc, checkScc) {
	static_assert(sizeof(PrgAtom) == sizeof(PrgHead) + sizeof(LitVec), "Unsupported Alignment");
}

void PrgAtom::setEqGoal(Literal x) {
	if (eq()) {
		data_ = x.sign() ? x.var() : noScc;
	}
}
Literal PrgAtom::eqGoal(bool sign) const {
	if (!eq() || sign || data_ == noScc) {
		return Literal(id(), sign);
	}
	return negLit(data_);
}

// Adds a dependency between this atom and the body with
// the given id. If pos is true, atom appears positively
// in body, otherwise negatively.
void PrgAtom::addDep(Var bodyId, bool pos) {
	deps_.push_back(Literal(bodyId, !pos));
}

// Removes a dependency between this atom and the body with
// the given id. If pos is true, atom appears positively
// in body, otherwise negatively.
void PrgAtom::removeDep(Var bodyId, bool pos) {
	LitVec::iterator it = std::find(deps_.begin(), deps_.end(), Literal(bodyId, !pos));
	if (it != deps_.end()) { deps_.erase(it); }
}

// Removes the subset of dependencies given by d
void PrgAtom::clearDeps(Dependency d) {
	if (d == dep_all) {
		deps_.clear();
	}
	else {
		bool sign = d == dep_neg;
		LitVec::iterator j = deps_.begin();
		for (LitVec::iterator it = deps_.begin(), end = deps_.end(); it != end; ++it) {
			if (it->sign() != sign) { *j++ = *it; }
		}
		deps_.erase(j, deps_.end());
	}
}

bool PrgAtom::hasDep(Dependency d) const {
	if (d == dep_all) { return !deps_.empty(); }
	for (LitVec::const_iterator it = deps_.begin(), end = deps_.end(); it != end; ++it) {
		if (static_cast(it->sign()) == d) { return true; }
	}
	return false;
}

bool PrgAtom::inDisj() const {
	for (EdgeIterator it= supports_.begin(), end = supports_.end(); it != end; ++it) {
		if (it->isDisj()) { return true; }
	}
	return false;
}

// Propagates the value of this atom to its depending bodies
// and, if backpropagation is enabled, to its supporting bodies/disjunctions.
// PRE: value() != value_free
bool PrgAtom::propagateValue(LogicProgram& prg, bool backprop) {
	ValueRep val = value();
	assert(val != value_free);
	// propagate value forward
	Literal dep = posLit(id());
	for (dep_iterator it = deps_.begin(), end = deps_end(); it != end; ++it) {
		if (!prg.getBody(it->var())->propagateAssigned(prg, dep ^ it->sign(), val)) {
			return false;
		}
	}
	if (inDisj() && prg.isFact(this)) {
		// - atom is true, thus all disjunctive rules containing it are superfluous
		EdgeVec temp; temp.swap(supports_);
		EdgeVec::iterator j = temp.begin();
		EdgeType t          = PrgEdge::Choice;
		for (EdgeIterator it= temp.begin(), end = temp.end(); it != end; ++it) {
			if      (!it->isDisj())                                            { *j++ = *it; }
			else if (!prg.getDisj(it->node())->propagateAssigned(prg, this, t)){ return false; }
		}
		temp.erase(j, temp.end());
		supports_.swap(temp);
	}
	return backpropagate(prg, val, backprop);
}

// Adds the atom-oriented nogoods for this atom in form of clauses.
// Adds the support clause [~a S1...Sn] (where each Si is a supporting node of a)
// representing the tableau-rules BTA and FFA.
// Furthermore, adds the clause [a ~Bj] representing tableau-rules FTA and BFA
// if Bj supports a via a "normal" edge.
bool PrgAtom::addConstraints(const LogicProgram& prg, ClauseCreator& gc) {
	SharedContext& ctx  = *prg.ctx();
	EdgeVec::iterator j = supports_.begin();
	bool           nant = false;
	gc.start().add(~literal());
	for (EdgeVec::iterator it = supports_.begin(); it != supports_.end(); ++it) {
		PrgNode* n = prg.getSupp(*it);
		Literal  B = n->literal();
		// consider only bodies which are part of the simplified program, i.e.
		// are associated with a variable in the solver.
		if (n->relevant() && n->hasVar()) {
			*j++ = *it;
			nant = nant || it->isChoice();
			if (!it->isDisj()) { gc.add(B); }
			if (it->isNormal() && !ctx.addBinary(literal(), ~B)) { // FTA/BFA
				return false;
			}
		}
	}
	supports_.erase(j, supports_.end());
	if (nant ||	hasDep(PrgAtom::dep_neg)) { ctx.setNant(var(), true); }
	return gc.end(ClauseCreator::clause_force_simplify);
}
/////////////////////////////////////////////////////////////////////////////////////////
// class PrgBody
/////////////////////////////////////////////////////////////////////////////////////////
PrgBody::PrgBody(uint32 id, LogicProgram& prg, const Potassco::LitSpan& lits, uint32 pos, bool addDeps)
	: PrgNode(id, true) {
	init(Body_t::Normal, toU32(Potassco::size(lits)));
	Norm* c = new (data_)Norm();
	unsupp_ = pos;
	// store B+ followed by B-
	Literal* p[2] = {c->lits, c->lits + pos};
	for (Potassco::LitSpan::iterator it = Potassco::begin(lits), end = Potassco::end(lits); it != end; ++it) {
		CLASP_ASSERT_CONTRACT_MSG(*it != 0, "body not simplified");
		Literal*& n = p[*it < 0];
		*n = toLit(*it);
		if (addDeps) { prg.getAtom(n->var())->addDep(id, !n->sign()); }
		++n;
	}
}

PrgBody::PrgBody(uint32 id, LogicProgram& prg, const Potassco::Sum_t& sum, bool hasWeights, uint32 pos, bool addDeps)
	: PrgNode(id, true) {
	init(hasWeights ? Body_t::Sum : Body_t::Count, toU32(Potassco::size(sum.lits)));
	Agg* a = new (data_) Agg();
	if (!hasWeights) {
		a->bound = sum.bound;
		unsupp_  = sum.bound - static_cast(size_ - pos);
	}
	else {
		a->sum  = SumData::create(size_, sum.bound, 0);
		unsupp_ = sum.bound;
	}
	// store B+ followed by B- followed by optional weights
	Literal* base = a->lits;
	Literal* p[2] = {base, base + pos};
	weight_t* weights = hasWeights ? a->sum->weights : 0;
	for (Potassco::WeightLitSpan::iterator it = Potassco::begin(sum.lits), end = Potassco::end(sum.lits); it != end; ++it) {
		CLASP_ASSERT_CONTRACT_MSG(it->lit != 0 && it->weight > 0, "body not simplified");
		Literal*& n = p[it->lit < 0];
		*n = toLit(Potassco::lit(*it));
		if (weights) { weights[n - base] = it->weight; a->sum->sumW += it->weight; if (n->sign()) { unsupp_ -= it->weight; } }
		if (addDeps) { prg.getAtom(n->var())->addDep(id, !n->sign()); }
		++n;
	}
}
void PrgBody::init(Body_t t, uint32 sz) {
	size_ = sz, head_ = 0, type_ = t, sBody_ = 0, sHead_ = 0, freeze_ = 0;
}
PrgBody* PrgBody::create(LogicProgram& prg, uint32 id, const Rule& r, uint32 pos, bool addDeps) {
	static_assert(sizeof(PrgBody) == 24 && sizeof(Agg) == sizeof(void*), "unexpected alignment");
	PrgBody* ret = 0;
	if (r.normal()) {
		size_t bytes = sizeof(PrgBody) + (Potassco::size(r.cond) * sizeof(Literal));
		ret = new (::operator new(bytes)) PrgBody(id, prg, r.cond, pos, addDeps);
	}
	else {
		const Potassco::Sum_t& sum = r.agg;
		size_t bytes = sizeof(PrgBody) + (Potassco::size(r.agg.lits) * sizeof(Literal)) + sizeof(Agg);
		ret = new (::operator new(bytes)) PrgBody(id, prg, sum, r.bt == Body_t::Sum, pos, addDeps);
		CLASP_ASSERT_CONTRACT_MSG(ret->bound() > 0 && ret->sumW() > ret->bound(), "body not simplified");
	}
	if (ret->bound() == 0) {
		ret->assignValue(value_true);
		ret->markDirty();
	}
	return ret;
}

PrgBody::~PrgBody() {
	clearHeads();
	if (hasWeights()) {
		sumData()->destroy();
	}
}

void PrgBody::destroy() {
	this->~PrgBody();
	::operator delete(this);
}

PrgBody::SumData* PrgBody::SumData::create(uint32 size, weight_t b, weight_t s) {
	uint32 bytes = sizeof(SumData) + (size * sizeof(weight_t));
	SumData* ret = new (::operator new(bytes)) SumData();
	ret->bound = b;
	ret->sumW = s;
	return ret;
}
void PrgBody::SumData::destroy() {
	::operator delete(this);
}

uint32 PrgBody::findLit(const LogicProgram& prg, Literal p) const {
	for (const Literal* it = goals_begin(), *end = it + size(); it != end; ++it) {
		Literal x = prg.getAtom(it->var())->literal();
		if (it->sign()) x = ~x;
		if (x == p) return static_cast(it - goals_begin());
	}
	return varMax;
}

// Sets the unsupported counter back to
// bound() - negWeight()
bool PrgBody::resetSupported() {
	unsupp_ = bound();
	for (uint32 x = size(); x && goal(--x).sign(); ) {
		unsupp_ -= weight(x);
	}
	return isSupported();
}

// Removes all heads from this body *without* notifying them
void PrgBody::clearHeads() {
	if (!isSmallHead()) { delete largeHead(); }
	head_ = 0;
}

// Makes h a head-successor of this body and adds this
// body as a support for h.
void PrgBody::addHead(PrgHead* h, EdgeType t) {
	assert(relevant() && h->relevant());
	PrgEdge fwdEdge = PrgEdge::newEdge(*h, t);
	PrgEdge bwdEdge = PrgEdge::newEdge(*this, t);
	uint32  numHeads= static_cast(heads_end() - heads_begin());
	uint32  numSupps= h->supports();
	bool    dup     = false;
	if (numHeads && numSupps && std::min(numHeads, numSupps) < 10) {
		if (numSupps < numHeads) { dup = std::find(h->supps_begin(), h->supps_end(), bwdEdge) != h->supps_end(); }
		else                     { dup = std::find(heads_begin(), heads_end(), fwdEdge) != heads_end(); }
	}
	if (dup) { return; }
	addHead(fwdEdge);
	h->addSupport(bwdEdge);
	// mark head-set as dirty
	if (head_ > 1) {  sHead_ = 1; }
}

void PrgBody::addHead(PrgEdge h) {
	if      (head_ < 2u)    { smallHead()[head_++] = h; }
	else if (!isSmallHead()){ largeHead()->push_back(h);    }
	else                    {
		EdgeVec* t  = new EdgeVec(heads_begin(), heads_end());
		headData_.ext = t;
		head_ = 3u;
		t->push_back(h);
	}
}

void PrgBody::removeHead(PrgHead* h, EdgeType t) {
	PrgEdge x = PrgEdge::newEdge(*h, t);
	if (eraseHead(x)) {
		h->removeSupport(PrgEdge::newEdge(*this, t)); // also remove back edge
	}
}

bool PrgBody::hasHead(PrgHead* h, EdgeType t) const {
	if (!hasHeads()) { return false;  }
	PrgEdge x = PrgEdge::newEdge(*h, t);
	head_iterator it = sHead_ != 0 || isSmallHead() ? std::find(heads_begin(), heads_end(), x) : std::lower_bound(heads_begin(), heads_end(), x);
	return it != heads_end() && *it == x;
}

bool PrgBody::eraseHead(PrgEdge h) {
	PrgEdge* it = const_cast(std::find(heads_begin(), heads_end(), h));
	if      (it == heads_end()) { return false; }
	else if (isSmallHead())     { *it = smallHead()[1]; --head_; }
	else                        { largeHead()->erase(it); }
	return true;
}

bool PrgBody::toData(const LogicProgram& prg, Potassco::RuleBuilder& out) const {
	Body_t bt = type();
	weight_t sum = 0, bound = this->bound();
	bt == Body_t::Normal ?  out.startBody() : out.startSum(bound);
	for (uint32 i = 0, end = size(); i != end; ++i) {
		Potassco::WeightLit_t wl = {toInt(goal(i)), weight(i)};
		if (!prg.frozen() || prg.inProgram(Potassco::atom(wl))) {
			out.addGoal(wl);
			sum += wl.weight;
		}
		else if (wl.lit < 0)           { bound -= weight(i); }
		else if (bt == Body_t::Normal) { return false; }
	}
	if (bt != Body_t::Normal) {
		out.setBound(bound);
		if (bound <= 0 || bound >= sum) {
			if      (bound > sum) { return false; }
			else if (bound <= 0)  { out.clearBody(); }
			else                  { out.weaken(Body_t::Normal); }
		}
	}
	return true;
}

// Simplifies the body by removing assigned atoms & replacing eq atoms.
// Checks whether simplified body must be false (CONTRA) or is
// structurally equivalent to some other body.
// prg    The program containing this body
// strong If true, treats atoms that have no variable associated as false.
// eqId   The id of a body in prg that is equivalent to this body
bool PrgBody::simplifyBody(LogicProgram& prg, bool strong, uint32* eqId) {
	if (eqId)        { *eqId  = id(); }
	if (sBody_ == 0) { return true;   }
	// update body - compute old hash value
	SharedContext& ctx = *prg.ctx();
	uint32 oldHash     = 0;
	weight_t bound     = this->bound();
	weight_t w         = 1, *jw = hasWeights() ? sumData()->weights : 0;
	Literal* lits      = goals_begin();
	Literal* j         = lits;
	AtomState& todo    = prg.atomState();
	Var a;
	bool mark, isEq;
	int todos = 0;
	for (Literal* it = j, *end = j + size(); it != end; ++it) {
		a       = it->var();
		isEq    = a != prg.getRootId(a);
		oldHash+= hashLit(*it);
		if (isEq) {
			prg.getAtom(a)->removeDep(id(), !it->sign()); // remove old edge
			*it = prg.getAtom(a)->eqGoal(it->sign());     // replace with eq goal
			a   = it->var();                              // and check it
		}
		Literal aLit = it->sign() ? ~prg.getAtom(a)->literal() : prg.getAtom(a)->literal();
		ValueRep v   = prg.getAtom(a)->value();
		mark         = strong || prg.getAtom(a)->hasVar();
		if (strong && !prg.getAtom(a)->hasVar()) {
			v = value_false;
		}
		if (v == value_weak_true && it->sign()) {
			v = value_true;
		}
		if (v == value_true || v == value_false) { // truth value is known - remove subgoal
			if (v == trueValue(*it)) {
				// subgoal is true: decrease necessary lower bound
				bound -= weight(uint32(it - lits));
			}
			prg.getAtom(a)->removeDep(id(), !it->sign());
		}
		else if (!mark || !ctx.marked(aLit)) {
			if (mark) { ctx.mark(aLit); }
			if (isEq) { // remember to add edge for new goal later
				todo.addToBody(Literal(*it));
				++todos;
			}
			*j++ = *it;  // copy literal and optionally weight
			if (jw) { *jw++ = weight(uint32(it - lits)); }
		}
		else { // body contains aLit more than once
			if (type() != Body_t::Normal) { // merge subgoal
				if (!jw) {
					SumData* sum = SumData::create(size(), this->bound(), this->sumW());
					std::fill_n(sum->weights, size(), w = 1);
					aggData().sum = sum;
					type_ = Body_t::Sum;
					jw    = sum->weights + (it - lits);
				}
				else { w = weight(uint32(it - lits)); }
				uint32 pos = findLit(prg, aLit);
				sumData()->weights[pos] += w;
			}
			else { // ignore if normal
				--bound;
				if (!isEq) { // remove edge
					if (todo.inBody(*it)) { todo.clearBody(*it); --todos; }
					else                  { prg.getAtom(it->var())->removeDep(id(), !it->sign()); }
				}
			}
		}
	}
	// unmark atoms, compute new hash value,
	// and restore pos | neg partition in case
	// we changed some positive goals to negative ones
	size_          = j - lits;
	if (jw) jw     = sumData()->weights;
	uint32 newHash = 0;
	weight_t sumW  = 0, reachW = 0;
	for (uint32 p = 0, n = size_, i, h; p < n;) {
		if      (!lits[p].sign())      { h = hashLit(lits[i = p++]);  }
		else if (lits[n-1].sign())     { h = hashLit(lits[i = --n]);  }
		else /* restore pos|neg order */ {
			std::swap(lits[p], lits[n-1]);
			if (jw) { std::swap(jw[p], jw[n-1]); }
			continue;
		}
		a = lits[i].var();
		if (todos && todo.inBody(lits[i])) {
			prg.getAtom(a)->addDep(id(), !lits[i].sign());
			todo.clearBody(lits[i]);
			--todos;
		}
		Var v   = prg.getAtom(a)->var();
		w       = !jw ? 1 : jw[i];
		sumW   += w;
		reachW += w;
		if (ctx.marked(posLit(v)) && ctx.marked(negLit(v))) {
			// body contains aLit and ~aLit
			if  (!hasWeights()) { reachW -= 1; }
			else {
				Literal other = prg.getAtom(a)->literal() ^ !goal(i).sign();
				uint32 pos    = findLit(prg, other);
				assert(pos != varMax && pos != i);
				reachW       -= std::min(w, jw[pos]);
			}
		}
		ctx.unmark( v );
		newHash += h;
	}
	bool ok = normalize(prg, bound, sumW, reachW, newHash);
	if (ok) {
		Var xId = id();
		if (oldHash != newHash) {
			xId = prg.update(this, oldHash, newHash);
		}
		if (eqId) { *eqId = xId != varMax ? xId : id(); }
	}
	if (strong) sBody_ = 0;
	return ok && (value() == value_free || propagateValue(prg));
}

bool PrgBody::normalize(const LogicProgram& prg, weight_t bound, weight_t sumW, weight_t reachW, uint32& hashOut) {
	Body_t nt = (sumW == bound || size() == 1) ? Body_t::Normal : type();
	bool ok = true;
	if (sumW >= bound && type() != Body_t::Normal) {
		if (hasWeights()) {
			sumData()->bound = bound;
			sumData()->sumW  = sumW;
		}
		else {
			aggData().bound = bound;
		}
	}
	if (bound <= 0) {
		for (uint32 i = 0, myId = id(); i != size_; ++i) {
			prg.getAtom(goal(i).var())->removeDep(myId, !goal(i).sign());
		}
		size_ = 0; hashOut = 0, unsupp_ = 0;
		nt    = Body_t::Normal;
		ok    = assignValue(value_true);
	}
	else if (reachW < bound) {
		ok     = assignValue(value_false);
		sHead_ = 1;
		markRemoved();
	}
	if (nt != type()) {
		assert(nt == Body_t::Normal);
		Literal* from = aggData().lits;
		if (hasWeights()) {
			sumData()->destroy();
		}
		Literal* to = (new (data_)Norm())->lits;
		std::copy(from, from+size(), to);
		type_ = nt;
	}
	return ok;
}

// Marks the set of heads in rs and removes
// any duplicate heads.
void PrgBody::prepareSimplifyHeads(LogicProgram& prg, AtomState& rs) {
	head_iterator end = heads_end();
	uint32 size       = 0;
	for (PrgEdge*  j  = const_cast(heads_begin()); j != end;) {
		if (!rs.inHead(*j)) {
			rs.addToHead(*j);
			++j; ++size;
		}
		else {
			prg.getHead(*j)->markDirty();
			*j = *--end;
		}
	}
	if (isSmallHead()) { head_ = size; }
	else               { shrinkVecTo(*largeHead(), size); }
}

// Simplifies the heads of this body wrt target.
// Removes superfluous/eq/unsupported heads and checks for self-blocking
// situations.
// PRE: prepareSimplifyHeads was called
bool PrgBody::simplifyHeadsImpl(LogicProgram& prg, PrgBody& target, AtomState& rs, bool strong) {
	PrgHead* cur;
	PrgEdge* j     = const_cast(heads_begin());
	uint32 newSize = 0;
	bool merge     = this != ⌖
	bool block     = value() == value_false || (merge && target.value() == value_false);
	for (head_iterator it = heads_begin(), end = heads_end(); it != end; ++it) {
		cur  = prg.getHead(*it);
		block= block || target.blockedHead(*it, rs);
		if (!cur->relevant() || (strong && !cur->hasVar())
			|| block || target.superfluousHead(prg, cur, *it, rs) || cur->value() == value_false) {
			// remove superfluous and unsupported heads
			cur->removeSupport(PrgEdge::newEdge(*this, it->type()));
			rs.clearHead(*it);
			block = block || (cur->value() == value_false && it->type() == PrgEdge::Normal);
		}
		else {
			*j++ = *it;
			++newSize;
			if (merge) { target.addHead(cur, it->type()); }
		}
	}
	if (isSmallHead()) { head_ = newSize; }
	else               { shrinkVecTo(*largeHead(), newSize); }
	return !block;
}

bool PrgBody::simplifyHeads(LogicProgram& prg, bool strong) {
	if (sHead_ == 0) { return true; }
	return PrgBody::mergeHeads(prg, *this, strong);
}

bool PrgBody::mergeHeads(LogicProgram& prg, PrgBody& heads, bool strong, bool simplify) {
	AtomState& rs = prg.atomState();
	bool       ok = true;
	assert((this == &heads || heads.sHead_ == 0) && "Heads to merge not simplified!");
	if (simplify || &heads == this) {
		// mark the body literals so that we can easily detect superfluous atoms
		// and selfblocking situations.
		for (const Literal* it = goals_begin(), *end = it + size(); it != end; ++it) {
			rs.addToBody(*it);
		}
		// remove duplicate/superfluous heads & check for blocked atoms
		prepareSimplifyHeads(prg, rs);
		if (this == &heads) {
			ok = simplifyHeadsImpl(prg, *this, rs, strong);
		}
		else {
			heads.prepareSimplifyHeads(prg, rs);
			if (!simplifyHeadsImpl(prg, *this, rs, strong) && !assignValue(value_false)) {
				clearRule(rs);
				return false;
			}
			ok = heads.simplifyHeadsImpl(prg, *this, rs, strong);
			if (!ok && (!heads.assignValue(value_false) || !heads.propagateValue(prg, false))) {
				clearRule(rs);
				return false;
			}
		}
		// clear temporary flags & reestablish ordering
		std::sort(const_cast(heads_begin()), const_cast(heads_end()));
		clearRule(rs);
		sHead_ = 0;
	}
	else if (relevant()) {
		for (head_iterator it = heads.heads_begin(), end = heads.heads_end(); it != end; ++it) {
			PrgHead* h = prg.getHead(*it);
			if (h->relevant()) { addHead(h, it->type()); }
		}
	}
	return ok || (assignValue(value_false) && propagateValue(prg));
}

// Checks whether the head is superfluous w.r.t this body, i.e.
//  - is needed to satisfy the body
//  - it appears in the body and is a choice
//  - it is a disjunction and one of the atoms is needed to satisfy the body
bool PrgBody::superfluousHead(const LogicProgram& prg, const PrgHead* head, PrgEdge it, const AtomState& rs) const {
	if (it.isAtom()) {
		// the head is an atom
		uint32 atomId = it.node();
		weight_t    w = 1;
		if (rs.inBody(posLit(atomId))) {
			if (hasWeights()) {
				const Literal* lits = aggData().lits;
				const Literal* x    = std::find(lits, lits + size(), posLit(atomId));
				assert(x != lits + size());
				w = sumData()->weights[ x - lits ];
			}
			if (it.isChoice() || (sumW() - w) < bound()) {
				return true;
			}
		}
		return it.isChoice() && (rs.inBody(negLit(atomId)) || rs.inHead(atomId));
	}
	else { assert(it.isDisj());
		// check each contained atom
		const PrgDisj* dis = static_cast(head);
		for (PrgDisj::atom_iterator aIt = dis->begin(), aEnd = dis->end(); aIt != aEnd; ++aIt) {
			if (rs.inBody(posLit(*aIt)) || rs.inHead(*aIt)) {
				return true;
			}
			if (prg.isFact(prg.getAtom(*aIt))) {
				return true;
			}
		}
		// check for subsumption
		if (prg.options().iters == LogicProgram::AspOptions::MAX_EQ_ITERS) {
			for (head_iterator hIt = heads_begin(), hEnd = heads_end(); hIt != hEnd; ++hIt) {
				if (hIt->isDisj() && prg.getDisj(hIt->node())->size() < dis->size()) {
					const PrgDisj* other = prg.getDisj(hIt->node());
					for (PrgDisj::atom_iterator a = other->begin(), aEnd = other->end(); a != aEnd && other; ++a) {
						if (std::find(dis->begin(), dis->end(), *a) == dis->end()) {
							other = 0;
						}
					}
					if (other && other->size() > 0) {
						return true;
					}
				}
			}
		}
	}
	return false;
}

// Checks whether the rule it.node() :- *this is selfblocking, i.e.
// from TB follows conflict
bool PrgBody::blockedHead(PrgEdge it, const AtomState& rs) const {
	if (it.isAtom() && it.isNormal() && rs.inBody(negLit(it.node()))) {
		weight_t w = 1;
		if (hasWeights()) {
			const Literal* lits = aggData().lits;
			const Literal* x    = std::find(lits, lits + size(), negLit(it.node()));
			assert(x != lits + size());
			w = sumData()->weights[ x - lits ];
		}
		return (sumW() - w) < bound();
	}
	return false;
}

void PrgBody::assignVar(LogicProgram& prg) {
	if (hasVar() || !relevant()) { return; }
	uint32 size = this->size();
	if (size == 0 || value() == value_true) {
		setLiteral(lit_true());
	}
	else if (size == 1 && prg.getAtom(goal(0).var())->hasVar()) {
		Literal x = prg.getAtom(goal(0).var())->literal();
		setLiteral(goal(0).sign() ? ~x : x);
		prg.ctx()->setVarEq(var(), true);
		prg.incEqs(Var_t::Hybrid);
	}
	else if (value() != value_false) {
		setLiteral(posLit(prg.ctx()->addVar(Var_t::Body, 0)));
	}
	else {
		setLiteral(lit_false());
	}
}

bool PrgBody::propagateSupported(Var v) {
	weight_t w = 1;
	if (hasWeights()) {
		uint32 pos = (uint32)std::distance(goals_begin(), std::find(goals_begin(), goals_end(), posLit(v)));
		w          = weight(pos);
	}
	return (unsupp_ -= w) <= 0;
}

bool PrgBody::propagateAssigned(LogicProgram& prg, Literal p, ValueRep v) {
	if (!relevant()) return true;
	assert(std::find(goals_begin(), goals_end(), p) != goals_end());
	markDirty();
	ValueRep x = v == value_weak_true ? value_true : v;
	weight_t w = 1; // TODO: find weight of p for weight rule
	if (x == falseValue(p) && (sumW() - w) < bound() && value() != value_false) {
		return assignValue(value_false) && propagateValue(prg);
	}
	else if (x == trueValue(p) && (bound() - w) <= 0 && value() != value_weak_true) {
		return assignValue(value_weak_true) && propagateValue(prg);
	}
	return true;
}

bool PrgBody::propagateAssigned(LogicProgram& prg, PrgHead* h, EdgeType t) {
	if (!relevant()) return true;
	markHeadsDirty();
	if (h->value() == value_false && eraseHead(PrgEdge::newEdge(*h, t)) && t == PrgEdge::Normal) {
		return value() == value_false || (assignValue(value_false) && propagateValue(prg));
	}
	return true;
}

bool PrgBody::propagateValue(LogicProgram& prg, bool backprop) {
	ValueRep val = value();
	assert(value() != value_free);
	// propagate value forward
	for (head_iterator h = heads_begin(), end = heads_end(); h != end; ++h) {
		PrgHead* head = prg.getHead(*h);
		PrgEdge  supp = PrgEdge::newEdge(*this, h->type());
		if (val == value_false) {
			head->removeSupport(supp);
		}
		else if (!h->isChoice() && head->value() != val && !prg.assignValue(head, val, supp)) {
			return false;
		}
	}
	if (val == value_false) { clearHeads(); }
	// propagate value backward
	if (backprop && relevant()) {
		const uint32 W = hasWeights();
		weight_t MAX_W = 1;
		weight_t* wPos = W == 0 ? &MAX_W : sumData()->weights;
		MAX_W          = *std::max_element(wPos, wPos + (size() * W));
		weight_t bound = value()==value_false ? this->bound() : (sumW() - this->bound())+1;
		if (MAX_W >= bound) {
			ValueRep goalVal;
			for (const Literal* it = goals_begin(), *end = goals_end(); it != end; ++it) {
				if ((bound - *wPos) <= 0) {
					if (!it->sign()) { goalVal = val; }
					else             { goalVal = val == value_false ? value_weak_true : value_false; }
					if (!prg.assignValue(prg.getAtom(it->var()), goalVal, PrgEdge::noEdge())) {
						return false;
					}
				}
				wPos += W;
			}
		}
	}
	return true;
}
bool PrgBody::propagateValue(LogicProgram& prg) {
	return propagateValue(prg, prg.options().backprop != 0);
}

// Adds nogoods for the tableau-rules FFB and BTB as well as FTB, BFB.
// For normal bodies, clauses are used, i.e:
//   FFB and BTB:
//     - a binary clause [~b s] for every positive subgoal of b
//     - a binary clause [~b ~n] for every negative subgoal of b
//   FTB and BFB:
//     - a clause [b ~s1...~sn n1..nn] where si is a positive and ni a negative subgoal
// For count/sum bodies, a weight constraint is created
bool PrgBody::addConstraints(const LogicProgram& prg, ClauseCreator& gc) {
	if (type() == Body_t::Normal) {
		bool    taut= false;
		Literal negB= ~literal();
		gc.start().add(literal());
		for (const Literal* it = goals_begin(), *end = goals_end(); it != end; ++it) {
			Literal li = prg.getAtom(it->var())->literal() ^ it->sign();
			if (li == literal()) { taut = true; continue; }
			if (!prg.ctx()->addBinary(negB, li)) { // [~B li]
				return false;
			}
			if (li.var() != negB.var()) { gc.add(~li); }  // [B v ~l1 v ... v ~ln]
		}
		return taut || gc.end();
	}
	WeightLitVec lits;
	for (uint32 i = 0, end = size_; i != end; ++i) {
		Literal eq = prg.getAtom(goal(i).var())->literal() ^ goal(i).sign();
		lits.push_back(WeightLiteral(eq, weight(i)));
	}
	return WeightConstraint::create(*prg.ctx()->master(), literal(), lits, bound()).ok();
}

// Returns the SCC of body B, i.e.
// - scc if exist atom a in B.heads(), a' in B+, s.th. a.scc == a'.scc
// - noScc otherwise
uint32 PrgBody::scc(const LogicProgram& prg) const {
	uint64 sccMask = 0;
	uint32 end     = size();
	uint32 scc     = PrgNode::noScc;
	bool   large   = false;
	for (uint32 i  = 0; i != end; ++i) {
		if      (goal(i).sign()) {
			end = i;
			break;
		}
		else if ((scc = prg.getAtom(goal(i).var())->scc()) != PrgNode::noScc) {
			sccMask |= uint64(1) << (scc & 63);
			large   |= scc > 63;
		}
	}
	if (sccMask != 0) {
		PrgDisj::atom_iterator aIt = 0, aEnd = 0;
		Var head;
		for (head_iterator h = heads_begin(), hEnd = heads_end(); h != hEnd; ++h) {
			if (h->isAtom()) { head = h->node(); aIt = &head, aEnd = aIt + 1; }
			else             { PrgDisj* d = prg.getDisj(h->node()); aIt = d->begin(), aEnd = d->end(); }
			for (; aIt != aEnd; ++aIt) {
				scc = prg.getAtom(*aIt)->scc();
				if (scc != PrgNode::noScc && (sccMask & (uint64(1) << (scc&63))) != 0) {
					if (!large) { return scc; }
					for (uint32 j = 0; j != end; ++j) {
						if (scc == prg.getAtom(goal(j).var())->scc()) { return scc; }
					}
				}
			}
		}
	}
	return PrgNode::noScc;
}

/////////////////////////////////////////////////////////////////////////////////////////
// class PrgDisj
//
// Head of a disjunctive rule
/////////////////////////////////////////////////////////////////////////////////////////
PrgDisj* PrgDisj::create(uint32 id, const Potassco::AtomSpan& head) {
	void* m = ::operator new(sizeof(PrgDisj) + (Potassco::size(head)*sizeof(Var)));
	return new (m) PrgDisj(id, head);
}

PrgDisj::PrgDisj(uint32 id, const Potassco::AtomSpan& head) : PrgHead(id, PrgNode::Disj, (uint32)Potassco::size(head)) {
	std::copy(Potassco::begin(head), Potassco::end(head), atoms_);
	std::sort(atoms_, atoms_+size());
}
PrgDisj::~PrgDisj() {}
void PrgDisj::destroy() {
	this->~PrgDisj();
	::operator delete(this);
}

void PrgDisj::detach(LogicProgram& prg) {
	PrgEdge edge = PrgEdge::newEdge(*this, PrgEdge::Choice);
	for (atom_iterator it = begin(), end = this->end(); it != end; ++it) {
		prg.getAtom(*it)->removeSupport(edge);
	}
	EdgeVec temp; temp.swap(supports_);
	for (PrgDisj::sup_iterator it = temp.begin(), end = temp.end(); it != end; ++it) {
		prg.getBody(it->node())->removeHead(this, PrgEdge::Normal);
	}
	setInUpper(false);
	markRemoved();
}

bool PrgDisj::propagateAssigned(LogicProgram& prg, PrgHead* head, EdgeType t) {
	assert(head->isAtom() && t == PrgEdge::Choice);
	if (prg.isFact(static_cast(head)) || head->value() == value_false) {
		atom_iterator it = std::find(begin(), end(), head->id());
		if (it != end()) {
			if      (head->value() == value_true) { detach(prg); }
			else if (head->value() == value_false){
				head->removeSupport(PrgEdge::newEdge(*this, t));
				std::copy(it+1, end(), const_cast(it));
				if (--data_ == 1) {
					PrgAtom* last = prg.getAtom(*begin());
					EdgeVec temp;
					clearSupports(temp);
					for (EdgeVec::const_iterator it = temp.begin(), end = temp.end(); it != end; ++it) {
						prg.getBody(it->node())->removeHead(this, PrgEdge::Normal);
						prg.getBody(it->node())->addHead(last, PrgEdge::Normal);
					}
					detach(prg);
				}
			}
		}
	}
	return true;
}
} }
clasp-3.2.2/libclasp/src/lookahead.cpp000066400000000000000000000316001304134206100176250ustar00rootroot00000000000000//
// Copyright (c) 2009, 2012 Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// Lookahead scoring
/////////////////////////////////////////////////////////////////////////////////////////
uint32 ScoreLook::countNant(const Solver& s, const Literal* b, const Literal *e) const {
	uint32 sc = 1;
	for (; b != e; ++b) { sc += s.varInfo(b->var()).nant(); }
	return sc;
}
void ScoreLook::scoreLits(const Solver& s, const Literal* b, const Literal *e) {
	assert(b < e);
	uint32 sc = !nant ? uint32(e-b) : countNant(s, b, e);
	Var v     = b->var();
	assert(validVar(v));
	score[v].setScore(*b, sc);
	if (addDeps) {
		if ((score[v].testedBoth() || mode == score_max) && greater(v, best)) {
			best = v;
		}
		for (; b != e; ++b) {
			v = b->var();
			if (validVar(v) && (s.varInfo(v).type() & types) != 0) {
				if (!score[v].seen()) { deps.push_back(v); }
				score[v].setDepScore(*b, sc);
				score[v].setSeen(*b);
			}
		}
	}
}
void ScoreLook::clearDeps() {
	for (VarVec::size_type i = 0, end = deps.size(); i != end; ++i) {
		score[deps[i]].clear();
	}
	deps.clear();
	best = 0;
}
bool ScoreLook::greater(Var lhs, Var rhs) const {
	uint32 rhsMax, rhsMin;
	score[rhs].score(rhsMax, rhsMin);
	return mode == score_max
		? greaterMax(lhs, rhsMax)
		: greaterMaxMin(lhs, rhsMax, rhsMin);
}
/////////////////////////////////////////////////////////////////////////////////////////
// Lookahead propagator
/////////////////////////////////////////////////////////////////////////////////////////
Lookahead::Lookahead(const Params& p)
	: nodes_(2, LitNode(lit_true()))
	, last_(head_id)    // circular list
	, pos_(head_id)     // lookahead start pos
	, top_(uint32(-2))
	, limit_(p.lim) {
	head()->next = head_id;
	undo()->next = UINT32_MAX;
	if (p.type != Var_t::Hybrid) {
		score.mode = ScoreLook::score_max_min;
	}
	else {
		score.mode = ScoreLook::score_max;
	}
	score.types = p.type;
	if (p.topLevelImps) { head()->lit.flag(); }
	score.nant = p.restrictNant;
}

Lookahead::~Lookahead() {}

void Lookahead::detach(Solver& s) {
	s.removePost(this);
	while (saved_.size()>1) {
		s.removeUndoWatch(uint32(saved_.size()-1), this);
		saved_.pop_back();
	}
}
void Lookahead::destroy(Solver* s, bool detach) {
	if (s && detach) { Lookahead::detach(*s); }
	PostPropagator::destroy(s, detach);
}

uint32 Lookahead::priority() const { return priority_reserved_look; }

void Lookahead::clear() {
	score.clearDeps();
	while (!saved_.empty()) {
		if (saved_.back() != UINT32_MAX) {
			splice(saved_.back());
		}
		saved_.pop_back();
	}
	LookList(2, *head()).swap(nodes_);
	head()->next = head_id;
	undo()->next = UINT32_MAX;
	last_        = head_id;
	top_         = UINT32_MAX;
}

bool Lookahead::init(Solver& s) {
	ScoreLook& sc = score;
	sc.clearDeps();
	Var start     = (uint32)sc.score.size();
	sc.score.resize(s.numVars()+1);
	const VarType types= sc.types;
	const bool uniform = types != Var_t::Hybrid;
	uint32 add    = 0;
	uint32 nants  = 0;
	for (Var v = start; v <= s.numVars(); ++v) {
		if (s.value(v) == value_free && (s.varInfo(v).type() & types) != 0 ) {
			++add;
			nants += s.varInfo(v).nant();
		}
	}
	nodes_.reserve(nodes_.size() + add);
	for (Var v = start; v <= s.numVars(); ++v) {
		if (s.value(v) == value_free && (s.varInfo(v).type() & types) != 0 ) {
			append(Literal(v, s.varInfo(v).preferredSign()), uniform || s.varInfo(v).type() == Var_t::Hybrid);
		}
	}
	if (add && score.nant) {
		score.nant = add != nants && nants != 0;
	}
	return true;
}

void Lookahead::append(Literal p, bool testBoth) {
	node(last_)->next = static_cast(nodes_.size());
	nodes_.push_back(LitNode(p));
	last_             = node(last_)->next;
	node(last_)->next = head_id;
	// remember to also test ~p by setting watched-flag
	if (testBoth) { node(last_)->lit.flag(); }
}

// test p and optionally ~p if necessary
bool Lookahead::test(Solver& s, Literal p) {
	return (score.score[p.var()].seen(p) || s.test(p, this))
		&& (!p.flagged() || score.score[p.var()].seen(~p) || s.test(~p, this))
		&& (imps_.empty() || checkImps(s, p));
}

bool Lookahead::checkImps(Solver& s, Literal p) {
	assert(!imps_.empty());
	bool ok = true;
	if (score.score[p.var()].testedBoth()) {
		for (LitVec::const_iterator it = imps_.begin(), end = imps_.end(); it != end && ok; ++it) {
			ok  = s.force(*it, lit_true());
		}
	}
	imps_.clear();
	return ok && (s.queueSize() == 0 || s.propagateUntil(this));
}

// failed-literal detection - stop on failed-literal
bool Lookahead::propagateLevel(Solver& s) {
	assert(!s.hasConflict());
	saved_.resize(s.decisionLevel()+1, UINT32_MAX);
	uint32 undoId = saved_[s.decisionLevel()];
	if (undoId == UINT32_MAX) {
		undoId = undo_id;
		if (s.decisionLevel() != 0) {
			s.addUndoWatch(s.decisionLevel(), this);
		}
	}
	score.clearDeps();
	score.addDeps = true;
	Literal p     = node(pos_)->lit;
	bool   ok     = s.value(p.var()) != value_free || test(s, p);
	for (LitNode* r = node(pos_); r->next != pos_ && ok; ) {
		p = node(r->next)->lit;
		if (s.value(p.var()) == value_free) {
			if (test(s, p)) { r   = node(r->next); }
			else            { pos_= r->next; ok = false; }
		}
		else if (r->next != last_ && r->next != head_id) {
			// unlink from candidate list
			NodeId t       = r->next;
			r->next        = node(t)->next;
			// append to undo list
			LitNode* u     = node(undoId);
			node(t)->next  = u->next;
			u->next        = t;
			undoId         = t;
		}
		else { r = node(r->next); } // keep iterators valid; never unlink last node and dummy head
	}
	saved_.back() = undoId;
	return ok;
}

bool Lookahead::propagateFixpoint(Solver& s, PostPropagator* ctx) {
	if ((empty() || top_ == s.numAssignedVars()) && !score.deps.empty()) {
		// nothing to lookahead
		return true;
	}
	bool ok = true;
	uint32 dl;
	for (dl = s.decisionLevel(); !propagateLevel(s); dl = s.decisionLevel()) {
		// some literal failed
		// resolve and propagate conflict
		assert(s.decisionLevel() >= dl);
		if (!s.resolveConflict() || !s.propagateUntil(this)) {
			ok = false;
			score.clearDeps();
			break;
		}
	}
	if (dl == 0 && ok) {
		// remember top-level size - no need to redo lookahead
		// on level 0 unless we learn a new implication
		assert(s.queueSize() == 0);
		top_ = s.numAssignedVars();
		LitVec().swap(imps_);
	}
	if (!ctx && limit_ && --limit_ == 0) {
		this->destroy(&s, true);
	}
	return ok;
}

// splice list [undo_.next, ul] back into candidate list
void Lookahead::splice(NodeId ul) {
	assert(ul != UINT32_MAX);
	if (ul != undo_id) {
		assert(undo()->next != UINT32_MAX);
		// unlink from undo list
		LitNode* ulNode= node(ul);
		NodeId   first = undo()->next;
		undo()->next   = ulNode->next;
		// splice into look-list
		ulNode->next   = head()->next;
		head()->next   = first;
	}
}

void Lookahead::undoLevel(Solver& s) {
	if (s.decisionLevel() == saved_.size()) {
		cancelPropagation();
		const LitVec& a = s.trail();
		score.scoreLits(s, &a[0]+s.levelStart(s.decisionLevel()), &a[0]+a.size());
		if (s.decisionLevel() == static_cast(head()->lit.flagged())) {
			const Literal* b = &a[0]+s.levelStart(s.decisionLevel());
			if (b->flagged()) {
				// remember current DL for b
				uint32 dist = static_cast(((&a[0]+a.size()) - b));
				imps_.assign(b+1, b + std::min(dist, uint32(2048)));
			}
			else if (score.score[b->var()].testedBoth()) {
				// all true lits in imps_ follow from both *b and ~*b
				// and are therefore implied
				LitVec::iterator j = imps_.begin();
				for (LitVec::iterator it = imps_.begin(), end = imps_.end(); it != end; ++it) {
					if (s.isTrue(*it)) { *j++ = *it; }
				}
				imps_.erase(j, imps_.end());
			}
		}
	}
	else {
		assert(saved_.size() >= s.decisionLevel()+1);
		saved_.resize(s.decisionLevel()+1);
		NodeId n = saved_.back();
		saved_.pop_back();
		splice(n);
		assert(node(last_)->next == head_id);
		score.clearDeps();
	}
}

Literal Lookahead::heuristic(Solver& s) {
	if (s.value(score.best) != value_free) {
		// no candidate available
		return lit_true();
	}
	ScoreLook& sc = score;
	Literal choice= Literal(sc.best, sc.score[sc.best].prefSign());
	if (!sc.deps.empty() && sc.mode == ScoreLook::score_max_min) {
		// compute heuristic values for candidates skipped during last lookahead
		uint32 min, max;
		sc.score[sc.best].score(max, min);
		sc.addDeps = false;
		bool ok    = true;
		LitVec::size_type i = 0;
		do {
			Var v        = sc.deps[i];
			VarScore& vs = sc.score[v];
			if (s.value(v) == value_free) {
				uint32 vMin, vMax;
				vs.score(vMax, vMin);
				if (vMin == 0 || vMin > min || (vMin == min && vMax > max)) {
					uint32 neg = vs.score(negLit(v)) > 0 ? vs.score(negLit(v)) : max+1;
					uint32 pos = vs.score(posLit(v)) > 0 ? vs.score(posLit(v)) : max+1;
					if (!vs.tested(negLit(v))) {
						ok  = ok && s.test(negLit(v), this);
						neg = vs.score(negLit(v));
					}
					if ((neg > min || (neg == min && pos > max)) && !vs.tested(posLit(v))) {
						ok  = ok && s.test(posLit(v), this);
					}
				}
				if (vs.testedBoth() && sc.greaterMaxMin(v, max, min)) {
					vs.score(max, min);
					choice = Literal(v, vs.prefSign());
				}
			}
		} while (++i != sc.deps.size() && ok);
		if (!ok) {
			// One of the candidates failed. Since none of them failed
			// during previous propagation, this indicates that
			// either some post propagator has wrong priority or
			// parallel solving is active and a stop conflict was set.
			// Since we can't resolve the problem here, we simply return the
			// literal that caused the conflict
			assert(s.hasConflict());
			return lit_false();
		}
	}
	return choice;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Lookahead heuristic
/////////////////////////////////////////////////////////////////////////////////////////
UnitHeuristic::UnitHeuristic() { }
void UnitHeuristic::endInit(Solver& s) {
	Lookahead* look = static_cast(s.getPost(Lookahead::priority_reserved_look));
	if (!look) { s.addPost(new Lookahead(Var_t::Atom)); }
}
Literal UnitHeuristic::doSelect(Solver& s) {
	Lookahead* look = static_cast(s.getPost(Lookahead::priority_reserved_look));
	Literal x       = look ? look->heuristic(s) : lit_true();
	if (x != lit_true()) { return x; }
	return SelectFirst::doSelect(s);
}
/////////////////////////////////////////////////////////////////////////////////////////
// Restricted Lookahead heuristic - lookahead and heuristic for a limited number of ops
/////////////////////////////////////////////////////////////////////////////////////////
class Restricted : public UnitHeuristic {
public:
	typedef LitVec::size_type size_t;
	typedef ConstraintType    con_t;
	Restricted(DecisionHeuristic* other)
		: UnitHeuristic()
		, other_(other) {
	}
	Literal doSelect(Solver& s) {
		Lookahead* look = static_cast(s.getPost(Lookahead::priority_reserved_look));
		if (look && !look->hasLimit()) { look = 0; }
		Literal x = look ? look->heuristic(s) : lit_true();
		if (x == lit_true()) { x = other_->doSelect(s); }
		if (!look)          { s.setHeuristic(other_.release(), Ownership_t::Acquire); }
		return x;
	}
	// heuristic interface - forward to other
	void startInit(const Solver& s)           { other_->startInit(s); }
	void endInit(Solver& s)                   { other_->endInit(s); }
	void setConfig(const HeuParams& p)        { other_->setConfig(p); }
	void detach(Solver& s)                    { if (other_.is_owner()) { other_->detach(s); } }
	void simplify(const Solver& s, size_t st) { other_->simplify(s, st); }
	void undoUntil(const Solver& s, size_t st){ other_->undoUntil(s, st); }
	void updateReason(const Solver& s, const LitVec& x, Literal r)            { other_->updateReason(s, x, r); }
	bool bump(const Solver& s, const WeightLitVec& w, double d)               { return other_->bump(s, w, d); }
	void newConstraint(const Solver& s, const Literal* p, size_t sz, con_t t) { other_->newConstraint(s, p, sz, t); }
	void updateVar(const Solver& s, Var v, uint32 n)                          { other_->updateVar(s, v, n); }
	Literal selectRange(Solver& s, const Literal* f, const Literal* l)        { return other_->selectRange(s, f, l); }
private:
	typedef SingleOwnerPtr HeuPtr;
	HeuPtr other_;
};

UnitHeuristic* UnitHeuristic::restricted(DecisionHeuristic* other) {
	return new Restricted(other);
}
}
clasp-3.2.2/libclasp/src/minimize_constraint.cpp000066400000000000000000001314721304134206100217730ustar00rootroot00000000000000//
// Copyright (c) 2010-2015, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// SharedMinimizeData
/////////////////////////////////////////////////////////////////////////////////////////
SharedMinimizeData::SharedMinimizeData(const SumVec& lhsAdjust, MinimizeMode m) : mode_(m) {
	adjust_ = lhsAdjust;
	lower_  = new LowerType[adjust_.size()];
	count_  = 1;
	resetBounds();
	setMode(MinimizeMode_t::optimize);
}
SharedMinimizeData::~SharedMinimizeData() {
	delete[] lower_;
}

void SharedMinimizeData::destroy() const {
	this->~SharedMinimizeData();
	::operator delete(const_cast(this));
}

void SharedMinimizeData::resetBounds() {
	gCount_  = 0;
	optGen_  = 0;
	std::fill_n(lower_, numRules(), wsum_t(0));
	up_[0].assign(numRules(), maxBound());
	up_[1].assign(numRules(), maxBound());
	const WeightLiteral* lit = lits;
	for (weight_t wPos = 0, end = (weight_t)weights.size(), x; wPos != end; wPos = x+1) {
		assert(weights[wPos].weight >= 0);
		for (x = wPos; weights[x].next; ) { // compound weight - check for negative
			if (weights[++x].weight < 0) {
				while (lit->second != wPos) { ++lit; }
				for (const WeightLiteral* t = lit; t->second == wPos; ++t) {
					lower_[weights[x].level] += weights[x].weight;
				}
			}
		}
	}
}

bool SharedMinimizeData::setMode(MinimizeMode m, const wsum_t* bound, uint32 boundSize)  {
	mode_ = m;
	if (boundSize && bound) {
		SumVec& opt = up_[0];
		bool    ok  = false;
		gCount_     = 0;
		optGen_     = 0;
		boundSize   = std::min(boundSize, numRules());
		for (uint32 i = 0, end = boundSize; i != end; ++i) {
			wsum_t B = bound[i], a = adjust(i);
			B        = a >= 0 || (maxBound() + a) >= B ? B - a : maxBound();
			wsum_t d = B - lower_[i];
			if (d < 0 && !ok) { return false; }
			opt[i]   = B;
			ok       = ok || d > 0;
		}
		for (uint32 i = boundSize, end = (uint32)opt.size(); i != end; ++i) { opt[i] = maxBound(); }
	}
	return true;
}

MinimizeConstraint* SharedMinimizeData::attach(Solver& s, MinimizeMode_t::Strategy strat, uint32 param, bool addRef) {
	if (addRef) this->share();
	MinimizeConstraint* ret;
	if (strat == MinimizeMode_t::opt_bb || mode() == MinimizeMode_t::enumerate) {
		ret = new DefaultMinimize(this, param);
	}
	else {
		ret = new UncoreMinimize(this, param);
	}
	ret->attach(s);
	return ret;
}

const SumVec* SharedMinimizeData::setOptimum(const wsum_t* newOpt) {
	if (optGen_) { return up_ + (optGen_&1u); }
	uint32  g = gCount_;
	uint32  n = 1u - (g & 1u);
	SumVec& U = up_[n];
	U.assign(newOpt, newOpt + numRules());
	assert(mode() != MinimizeMode_t::enumerate || n == 1);
	if (mode() != MinimizeMode_t::enumerate) {
		if (++g == 0) { g = 2; }
		gCount_  = g;
	}
	return &U;
}
void SharedMinimizeData::setLower(uint32 lev, wsum_t low) {
	lower_[lev] = low;
}
wsum_t SharedMinimizeData::incLower(uint32 at, wsum_t low){
	for (wsum_t stored;;) {
		if ((stored = lower(at)) >= low) {
			return stored;
		}
		if (lower_[at].compare_and_swap(low, stored) == stored) {
			return low;
		}
	}
}
wsum_t SharedMinimizeData::lower(uint32 lev) const {
	return lower_[lev];
}
wsum_t SharedMinimizeData::optimum(uint32 lev) const {
	wsum_t o = sum(lev);
	return o + (o != maxBound() ? adjust(lev) : 0);
}
void SharedMinimizeData::markOptimal() {
	optGen_ = generation();
}
void SharedMinimizeData::sub(wsum_t* lhs, const LevelWeight* w, uint32& aLev) const {
	if (w->level < aLev) { aLev = w->level; }
	do { lhs[w->level] -= w->weight; } while (w++->next);
}
bool SharedMinimizeData::imp(wsum_t* lhs, const LevelWeight* w, const wsum_t* rhs, uint32& lev) const {
	assert(lev <= w->level && std::equal(lhs, lhs+lev, rhs));
	while (lev != w->level && lhs[lev] == rhs[lev]) { ++lev; }
	for (uint32 i = lev, end = numRules(); i != end; ++i) {
		wsum_t temp = lhs[i];
		if (i == w->level) { temp += w->weight; if (w->next) ++w; }
		if (temp != rhs[i]){ return temp > rhs[i]; }
	}
	return false;
}
/////////////////////////////////////////////////////////////////////////////////////////
// MinimizeConstraint
/////////////////////////////////////////////////////////////////////////////////////////
MinimizeConstraint::MinimizeConstraint(SharedData* d) : shared_(d) {}

MinimizeConstraint::~MinimizeConstraint() {
	assert(shared_ == 0 && "MinimizeConstraint not destroyed!");
}
bool MinimizeConstraint::prepare(Solver& s, bool useTag) {
	CLASP_ASSERT_CONTRACT_MSG(!s.isFalse(tag_), "Tag literal must not be false!");
	if (useTag && tag_ == lit_true())      { tag_ = posLit(s.pushTagVar(false)); }
	if (s.isTrue(tag_) || s.hasConflict()){ return !s.hasConflict(); }
	return useTag ? s.pushRoot(tag_) : s.force(tag_, 0);
}
void MinimizeConstraint::destroy(Solver* s, bool d) {
	shared_->release();
	shared_ = 0;
	Constraint::destroy(s, d);
}
void MinimizeConstraint::reportLower(Solver& s, uint32 lev, wsum_t low) const {
	s.lower.level = lev;
	s.lower.bound = low + shared_->adjust(lev);
}
/////////////////////////////////////////////////////////////////////////////////////////
// DefaultMinimize
/////////////////////////////////////////////////////////////////////////////////////////
union DefaultMinimize::UndoInfo {
	UndoInfo() : rep(0) {}
	struct {
		uint32 idx    : 30; // index of literal on stack
		uint32 newDL  :  1; // first literal of new DL?
		uint32 idxSeen:  1; // literal with idx already propagated?
	}      data;
	uint32 rep;
	uint32 index() const { return data.idx; }
	bool   newDL() const { return data.newDL != 0u; }
};
DefaultMinimize::DefaultMinimize(SharedData* d, uint32 strat)
	: MinimizeConstraint(d)
	, bounds_(0)
	, pos_(d->lits)
	, undo_(0)
	, undoTop_(0)
	, size_(d->numRules()) {
	step_.type = strat & 3u;
	if (step_.type == MinimizeMode_t::bb_step_hier && d->numRules() == 1) {
		step_.type = 0;
	}
}

DefaultMinimize::~DefaultMinimize() {
	delete [] bounds_;
	delete [] undo_;
}

void DefaultMinimize::destroy(Solver* s, bool detach) {
	if (s && detach) {
		for (const WeightLiteral* it = shared_->lits; !isSentinel(it->first); ++it) {
			s->removeWatch(it->first, this);
		}
		for (uint32 dl = 0; (dl = lastUndoLevel(*s)) != 0; ) {
			s->removeUndoWatch(dl, this);
			DefaultMinimize::undoLevel(*s);
		}
	}
	MinimizeConstraint::destroy(s, detach);
}

bool DefaultMinimize::attach(Solver& s) {
	assert(s.decisionLevel() == 0 && !bounds_);
	uint32 numL = 0;
	VarVec up;
	for (const WeightLiteral* it = shared_->lits; !isSentinel(it->first); ++it, ++numL) {
		if (s.value(it->first.var()) == value_free) {
			s.addWatch(it->first, this, numL);
		}
		else if (s.isTrue(it->first)) {
			up.push_back(numL);
		}
	}
	bounds_ = new wsum_t[(numRules() * (3 + uint32(step_.type != 0)))]; // upper, sum, temp, lower
	std::fill(this->opt(), this->sum(), SharedData::maxBound());
	std::fill(this->sum(), this->end(), wsum_t(0));
	stepInit(0);
	// [0,numL+1)      : undo stack
	// [numL+1, numL*2): pos  stack
	undo_    = new UndoInfo[(numL*2)+1];
	undoTop_ = 0;
	posTop_  = numL+1;
	actLev_  = 0;
	for (WeightVec::size_type i = 0; i != up.size(); ++i) {
		DefaultMinimize::propagate(s, shared_->lits[up[i]].first, up[i]);
	}
	return true;
}

// Returns the numerical highest decision level watched by this constraint.
uint32 DefaultMinimize::lastUndoLevel(const Solver& s) const {
	return undoTop_ != 0
		? s.level(shared_->lits[undo_[undoTop_-1].index()].first.var())
		: 0;
}
bool DefaultMinimize::litSeen(uint32 i) const { return undo_[i].data.idxSeen != 0; }

// Pushes the literal at index idx onto the undo stack
// and marks it as seen; if literal is first in current level
// adds a new undo watch.
void DefaultMinimize::pushUndo(Solver& s, uint32 idx) {
	assert(idx >= static_cast(pos_ - shared_->lits));
	undo_[undoTop_].data.idx  = idx;
	undo_[undoTop_].data.newDL= 0;
	if (lastUndoLevel(s) != s.decisionLevel()) {
		// remember current "look at" position and start
		// a new decision level on the undo stack
		undo_[posTop_++].data.idx = static_cast(pos_-shared_->lits);
		s.addUndoWatch(s.decisionLevel(), this);
		undo_[undoTop_].data.newDL = 1;
	}
	undo_[idx].data.idxSeen   = 1;
	++undoTop_;
}
/////////////////////////////////////////////////////////////////////////////////////////
// MinimizeConstraint - arithmetic strategy implementation
//
// For now we use a simple "switch-on-type" approach.
// In the future, if new strategies emerge, we may want to use a strategy hierarchy.
/////////////////////////////////////////////////////////////////////////////////////////
#define STRATEGY(x) shared_->x
// set *lhs = *rhs, where lhs != rhs
void DefaultMinimize::assign(wsum_t* lhs, wsum_t* rhs) const {
	std::memcpy(lhs, rhs, size_*sizeof(wsum_t));
}
// returns lhs > rhs
bool DefaultMinimize::greater(wsum_t* lhs, wsum_t* rhs, uint32 len, uint32& aLev) const {
	while (*lhs == *rhs && --len) { ++lhs, ++rhs; ++aLev; }
	return *lhs > *rhs;
}
/////////////////////////////////////////////////////////////////////////////////////////
Constraint::PropResult DefaultMinimize::propagate(Solver& s, Literal, uint32& data) {
	pushUndo(s, data);
	STRATEGY(add(sum(), shared_->lits[data]));
	return PropResult(propagateImpl(s, propagate_new_sum), true);
}

// Computes the set of literals implying p and returns
// the highest decision level of that set.
// PRE: p is implied on highest undo level
uint32 DefaultMinimize::computeImplicationSet(const Solver& s, const WeightLiteral& p, uint32& undoPos) {
	wsum_t* temp    = this->temp(), *opt = this->opt();
	uint32 up       = undoTop_, lev = actLev_;
	uint32 minLevel = std::max(s.level(tag_.var()), s.level(s.sharedContext()->stepLiteral().var()));
	// start from current sum
	assign(temp, sum());
	// start with full set
	for (UndoInfo u; up != 0; --up) {
		u = undo_[up-1];
		// subtract last element from set
		STRATEGY(sub(temp, shared_->lits[u.index()], lev));
		if (!STRATEGY(imp(temp, p, opt, lev))) {
			// p is no longer implied after we removed last literal,
			// hence [0, up) implies p @ level of last literal
			undoPos = up;
			return std::max(s.level(shared_->lits[u.index()].first.var()), minLevel);
		}
	}
	undoPos = 0;
	return minLevel;
}

bool DefaultMinimize::propagateImpl(Solver& s, PropMode m) {
	Iter it    = pos_;
	uint32 idx = static_cast(it - shared_->lits);
	uint32 DL  = s.decisionLevel();
	// current implication level or "unknown" if
	// we propagate a new optimum
	uint32 impLevel = DL + (m == propagate_new_opt);
	weight_t lastW  = -1;
	uint32 undoPos  = undoTop_;
	bool ok         = true;
	actLev_         = std::min(actLev_, shared_->level(idx));
	for (wsum_t* sum= this->sum(), *opt = this->opt(); ok && !isSentinel(it->first); ++it, ++idx) {
		// skip propagated/false literals
		if (litSeen(idx) || (m == propagate_new_sum && s.isFalse(it->first))) {
			continue;
		}
		if (lastW != it->second) {
			// check if the current weight is implied
			if (!STRATEGY(imp(sum, *it, opt, actLev_))) {
				// all good - current optimum is safe
				pos_    = it;
				return true;
			}
			// compute implication set and level of current weight
			if (m == propagate_new_opt) {
				impLevel = computeImplicationSet(s, *it, undoPos);
			}
			lastW = it->second;
		}
		assert(active());
		// force implied literals
		if (!s.isFalse(it->first) || (impLevel < DL && s.level(it->first.var()) > impLevel)) {
			if (impLevel != DL) { DL = s.undoUntil(impLevel, Solver::undo_pop_bt_level); }
			ok = s.force(~it->first, impLevel, this, undoPos);
		}
	}
	return ok;
}

// pops free literals from the undo stack and decreases current sum
void DefaultMinimize::undoLevel(Solver&) {
	assert(undoTop_ != 0 && posTop_ > undoTop_);
	uint32 up  = undoTop_;
	uint32 idx = undo_[--posTop_].index();
	for (wsum_t* sum = this->sum();;) {
		UndoInfo& u = undo_[--up];
		undo_[u.index()].data.idxSeen = 0;
		STRATEGY(sub(sum, shared_->lits[u.index()], actLev_));
		if (u.newDL()) { break; }
	}
	undoTop_ = up;
	Iter temp= shared_->lits + idx;
	if (temp < pos_) {
		pos_    = temp;
		actLev_ = std::min(actLev_, shared_->level(idx));
	}
}

// computes the reason for p -
// all literals that were propagated before p
void DefaultMinimize::reason(Solver& s, Literal p, LitVec& lits) {
	assert(s.isTrue(tag_));
	uint32 stop = s.reasonData(p);
	Literal   x = s.sharedContext()->stepLiteral();
	assert(stop <= undoTop_);
	if (!isSentinel(x) && s.isTrue(x)) { lits.push_back(x); }
	if (s.level(tag_.var()))           { lits.push_back(tag_); }
	for (uint32 i = 0; i != stop; ++i) {
		UndoInfo u = undo_[i];
		x = shared_->lits[u.index()].first;
		lits.push_back(x);
	}
}

bool DefaultMinimize::minimize(Solver& s, Literal p, CCMinRecursive* rec) {
	assert(s.isTrue(tag_));
	uint32 stop = s.reasonData(p);
	Literal   x = s.sharedContext()->stepLiteral();
	assert(stop <= undoTop_);
	if (!s.ccMinimize(x, rec) || !s.ccMinimize(tag_, rec)) { return false; }
	for (uint32 i = 0; i != stop; ++i) {
		UndoInfo u = undo_[i];
		x = shared_->lits[u.index()].first;
		if (!s.ccMinimize(x, rec)) {
			return false;
		}
	}
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// DefaultMinimize - bound management
/////////////////////////////////////////////////////////////////////////////////////////
// Stores the current sum as the shared optimum.
void DefaultMinimize::commitUpperBound(const Solver&)  {
	shared_->setOptimum(sum());
	if (step_.type == MinimizeMode_t::bb_step_inc) { step_.size *= 2; }
}
bool DefaultMinimize::commitLowerBound(Solver& s, bool upShared) {
	bool act  = active() && shared_->checkNext();
	bool more = step_.lev < size_ && (step_.size > 1 || step_.lev != size_-1);
	if (act && step_.type && step_.lev < size_) {
		uint32 x = step_.lev;
		wsum_t L = opt()[x] + 1;
		if (upShared) {
			wsum_t sv = shared_->incLower(x, L);
			if (sv == L) { reportLower(s, x, sv); }
			else         { L = sv; }
		}
		stepLow()= L;
		if (step_.type == MinimizeMode_t::bb_step_inc){ step_.size = 1; }
	}
	return more;
}
bool DefaultMinimize::handleUnsat(Solver& s, bool up, LitVec& out) {
	bool more = shared_->optimize() && commitLowerBound(s, up);
	uint32 dl = s.isTrue(tag_) ? s.level(tag_.var()) : 0;
	relaxBound(false);
	if (more && dl && dl <= s.rootLevel()) {
		s.popRootLevel(s.rootLevel()-dl, &out); // pop and remember new path
		return s.popRootLevel(1);               // pop tag - disable constraint
	}
	return false;
}

// Disables the minimize constraint by clearing its upper bound.
bool DefaultMinimize::relaxBound(bool full) {
	if (active()) { std::fill(opt(), opt()+size_, SharedData::maxBound()); }
	pos_       = shared_->lits;
	actLev_    = 0;
	if (full || !shared_->optimize()) { stepInit(0); }
	return true;
}

void DefaultMinimize::stepInit(uint32 n) {
	step_.size = uint32(step_.type != MinimizeMode_t::bb_step_dec);
	if (step_.type) { step_.lev = n; if (n != size_) stepLow() = 0-shared_->maxBound(); }
	else            { step_.lev = shared_->maxLevel(); }
}

// Integrates new (tentative) bounds from the ones stored in the shared data object.
bool DefaultMinimize::integrateBound(Solver& s) {
	bool useTag = shared_->optimize() && (step_.type != 0 || shared_->mode() == MinimizeMode_t::enumOpt);
	if (!prepare(s, useTag)) { return false; }
	if (useTag && s.level(tag_.var()) == 0) {
		step_.type = 0;
		stepInit(0);
	}
	if ((active() && !shared_->checkNext())) { return !s.hasConflict(); }
	WeightLiteral min(lit_true(), shared_->weights.empty() ? uint32(0) : (uint32)shared_->weights.size()-1);
	while (!s.hasConflict() && updateBounds(shared_->checkNext())) {
		uint32 x = 0;
		uint32 dl= s.decisionLevel() + 1;
		if (!STRATEGY(imp(sum(), min, opt(), actLev_)) || (dl = computeImplicationSet(s, min, x)) > s.rootLevel()) {
			for (--dl; !s.hasConflict() || s.resolveConflict(); ) {
				if      (s.undoUntil(dl, Solver::undo_pop_bt_level) > dl){ s.backtrack(); }
				else if (propagateImpl(s, propagate_new_opt))            { return true;   }
			}
		}
		if (!shared_->checkNext()) {
			break;
		}
		if (!step_.type) { ++step_.lev; }
		else             { stepLow() = ++opt()[step_.lev]; }
	}
	relaxBound(false);
	if (!s.hasConflict()) {
		s.undoUntil(0);
		s.setStopConflict();
	}
	return false;
}

// Loads bounds from the shared data object and (optionally) applies
// the current step to get the next tentative bound to check.
bool DefaultMinimize::updateBounds(bool applyStep) {
	for (;;) {
		const uint32  seq   = shared_->generation();
		const wsum_t* upper = shared_->upper();
		wsum_t*       myLow = step_.type ? end() : 0;
		wsum_t*       bound = opt();
		uint32        appLev= applyStep ? step_.lev : size_;
		for (uint32 i = 0; i != size_; ++i) {
			wsum_t U = upper[i], B = bound[i];
			if (i != appLev) {
				wsum_t L = shared_->lower(i);
				if (myLow) {
					if (i > step_.lev || L > myLow[i]) { myLow[i] = L; }
					else                               { L = myLow[i]; }
				}
				if      (i > appLev) { bound[i] = SharedData::maxBound(); }
				else if (U >= L)     { bound[i] = U; }
				else                 { stepInit(size_); return false; }
				continue;
			}
			if (step_.type) {
				wsum_t L = (stepLow() = std::max(myLow[i], shared_->lower(i)));
				if (U < L) { // path exhausted?
					stepInit(size_);
					return false;
				}
				if (B < L) { // tentative bound too strong?
					return false;
				}
				if (B < U) { // existing step?
					assert(std::count(bound+i+1, bound+size_, SharedData::maxBound()) == int(size_ - (i+1)));
					return true;
				}
				if (U == L) {// done with current level?
					bound[i] = U;
					stepInit(++appLev);
					continue;
				}
				assert(U > L && B > L);
				wsum_t diff = U - L;
				uint32 half = static_cast( (diff>>1) | (diff&1) );
				if (step_.type == MinimizeMode_t::bb_step_inc) {
					step_.size = std::min(step_.size, half);
				}
				else if (step_.type == MinimizeMode_t::bb_step_dec) {
					if (!step_.size) { step_.size = static_cast(diff); }
					else             { step_.size = half; }
				}
			}
			assert(step_.size != 0);
			bound[i] = U - step_.size;
			actLev_  = 0;
			pos_     = shared_->lits;
		}
		if (seq == shared_->generation()) { break; }
	}
	return step_.lev != size_ || !applyStep;
}
#undef STRATEGY
/////////////////////////////////////////////////////////////////////////////////////////
// MinimizeBuilder
/////////////////////////////////////////////////////////////////////////////////////////
MinimizeBuilder::MinimizeBuilder() { }
void MinimizeBuilder::clear() {
	LitVec().swap(lits_);
}
bool MinimizeBuilder::empty() const {
	return lits_.empty();
}
MinimizeBuilder& MinimizeBuilder::add(weight_t prio, const WeightLitVec& lits) {
	for (WeightLitVec::const_iterator it = lits.begin(), end = lits.end(); it != end; ++it) {
		add(prio, *it);
	}
	return *this;
}
MinimizeBuilder& MinimizeBuilder::add(weight_t prio, WeightLiteral lit) {
	lits_.push_back(MLit(lit, prio));
	return *this;
}
MinimizeBuilder& MinimizeBuilder::add(weight_t prio, weight_t w) {
	lits_.push_back(MLit(WeightLiteral(lit_true(), w), prio));
	return *this;
}
MinimizeBuilder& MinimizeBuilder::add(const SharedData& con) {
	if (con.numRules() == 1) {
		const weight_t P = !con.prios.empty() ? con.prios[0] : 0;
		for (const WeightLiteral* it = con.lits; !isSentinel(it->first); ++it) { add(P, *it); }
	}
	else {
		for (const WeightLiteral* it = con.lits; !isSentinel(it->first); ++it) {
			const SharedData::LevelWeight* w = &con.weights[it->second];
			do {
				add( w->level < con.prios.size() ? con.prios[w->level] : -static_cast(w->level), WeightLiteral(it->first, w->weight) );
			} while (w++->next);
		}
	}
	for (uint32 i = 0; i != con.numRules(); ++i) {
		if (wsum_t w = con.adjust(i)) {
			const weight_t P = i < con.prios.size() ? con.prios[i] : -static_cast(i);
			while (w < CLASP_WEIGHT_T_MIN) { add(P, CLASP_WEIGHT_T_MIN); w -= CLASP_WEIGHT_T_MIN; }
			while (w > CLASP_WEIGHT_T_MAX) { add(P, CLASP_WEIGHT_T_MAX); w -= CLASP_WEIGHT_T_MAX; }
			add(P, static_cast(w));
		}
	}
	return *this;
}
// Comparator for preparing levels: compare (prio, var, weight)
bool MinimizeBuilder::CmpPrio::operator()(const MLit& lhs, const MLit& rhs) const {
	if (lhs.prio != rhs.prio)           { return lhs.prio > rhs.prio; }
	if (lhs.lit.var() != rhs.lit.var()) { return lhs.lit  < rhs.lit; }
	return lhs.weight > rhs.weight;
}
// Comparator for merging levels: compare (var, level, weight)
bool MinimizeBuilder::CmpLit::operator()(const MLit& lhs, const MLit& rhs) const {
	if (lhs.lit.var() != rhs.lit.var()) { return lhs.lit  < rhs.lit; }
	if (lhs.prio != rhs.prio)           { return lhs.prio < rhs.prio; }
	return lhs.weight > rhs.weight;
}
// Comparator for sorting literals by final weight
bool MinimizeBuilder::CmpWeight::operator()(const MLit& lhs, const MLit& rhs) const {
	if (!weights) { return lhs.weight > rhs.weight; }
	const SharedData::LevelWeight* wLhs = &(*weights)[lhs.weight];
	const SharedData::LevelWeight* wRhs = &(*weights)[rhs.weight];
	for (;; ++wLhs, ++wRhs) {
		if (wLhs->level != wRhs->level)  { return wLhs->level < wRhs->level; }
		if (wLhs->weight != wRhs->weight){ return wLhs->weight > wRhs->weight; }
		if (!wLhs->next) { return wRhs->next && (++wRhs)->weight < 0; }
		if (!wRhs->next) { ++wLhs; break; }
	}
	return wLhs->weight > 0;
}

// Replaces integer priorities with increasing levels and merges duplicate/complementary literals.
void MinimizeBuilder::prepareLevels(const Solver& s, SumVec& adjust, WeightVec& prios) {
	// group first by decreasing priorities and then by variables
	std::stable_sort(lits_.begin(), lits_.end(), CmpPrio());
	prios.clear(); adjust.clear();
	// assign levels and simplify lits
	LitVec::iterator j = lits_.begin();
	for (LitVec::const_iterator it = lits_.begin(), end = lits_.end(); it != end;) {
		const weight_t P = it->prio, L = static_cast(prios.size());
		wsum_t R = 0;
		for (LitVec::const_iterator k; it != end && it->prio == P; it = k) {
			Literal x(it->lit); // make literal unique wrt this level
			wsum_t  w = it->weight;
			for (k = it + 1; k != end && k->lit.var() == x.var() && k->prio == P; ++k) {
				if (k->lit == x){ w += k->weight; }
				else            { w -= k->weight; R += k->weight; }
			}
			if (w < 0){
				R += w;
				x  = ~x;
				w  = -w;
			}
			if (w && s.value(x.var()) == value_free) {
				CLASP_FAIL_IF(static_cast(w) != w, "MinimizeBuilder: weight too large!");
				*j++ = MLit(WeightLiteral(x, static_cast(w)), L);
			}
			else if (s.isTrue(x)) { R += w; }
		}
		prios.push_back(P);
		adjust.push_back(R);
	}
	lits_.erase(j, lits_.end());
}

void MinimizeBuilder::mergeLevels(SumVec& adjust, SharedData::WeightVec& weights) {
	// group first by variables and then by increasing levels
	std::stable_sort(lits_.begin(), lits_.end(), CmpLit());
	LitVec::iterator j = lits_.begin();
	weights.clear(); weights.reserve(lits_.size());
	for (LitVec::const_iterator it = lits_.begin(), end = lits_.end(), k; it != end; it = k) {
		// handle first occurrence of var
		assert(it->weight > 0 && "most important occurrence of lit must have positive weight");
		weight_t wpos = (weight_t)weights.size();
		weights.push_back(SharedData::LevelWeight(it->prio, it->weight));
		// handle remaining occurrences with lower prios
		for (k = it + 1; k != end && k->lit.var() == it->lit.var(); ++k) {
			assert(k->prio > it->prio && "levels not prepared!");
			weights.back().next = 1;
			weights.push_back(SharedData::LevelWeight(k->prio, k->weight));
			if (k->lit.sign() != it->lit.sign()) {
				adjust[k->prio] += k->weight;
				weights.back().weight = -k->weight;
			}
		}
		(*j = *it).weight = wpos;
		++j;
	}
	lits_.erase(j, lits_.end());
}

MinimizeBuilder::SharedData* MinimizeBuilder::createShared(SharedContext& ctx, const SumVec& adjust, const CmpWeight& cmp) {
	const uint32 nLits = static_cast(lits_.size());
	SharedData*  ret   = new (::operator new(sizeof(SharedData) + ((nLits + 1)*sizeof(WeightLiteral)))) SharedData(adjust);
	// sort literals by decreasing weight
	std::stable_sort(lits_.begin(), lits_.end(), cmp);
	uint32   last = 0;
	weight_t wIdx = 0;
	for (uint32 i = 0; i != nLits; ++i) {
		WeightLiteral x(lits_[i].lit, lits_[i].weight);
		ctx.setFrozen(x.first.var(), true);
		ret->lits[i] = x;
		if (!cmp.weights) { continue; }
		if (!i || cmp(lits_[last], lits_[i])) {
			last = i;
			wIdx = (weight_t)ret->weights.size();
			for (const SharedData::LevelWeight* w = &(*cmp.weights)[x.second];; ++w) {
				ret->weights.push_back(*w);
				if (!w->next) { break; }
			}
		}
		ret->lits[i].second = wIdx;
	}
	ret->lits[nLits] = WeightLiteral(lit_true(), (weight_t)ret->weights.size());
	if (cmp.weights) {
		ret->weights.push_back(SharedData::LevelWeight((uint32)adjust.size()-1, 0));
	}
	ret->resetBounds();
	return ret;
}

MinimizeBuilder::SharedData* MinimizeBuilder::build(SharedContext& ctx) {
	CLASP_ASSERT_CONTRACT(!ctx.frozen());
	if ((!ctx.ok() || !ctx.master()->propagate()) || empty()) {
		clear();
		return 0;
	}
	typedef SharedData::WeightVec FlatVec;
	WeightVec prios;
	SumVec    adjust;
	FlatVec   weights;
	CmpWeight cmp(0);
	prepareLevels(*ctx.master(), adjust, prios);
	if (prios.size() > 1) {
		mergeLevels(adjust, weights);
		cmp.weights = &weights;
	}
	else if (prios.empty()) {
		prios.assign(1, 0);
		adjust.assign(1, 0);
	}
	SharedData* ret = createShared(ctx, adjust, cmp);
	ret->prios.swap(prios);
	clear();
	return ret;
}
/////////////////////////////////////////////////////////////////////////////////////////
// UncoreMinimize
/////////////////////////////////////////////////////////////////////////////////////////
UncoreMinimize::UncoreMinimize(SharedMinimizeData* d, uint32 strat)
	: MinimizeConstraint(d)
	, enum_(0)
	, sum_(new wsum_t[d->numRules()])
	, auxInit_(UINT32_MAX)
	, auxAdd_(0)
	, freeOpen_(0)
	, options_(0) {
	options_ = strat & 15u;
}
void UncoreMinimize::init() {
	releaseLits();
	fix_.clear();
	eRoot_ = 0;
	aTop_  = 0;
	upper_ = shared_->upper(0);
	lower_ = 0;
	gen_   = 0;
	level_ = 0;
	valid_ = 0;
	sat_   = 0;
	pre_   = 0;
	path_  = 1;
	next_  = 0;
	init_  = 1;
	actW_  = 1;
	nextW_ = 0;
}
bool UncoreMinimize::attach(Solver& s) {
	init();
	initRoot(s);
	auxInit_ = UINT32_MAX;
	auxAdd_  = 0;
	if (s.sharedContext()->concurrency() > 1 && shared_->mode() == MinimizeMode_t::enumOpt) {
		enum_ = new DefaultMinimize(shared_->share(), 0);
		enum_->attach(s);
		enum_->relaxBound(true);
	}
	return true;
}
// Detaches the constraint and all cores from s and removes
// any introduced aux vars.
void UncoreMinimize::detach(Solver* s, bool b) {
	releaseLits();
	if (s && auxAdd_ && s->numAuxVars() == (auxInit_ + auxAdd_)) {
		s->popAuxVar(auxAdd_, &closed_);
		auxInit_ = UINT32_MAX;
		auxAdd_  = 0;
	}
	Clasp::destroyDB(closed_, s, b);
	fix_.clear();
}
// Destroys this object and optionally detaches it from the given solver.
void UncoreMinimize::destroy(Solver* s, bool b) {
	detach(s, b);
	delete [] sum_;
	if (enum_) { enum_->destroy(s, b); enum_ = 0; }
	MinimizeConstraint::destroy(s, b);
}
Constraint::PropResult UncoreMinimize::propagate(Solver&, Literal, uint32&) {
	return PropResult(true, true);
}
bool UncoreMinimize::simplify(Solver& s, bool) {
	if (s.decisionLevel() == 0) { simplifyDB(s, closed_, false); }
	return false;
}
void UncoreMinimize::reason(Solver& s, Literal, LitVec& out) {
	uint32 r = initRoot(s);
	for (uint32 i = 1; i <= r; ++i) {
		out.push_back(s.decision(i));
	}
}

// Integrates any new information from this constraint into s.
bool UncoreMinimize::integrate(Solver& s) {
	assert(!s.isFalse(tag_));
	bool useTag = (shared_->mode() == MinimizeMode_t::enumOpt) || s.sharedContext()->concurrency() > 1;
	if (!prepare(s, useTag)) {
		return false;
	}
	if (enum_ && !shared_->optimize() && !enum_->integrateBound(s)) {
		return false;
	}
	for (uint32 gGen = shared_->generation(); gGen != gen_; ) {
		gen_   = gGen;
		upper_ = shared_->upper(level_);
		gGen   = shared_->generation();
		valid_ = 0;
	}
	return pushPath(s);
}

// Initializes the next optimization level to look at.
bool UncoreMinimize::initLevel(Solver& s) {
	initRoot(s);
	sat_   = 0;
	pre_   = 0;
	path_  = 1;
	init_  = 0;
	sum_[0]= -1;
	actW_  = 1;
	nextW_ = 0;
	if (!fixLevel(s)) {
		return false;
	}
	for (LitVec::const_iterator it = fix_.begin(), end = fix_.end(); it != end; ++it) {
		if (!s.force(*it, eRoot_, this)) { return false; }
	}
	if (!shared_->optimize()) {
		next_  = 0;
		level_ = shared_->maxLevel();
		lower_ = shared_->lower(level_);
		upper_ = shared_->upper(level_);
		return true;
	}
	weight_t maxW = 1;
	for (uint32 level = (level_ + next_), n = 1; level <= shared_->maxLevel() && assume_.empty(); ++level) {
		level_ = level;
		lower_ = 0;
		upper_ = shared_->upper(level_);
		for (const WeightLiteral* it = shared_->lits; !isSentinel(it->first); ++it) {
			if (weight_t w = shared_->weight(*it, level_)){
				Literal x = it->first;
				if (w < 0) {
					lower_ += w;
					w       = -w;
					x       = ~x;
				}
				if (s.value(x.var()) == value_free || s.level(x.var()) > eRoot_) {
					addLit(x, w);
					if (w > maxW){ maxW = w; }
				}
				else if (s.isTrue(x)) {
					lower_ += w;
				}
			}
		}
		if (n == 1) {
			if      (lower_ > upper_){ next_ = 1; break; }
			else if (lower_ < upper_){ next_ = (n = 0);  }
			else                     {
				n     = shared_->checkNext() || level != shared_->maxLevel();
				next_ = n;
				while (!assume_.empty()) {
					fixLit(s, assume_.back().lit);
					assume_.pop_back();
				}
				litData_.clear();
				assume_.clear();
				maxW = 1;
			}
		}
	}
	pre_  = (options_ & MinimizeMode_t::usc_preprocess) != 0u;
	actW_ = (options_ & MinimizeMode_t::usc_stratify) != 0u ? maxW : 1;
	valid_= (pre_ == 0 && maxW == 1);
	if (next_ && !s.hasConflict()) {
		s.force(~tag_, Antecedent(0));
		next_ = 0;
		pre_  = 0;
	}
	if (auxInit_ == UINT32_MAX) {
		auxInit_ = s.numAuxVars();
	}
	return !s.hasConflict();
}

UncoreMinimize::LitData& UncoreMinimize::addLit(Literal p, weight_t w) {
	assert(w > 0);
	litData_.push_back(LitData(w, true, 0));
	assume_.push_back(LitPair(~p, sizeVec(litData_)));
	if (nextW_ && w > nextW_) {
		nextW_ = w;
	}
	return litData_.back();
}

// Pushes the active assumptions from the active optimization level to
// the root path.
bool UncoreMinimize::pushPath(Solver& s) {
	bool ok   = !s.hasConflict() && !sat_ && (!path_ || (!next_ && !init_) || initLevel(s));
	bool path = path_ != 0;
	while (path) {
		uint32 j = 0;
		nextW_   = 0;
		path_    = uint32(path = false);
		ok       = ok && s.simplify() && s.propagate();
		initRoot(s);
		assert(s.queueSize() == 0);
		for (uint32 i = 0, end = sizeVec(assume_), dl; i != end; ++i) {
			LitData& x = getData(assume_[i].id);
			if (x.assume) {
				assume_[j++] = assume_[i];
				Literal lit  = assume_[i].lit;
				weight_t w   = x.weight;
				if (w < actW_) {
					nextW_ = std::max(nextW_, w);
					continue;
				}
				else if (!ok || s.isTrue(lit)) { continue; }
				else if ((lower_ + w) > upper_){
					ok   = fixLit(s, lit);
					path = true;
					x.assume = 0;
					x.weight = 0;
					if (hasCore(x)) { closeCore(s, x, false); }
					--j;
				}
				else if (s.value(lit.var()) == value_free) {
					ok    = path || s.pushRoot(lit);
					aTop_ = s.rootLevel();
				}
				else if (s.level(lit.var()) > eRoot_) {
					todo_.push_back(LitPair(~lit, assume_[i].id));
					ok = s.force(lit, Antecedent(0));
				}
				else {
					LitPair core(~lit, assume_[i].id);
					dl   = s.decisionLevel();
					ok   = addCore(s, &core, 1, x.weight);
					end  = sizeVec(assume_);
					path = path || (ok && s.decisionLevel() != dl);
					--j;
				}
			}
		}
		shrinkVecTo(assume_, j);
		CLASP_FAIL_IF(!sat_ && s.decisionLevel() != s.rootLevel(), "pushPath must be called on root level (%u:%u)", s.rootLevel(), s.decisionLevel());
	}
	if (sat_ || (ok && !validLowerBound())) {
		ok   = false;
		sat_ = 1;
		s.setStopConflict();
	}
	return ok;
}

// Removes invalid assumptions from the root path.
bool UncoreMinimize::popPath(Solver& s, uint32 dl, LitVec& out) {
	CLASP_ASSERT_CONTRACT(dl <= aTop_ && eRoot_ <= aTop_ && "You must not mess with my root level!");
	if (dl < eRoot_) { dl = eRoot_; }
	if (s.rootLevel() > aTop_) {
		// remember any assumptions added after us and
		// force removal of our assumptions because we want
		// them nicely arranged one after another
		s.popRootLevel(s.rootLevel() - aTop_, &out, true);
		dl    = eRoot_;
		path_ = 1;
		CLASP_FAIL_IF(true, "TODO: splitting not yet supported!");
	}
	return s.popRootLevel(s.rootLevel() - (aTop_ = dl));
}

bool UncoreMinimize::relax(Solver& s, bool reset) {
	if (sat_ && !reset) {
		// commit cores of last model
		s.setStopConflict();
		LitVec ignore;
		handleUnsat(s, false, ignore);
	}
	if ((reset && shared_->optimize()) || !assume_.empty() || level_ != shared_->maxLevel() || next_) {
		detach(&s, true);
		init();
	}
	else {
		releaseLits();
	}
	if (!shared_->optimize()) {
		gen_  = shared_->generation();
		next_ = 0;
		valid_= 1;
	}
	init_ = 1;
	sat_  = 0;
	assert(assume_.empty());
	return !enum_ || enum_->relax(s, reset);
}

// Computes the costs of the current assignment.
wsum_t* UncoreMinimize::computeSum(Solver& s) const {
	std::fill_n(sum_, shared_->numRules(), wsum_t(0));
	for (const WeightLiteral* it = shared_->lits; !isSentinel(it->first); ++it) {
		if (s.isTrue(it->first)) { shared_->add(sum_, *it); }
	}
	return sum_;
}

void UncoreMinimize::setLower(wsum_t x) {
	if (!pre_ && x > lower_ && nextW_ == 0) {
		fprintf(stderr, "*** WARNING: Fixing lower bound (%u - %u)\n", (uint32)lower_, (uint32)x);
		lower_ = x;
	}
}

// Checks whether the current assignment in s is valid w.r.t the
// bound stored in the shared data object.
bool UncoreMinimize::valid(Solver& s) {
	if (shared_->upper(level_) == SharedData::maxBound()){ return true; }
	if (gen_ == shared_->generation() && valid_ == 1)    { return true; }
	if (sum_[0] < 0) { computeSum(s); }
	const wsum_t* rhs;
	uint32 end  = shared_->numRules();
	wsum_t cmp  = 0;
	do {
		gen_  = shared_->generation();
		rhs   = shared_->upper();
		upper_= rhs[level_];
		for (uint32 i = level_; i != end && (cmp = sum_[i]-rhs[i]) == 0; ++i) { ; }
	} while (gen_ != shared_->generation());
	wsum_t low = sum_[level_];
	if (s.numFreeVars() != 0) { sum_[0] = -1; }
	if (cmp < wsum_t(!shared_->checkNext())) {
		valid_ = s.numFreeVars() == 0;
		return true;
	}
	valid_ = 0;
	sat_   = 1;
	setLower(low);
	s.setStopConflict();
 	return false;
}
// Sets the current sum as the current shared optimum.
bool UncoreMinimize::handleModel(Solver& s) {
	if (!valid(s))  { return false; }
	if (sum_[0] < 0){ computeSum(s);}
	shared_->setOptimum(sum_);
	sat_  = shared_->checkNext();
	gen_  = shared_->generation();
	upper_= shared_->upper(level_);
	valid_= 1;
	if (sat_) { setLower(sum_[level_]); }
	return true;
}

// Tries to recover from either a model or a root-level conflict.
bool UncoreMinimize::handleUnsat(Solver& s, bool up, LitVec& out) {
	assert(s.hasConflict());
	if (enum_) { enum_->relaxBound(true); }
	path_   = 1;
	sum_[0] = -1;
	do {
		if (sat_ == 0) {
			if (s.hasStopConflict()) { return false; }
			weight_t mw;
			uint32 cs = analyze(s, mw, out);
			if (!cs) {
				todo_.clear();
				return false;
			}
			if (pre_ == 0) {
				addCore(s, &todo_[0], cs, mw);
				todo_.clear();
			}
			else { // preprocessing: remove assumptions and remember core
				todo_.push_back(LitPair(lit_true(), 0)); // null-terminate core
				lower_ += mw;
				for(LitSet::iterator it = todo_.end() - (cs + 1); it->id; ++it) {
					getData(it->id).assume = 0;
				}
			}
			sat_ = !validLowerBound();
			if (up && shared_->incLower(level_, lower_) == lower_) {
				reportLower(s, level_, lower_);
			}
		}
		else {
			s.clearStopConflict();
			popPath(s, 0, out);
			sat_ = 0;
			for (LitSet::iterator it = todo_.begin(), end = todo_.end(), cs; (cs = it) != end; ++it) {
				weight_t w = std::numeric_limits::max();
				while (it->id) { w = std::min(w, getData(it->id).weight); ++it; }
				lower_    -= w;
				if (!addCore(s, &*cs, uint32(it - cs), w)) { break; }
			}
			wsum_t cmp = (lower_ - upper_);
			if (cmp >= 0) {
				fixLevel(s);
				if (cmp > 0) { s.hasConflict() || s.force(~tag_, Antecedent(0)); }
				else         { next_ = level_ != shared_->maxLevel() || shared_->checkNext(); }
			}
			if (pre_) {
				LitSet().swap(todo_);
				pre_ = 0;
			}
			if (nextW_) {
				actW_ = nextW_;
				valid_= 0;
				pre_  = (options_ & MinimizeMode_t::usc_preprocess) != 0u;
			}
		}
	} while (sat_ || s.hasConflict() || (next_ && out.empty() && !initLevel(s)));
	return true;
}

// Analyzes the current root level conflict and stores the set of our assumptions
// that caused the conflict in todo_.
uint32 UncoreMinimize::analyze(Solver& s, weight_t& minW, LitVec& poppedOther) {
	uint32 cs    = 0;
	uint32 minDL = s.decisionLevel();
	minW         = std::numeric_limits::max();
	if (!todo_.empty() && todo_.back().id) {
		cs   = 1;
		minW = getData(todo_.back().id).weight;
		minDL= s.level(todo_.back().lit.var());
	}
	if (s.decisionLevel() <= eRoot_) {
		return cs;
	}
	conflict_.clear();
	s.resolveToCore(conflict_);
	for (LitVec::const_iterator it = conflict_.begin(), end = conflict_.end(); it != end; ++it) {
		s.markSeen(*it);
	}
	// map marked root decisions back to our assumptions
	Literal p;
	uint32 roots = (uint32)conflict_.size(), dl;
	for (LitSet::iterator it = assume_.begin(), end = assume_.end(); it != end && roots; ++it) {
		if (s.seen(p = it->lit) && (dl = s.level(p.var())) > eRoot_ && dl <= aTop_) {
			assert(p == s.decision(dl) && getData(it->id).assume);
			if (dl < minDL) { minDL = dl; }
			minW = std::min(getData(it->id).weight, minW);
			todo_.push_back(LitPair(~p, it->id));
			++cs;
			s.clearSeen(p.var());
			--roots;
		}
	}
	popPath(s, minDL - (minDL != 0), poppedOther);
	if (roots) { // clear remaining levels - can only happen if someone messed with our assumptions
		for (LitVec::const_iterator it = conflict_.begin(), end = conflict_.end(); it != end; ++it) { s.clearSeen(it->var()); }
	}
	return cs;
}

// Eliminates the given core by adding suitable constraints to the solver.
bool UncoreMinimize::addCore(Solver& s, const LitPair* lits, uint32 cs, weight_t w) {
	assert(s.decisionLevel() == s.rootLevel());
	assert(w && cs);
	// apply weight and check for subcores
	lower_ += w;
	for (uint32 i = 0; i != cs; ++i) {
		LitData& x = getData(lits[i].id);
		if ( (x.weight -= w) <= 0) {
			x.assume = 0;
			x.weight = 0;
		}
		else if (pre_ && !x.assume) {
			x.assume = 1;
			assume_.push_back(LitPair(~lits[i].lit, lits[i].id));
		}
		if (x.weight == 0 && hasCore(x)) {
			Core& core = getCore(x);
			temp_.start(core.bound + 1);
			for (uint32 k = 0, end = core.size(); k != end; ++k) {
				Literal p = core.at(k);
				while (s.topValue(p.var()) != s.value(p.var()) && s.rootLevel() > eRoot_) {
					s.popRootLevel(s.rootLevel() - std::max(s.level(p.var())-1, eRoot_));
					aTop_ = std::min(aTop_, s.rootLevel());
				}
				temp_.add(s, p);
			}
			weight_t cw = core.weight;
			if (!closeCore(s, x, temp_.bound <= 1) || !addOllCon(s, temp_, cw)) {
				return false;
			}
		}
	}
	// add new core
	return (options_ & MinimizeMode_t::usc_clauses) == 0u
		? addOll(s, lits, cs, w)
		: addPmr(s, lits, cs, w);
}
bool UncoreMinimize::addOll(Solver& s, const LitPair* lits, uint32 size, weight_t w) {
	temp_.start(2);
	for (uint32 i = 0; i != size; ++i) { temp_.add(s, lits[i].lit); }
	if (!temp_.unsat()) {
		return addOllCon(s, temp_, w);
	}
	Literal fix = !temp_.lits.empty() ? temp_.lits[0].first : lits[0].lit;
	return temp_.bound < 2 || fixLit(s, fix);
}
bool UncoreMinimize::addPmr(Solver& s, const LitPair* lits, uint32 size, weight_t w) {
	if (size == 1) {
		return fixLit(s, lits[0].lit);
	}
	uint32 i   = size - 1;
	Literal bp = lits[i].lit;
	while (--i != 0) {
		Literal an = lits[i].lit;
		Literal bn = posLit(s.pushAuxVar());
		Literal cn = posLit(s.pushAuxVar());
		auxAdd_ += 2;
		addLit(cn, w);
		if (!addPmrCon(comp_disj, s, bn, an, bp)) { return false; }
		if (!addPmrCon(comp_conj, s, cn, an, bp)) { return false; }
		bp = bn;
	}
	Literal an = lits[i].lit;
	Literal cn = posLit(s.pushAuxVar());
	++auxAdd_;
	addLit(cn, w);
	return addPmrCon(comp_conj, s, cn, an, bp);
}
bool UncoreMinimize::addPmrCon(CompType c, Solver& s, Literal head, Literal body1, Literal body2) {
	typedef ClauseCreator::Result Result;
	const uint32 flags = ClauseCreator::clause_explicit | ClauseCreator::clause_not_root_sat | ClauseCreator::clause_no_add;
	const bool    sign = c == comp_conj;
	uint32       first = 0, last = 3;
	if ((options_ & MinimizeMode_t::usc_imp_only) != 0u) {
		first = c == comp_disj;
		last  = first + (1 + (c == comp_disj));
	}
	Literal temp[3][3] = {
		{ (~head)^ sign,   body1 ^ sign, body2 ^ sign },
		{   head ^ sign, (~body1)^ sign, lit_false() },
		{   head ^ sign, (~body2)^ sign, lit_false() }
	};
	for (uint32 i = first, sz = 3; i != last; ++i) {
		Result res = ClauseCreator::create(s, ClauseRep::create(temp[i], sz, Constraint_t::Other), flags);
		if (res.local) { closed_.push_back(res.local); }
		if (!res.ok()) { return false; }
		sz = 2;
	}
	return true;
}
bool UncoreMinimize::addOllCon(Solver& s, const WCTemp& wc, weight_t weight) {
	typedef WeightConstraint::CPair ResPair;
	weight_t B = wc.bound;
	if (B <= 0) {
		// constraint is sat and hence conflicting w.r.t new assumption -
		// relax core
		lower_ += ((1-B)*weight);
		B       = 1;
	}
	if (static_cast(B) > static_cast(wc.lits.size())) {
		// constraint is unsat and hence the new assumption is trivially satisfied
		return true;
	}
	// create new var for this core
	Var newAux = s.pushAuxVar();
	++auxAdd_;
	LitData& x = addLit(negLit(newAux), weight);
	WeightLitsRep rep = {&const_cast(wc).lits[0], (uint32)wc.lits.size(), B, (weight_t)wc.lits.size()};
	uint32       fset = WeightConstraint::create_explicit | WeightConstraint::create_no_add | WeightConstraint::create_no_freeze | WeightConstraint::create_no_share;
	if ((options_ & MinimizeMode_t::usc_imp_only) != 0u) { fset |= WeightConstraint::create_only_bfb; }
	ResPair       res = WeightConstraint::create(s, negLit(newAux), rep, fset);
	if (res.ok() && res.first()) {
		x.coreId = allocCore(res.first(), B, weight, rep.bound != rep.reach);
	}
	return !s.hasConflict();
}


// Computes the solver's initial root level, i.e. all assumptions that are not from us.
uint32 UncoreMinimize::initRoot(Solver& s) {
	if (eRoot_ == aTop_ && !s.hasStopConflict()) {
		eRoot_ = s.rootLevel();
		aTop_  = eRoot_;
	}
	return eRoot_;
}

// Assigns p at the solver's initial root level.
bool UncoreMinimize::fixLit(Solver& s, Literal p) {
	assert(s.decisionLevel() >= eRoot_);
	if (s.decisionLevel() > eRoot_ && (!s.isTrue(p) || s.level(p.var()) > eRoot_)) {
		// go back to root level
		s.popRootLevel(s.rootLevel() - eRoot_);
		aTop_ = s.rootLevel();
	}
	if (eRoot_ && s.topValue(p.var()) != trueValue(p)) { fix_.push_back(p); }
	return !s.hasConflict() && s.force(p, this);
}
// Fixes any remaining assumptions of the active optimization level.
bool UncoreMinimize::fixLevel(Solver& s) {
	for (LitSet::iterator it = assume_.begin(), end = assume_.end(); it != end; ++it) {
		if (getData(it->id).assume) { fixLit(s, it->lit); }
	}
	releaseLits();
	return !s.hasConflict();
}
void UncoreMinimize::releaseLits() {
	// remaining cores are no longer open - move to closed list
	for (CoreTable::iterator it = open_.begin(), end = open_.end(); it != end; ++it) {
		if (it->con) { closed_.push_back(it->con); }
	}
	open_.clear();
	litData_.clear();
	assume_.clear();
	todo_.clear();
	freeOpen_ = 0;
}

uint32 UncoreMinimize::allocCore(WeightConstraint* con, weight_t bound, weight_t weight, bool open) {
	if (!open) {
		closed_.push_back(con);
		return 0;
	}
	if (freeOpen_) { // pop next slot from free list
		assert(open_[freeOpen_-1].con == 0);
		uint32 id   = freeOpen_;
		freeOpen_   = static_cast(open_[id-1].bound);
		open_[id-1] = Core(con, bound, weight);
		return id;
	}
	open_.push_back(Core(con, bound, weight));
	return static_cast(open_.size());
}
bool UncoreMinimize::closeCore(Solver& s, LitData& x, bool sat) {
	if (uint32 coreId = x.coreId) {
		Core& core = open_[coreId-1];
		x.coreId   = 0;
		// close by moving to closed list
		if (!sat) { closed_.push_back(core.con); }
		else      { fixLit(s, core.tag()); core.con->destroy(&s, true); }
		// link slot to free list
		core      = Core(0, 0, static_cast(freeOpen_));
		freeOpen_ = coreId;
	}
	return !s.hasConflict();
}
uint32  UncoreMinimize::Core::size()       const { return con->size() - 1; }
Literal UncoreMinimize::Core::at(uint32 i) const { return con->lit(i+1, WeightConstraint::FFB_BTB); }
Literal UncoreMinimize::Core::tag()        const { return con->lit(0, WeightConstraint::FTB_BFB); }
void    UncoreMinimize::WCTemp::add(Solver& s, Literal p) {
	if      (s.topValue(p.var()) == value_free) { lits.push_back(WeightLiteral(p, 1)); }
	else if (s.isTrue(p))                       { --bound; }
}

} // end namespaces Clasp
clasp-3.2.2/libclasp/src/model_enumerators.cpp000066400000000000000000000274551304134206100214370ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
class ModelEnumerator::ModelFinder : public EnumerationConstraint {
protected:
	explicit ModelFinder() : EnumerationConstraint() {}
	bool hasModel() const { return !solution.empty(); }
	LitVec solution;
};
/////////////////////////////////////////////////////////////////////////////////////////
// strategy_record
/////////////////////////////////////////////////////////////////////////////////////////
class ModelEnumerator::RecordFinder : public ModelFinder {
public:
	explicit RecordFinder(const LitVec* d) : ModelFinder(), dom(d) { }
	ConPtr clone() { return new RecordFinder(dom); }
	void   doCommitModel(Enumerator& ctx, Solver& s);
	bool   doUpdate(Solver& s);
	const LitVec* dom;
};

bool ModelEnumerator::RecordFinder::doUpdate(Solver& s) {
	if (hasModel()) {
		ConstraintInfo e(Constraint_t::Other);
		ClauseCreator::Result ret = ClauseCreator::create(s, solution, ClauseCreator::clause_no_add, e);
		solution.clear();
		if (ret.local) { add(ret.local);}
		if (!ret.ok()) { return false;  }
	}
	return true;
}

void ModelEnumerator::RecordFinder::doCommitModel(Enumerator& en, Solver& s) {
	ModelEnumerator& ctx = static_cast(en);
	assert(solution.empty() && "Update not called!");
	solution.clear();
	if (dom && dom->empty()) {
		if (en.lastModel().num == 0) { s.sharedContext()->warn("domRec ignored: no domain atoms found!"); }
		dom = 0;
	}
	if (ctx.trivial() && !dom) {
		return;
	}
	else if (!dom && !ctx.projectionEnabled()) {
		for (uint32 x = s.decisionLevel(); x != 0; --x) {
			Literal d = s.decision(x);
			if      (!s.auxVar(d.var()))  { solution.push_back(~d); }
			else if (d != s.tagLiteral()) {
				// Todo: set of vars could be reduced to those having the aux var in their reason set.
				const LitVec& tr = s.trail();
				const uint32  end= x != s.decisionLevel() ? s.levelStart(x+1) : (uint32)tr.size();
				for (uint32 n = s.levelStart(x)+1; n != end; ++n) {
					if (!s.auxVar(tr[n].var())) { solution.push_back(~tr[n]); }
				}
			}
		}
	}
	else if (!dom) {
		for (Var i = 1, end = s.numProblemVars(); i <= end; ++i) {
			if (ctx.project(i)) {
				solution.push_back(~s.trueLit(i));
			}
		}
		solution.push_back(~s.sharedContext()->stepLiteral());
	}
	else {
		const bool project = ctx.projectionEnabled();
		for (LitVec::const_iterator it = dom->begin(), end = dom->end(); it != end; ++it) {
			if (s.isTrue(*it) && (!project || ctx.project(it->var()))) { solution.push_back(~*it); }
		}
		solution.push_back(~s.sharedContext()->stepLiteral());
	}
	if (solution.empty()) { solution.push_back(lit_false()); }
	if (s.sharedContext()->concurrency() > 1) {
		// parallel solving active - share solution nogood with other solvers
		en.commitClause(solution);
		solution.clear();
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// strategy_backtrack
/////////////////////////////////////////////////////////////////////////////////////////
class ModelEnumerator::BacktrackFinder : public ModelFinder {
public:
	explicit BacktrackFinder(uint32 projOpts) : ModelFinder(), opts(projOpts) {}
	// EnumerationConstraint interface
	ConPtr clone() { return new BacktrackFinder(opts); }
	void   doCommitModel(Enumerator& ctx, Solver& s);
	bool   doUpdate(Solver& s);
	// Constraint interface
	PropResult  propagate(Solver&, Literal, uint32&);
	void        reason(Solver& s, Literal p, LitVec& x){
		for (uint32 i = 1, end = s.level(p.var()); i <= end; ++i) {
			x.push_back(s.decision(i));
		}
	}
	bool simplify(Solver& s, bool reinit) {
		for (ProjectDB::iterator it = projNogoods.begin(), end = projNogoods.end(); it != end; ++it) {
			if (it->second && it->second->simplify(s, false)) {
				s.removeWatch(it->first, this);
				it->second->destroy(&s, false);
				it->second = 0;
			}
		}
		while (!projNogoods.empty() && projNogoods.back().second == 0) { projNogoods.pop_back(); }
		return ModelFinder::simplify(s, reinit);
	}
	void destroy(Solver* s, bool detach) {
		while (!projNogoods.empty()) {
			NogoodPair x = projNogoods.back();
			if (x.second) {
				if (s) { s->removeWatch(x.first, this); }
				x.second->destroy(s, detach);
			}
			projNogoods.pop_back();
		}
		ModelFinder::destroy(s, detach);
	}
	typedef std::pair NogoodPair;
	typedef PodVector::type     ProjectDB;
	ProjectDB projNogoods;
	uint32    opts;
};

Constraint::PropResult ModelEnumerator::BacktrackFinder::propagate(Solver& s, Literal, uint32& pos) {
	assert(pos < projNogoods.size() && projNogoods[pos].second != 0);
	ClauseHead* c = static_cast(projNogoods[pos].second);
	if (!c->locked(s)) {
		c->destroy(&s, true);
		projNogoods[pos].second = (c = 0);
		while (!projNogoods.empty() && !projNogoods.back().second) {
			projNogoods.pop_back();
		}
	}
	return PropResult(true, c != 0);
}
bool ModelEnumerator::BacktrackFinder::doUpdate(Solver& s) {
	if (hasModel()) {
		bool   ok = true;
		uint32 sp = (opts & ModelEnumerator::project_save_progress) != 0 ? Solver::undo_save_phases : 0;
		s.undoUntil(s.backtrackLevel(), sp|Solver::undo_pop_bt_level);
		ClauseRep rep = ClauseCreator::prepare(s, solution, 0, Constraint_t::Conflict);
		if (rep.size == 0 || s.isFalse(rep.lits[0])) { // The decision stack is already ordered.
			ok = s.backtrack();
		}
		else if (rep.size == 1 || s.isFalse(rep.lits[1])) { // The projection nogood is unit. Force the single remaining literal from the current DL.
			ok = s.force(rep.lits[0], this);
		}
		else if (!s.isTrue(rep.lits[0])) { // Shorten the projection nogood by assuming one of its literals to false.
			uint32  f = static_cast(std::stable_partition(rep.lits+2, rep.lits+rep.size, std::not1(std::bind1st(std::mem_fun(&Solver::isFalse), &s))) - rep.lits);
			Literal x = (opts & ModelEnumerator::project_use_heuristic) != 0 ? s.heuristic()->selectRange(s, rep.lits, rep.lits+f) : rep.lits[0];
			Constraint* c = Clause::newContractedClause(s, rep, f, true);
			CLASP_FAIL_IF(!c, "Invalid constraint!");
			s.assume(~x);
			// Remember that we must backtrack the current decision
			// level in order to guarantee a different projected solution.
			s.setBacktrackLevel(s.decisionLevel(), Solver::undo_pop_proj_level);
			// Attach nogood to the current decision literal.
			// Once we backtrack to x, the then obsolete nogood is destroyed
			// keeping the number of projection nogoods linear in the number of (projection) atoms.
			s.addWatch(x, this, (uint32)projNogoods.size());
			projNogoods.push_back(NogoodPair(x, c));
			ok = true;
		}
		solution.clear();
		return ok;
	}
	if (optimize() || s.sharedContext()->concurrency() == 1 || disjointPath()) {
		return true;
	}
	s.setStopConflict();
	return false;
}

void ModelEnumerator::BacktrackFinder::doCommitModel(Enumerator& ctx, Solver& s) {
	ModelEnumerator& en = static_cast(ctx);
	uint32           dl = s.decisionLevel();
	solution.assign(1, dl ? ~s.decision(dl) : lit_false());
	if (en.projectionEnabled()) {
		// Remember the current projected assignment as a nogood.
		solution.clear();
		for (Var i = 1, end = s.numProblemVars(); i <= end; ++i) {
			if (en.project(i)) {
				solution.push_back(~s.trueLit(i));
			}
		}
		// Tag solution
		solution.push_back(~s.sharedContext()->stepLiteral());
		// Remember initial decisions that are projection vars.
		for (dl = s.rootLevel(); dl < s.decisionLevel(); ++dl) {
			if (!en.project(s.decision(dl+1).var())) { break; }
		}
		s.setBacktrackLevel(dl, Solver::undo_pop_proj_level);
	}
	else {
		s.setBacktrackLevel(dl);
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// class ModelEnumerator
/////////////////////////////////////////////////////////////////////////////////////////
ModelEnumerator::ModelEnumerator(Strategy st)
	: Enumerator()
	, options_(st) {
}

Enumerator* EnumOptions::createModelEnumerator(const EnumOptions& opts) {
	ModelEnumerator*          e = new ModelEnumerator();
	ModelEnumerator::Strategy s = ModelEnumerator::strategy_auto;
	if (opts.enumMode && opts.models()) {
		s = opts.enumMode == enum_bt ? ModelEnumerator::strategy_backtrack : ModelEnumerator::strategy_record;
	}
	e->setStrategy(s, opts.project | (opts.enumMode == enum_dom_record ? ModelEnumerator::project_dom_lits : 0));
	return e;
}

ModelEnumerator::~ModelEnumerator() {}

void ModelEnumerator::setStrategy(Strategy st, uint32 projection, char f) {
	options_ = (static_cast(f) << 24) | uint32(st) | ((projection & 15u) << 4u);
	if ((projection & 7u) != 0) {
		options_ |= uint32(project_enable_simple) << 4u;
	}
	if (st == strategy_auto) {
		options_ |= detect_strategy_flag;
	}
}

EnumerationConstraint* ModelEnumerator::doInit(SharedContext& ctx, SharedMinimizeData* opt, int numModels) {
	initProjection(ctx);
	uint32 st = strategy();
	if (detectStrategy() || (ctx.concurrency() > 1 && !ModelEnumerator::supportsParallel())) {
		st = 0;
	}
	bool optOne  = opt && opt->mode() == MinimizeMode_t::optimize;
	bool trivial = optOne || std::abs(numModels) == 1;
	if (optOne && projectionEnabled()) {
		for (const WeightLiteral* it =  minimizer()->lits; !isSentinel(it->first) && trivial; ++it) {
			trivial = project(it->first.var());
		}
		if (!trivial) { ctx.warn("Projection: Optimization may depend on enumeration order."); }
	}
	if (st == strategy_auto) { st  = trivial || (projectionEnabled() && ctx.concurrency() > 1) ? strategy_record : strategy_backtrack; }
	if (trivial)             { st |= trivial_flag; }
	options_ &= ~uint32(strategy_opts_mask);
	options_ |= st;
	const LitVec* dom = (projectOpts() & project_dom_lits) != 0 ? (ctx.heuristic.domRec = &domRec_) : 0;
	EnumerationConstraint* c = st == strategy_backtrack
	  ? static_cast(new BacktrackFinder(projectOpts()))
	  : static_cast(new RecordFinder(dom));
	if (projectionEnabled()) { setIgnoreSymmetric(true); }
	return c;
}

void ModelEnumerator::initProjection(SharedContext& ctx) {
	project_.clear();
	if (!projectionEnabled()) { return; }
	const OutputTable& out = ctx.output;
	char const filter = static_cast(options_ >> 24);
	if (out.projectMode() == OutputTable::project_output) {
		// Mark all relevant output variables.
		for (OutputTable::pred_iterator it = out.pred_begin(), end = out.pred_end(); it != end; ++it) {
			if (*it->name != filter) { addProject(ctx, it->cond.var()); }
		}
		for (OutputTable::range_iterator it = out.vars_begin(), end = out.vars_end(); it != end; ++it) {
			addProject(ctx, *it);
		}
	}
	else {
		// Mark explicitly requested variables only.
		for (OutputTable::lit_iterator it = out.proj_begin(), end = out.proj_end(); it != end; ++it) {
			addProject(ctx, it->var());
		}
	}
	domRec_.clear();
}

void ModelEnumerator::addProject(SharedContext& ctx, Var v) {
	const uint32 wIdx = v / 32;
	const uint32 bIdx = v & 31;
	if (wIdx >= project_.size()) { project_.resize(wIdx + 1, 0); }
	store_set_bit(project_[wIdx], bIdx);
	ctx.setFrozen(v, true);
}
bool ModelEnumerator::project(Var v) const {
	const uint32 wIdx = v / 32;
	const uint32 bIdx = v & 31;
	return wIdx < project_.size() && test_bit(project_[wIdx], bIdx);
}

}
clasp-3.2.2/libclasp/src/parallel_solve.cpp000066400000000000000000001205351304134206100207100ustar00rootroot00000000000000//
// Copyright (c) 2010-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#if WITH_THREADS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp { namespace mt {
/////////////////////////////////////////////////////////////////////////////////////////
// BarrierSemaphore
/////////////////////////////////////////////////////////////////////////////////////////
// A combination of a barrier and a semaphore
class BarrierSemaphore {
public:
	explicit BarrierSemaphore(int counter = 0, int maxParties = 1) : counter_(counter), active_(maxParties) {}
	// Initializes this object
	// PRE: no thread is blocked on the semaphore
	//      (i.e. internal counter is >= 0)
	// NOTE: not thread-safe
	void unsafe_init(int counter = 0, int maxParties = 1) {
		counter_ = counter;
		active_  = maxParties;
	}
	// Returns the current semaphore counter.
	int  counter()   { lock_guard lock(semMutex_); return counter_; }
	// Returns the number of parties required to trip this barrier.
	int  parties()   { lock_guard lock(semMutex_); return active_;  }
	// Returns true if all parties are waiting at the barrier
	bool active()    { lock_guard lock(semMutex_); return unsafe_active(); }

	// barrier interface

	// Increases the barrier count, i.e. the number of
	// parties required to trip this barrier.
	void addParty() {
		lock_guard lock(semMutex_);
		++active_;
	}
	// Decreases the barrier count and resets the barrier
	// if reset is true.
	// PRE: the thread does not itself wait on the barrier
	int removeParty(bool reset) {
		unique_lock lock(semMutex_);
		assert(active_ > 0);
		int res = active_--;
		if      (reset)           { unsafe_reset(0); }
		else if (unsafe_active()) { counter_ = -active_; lock.unlock(); semCond_.notify_one(); }
		return res;
	}
	// Waits until all parties have arrived, i.e. called wait.
	// Exactly one of the parties will receive a return value of true,
	// the others will receive a value of false.
	// Applications shall use this value to designate one thread as the
	// leader that will eventually reset the barrier thereby unblocking the other threads.
	bool wait() {
		unique_lock lock(semMutex_);
		if (--counter_ >= 0) { counter_ = -1; }
		return unsafe_wait(lock);
	}
	// Resets the barrier and unblocks any waiting threads.
	void reset(uint32 semCount = 0) {
		lock_guard lock(semMutex_);
		unsafe_reset(semCount);
	}
	// semaphore interface

	// Decrement the semaphore's counter.
	// If the counter is zero or less prior to the call
	// the calling thread is suspended.
	// Returns false to signal that all but the calling thread
	// are currently blocked.
	bool down() {
		unique_lock lock(semMutex_);
		return down(lock);
	}
	// LOW-LEVEL version of down
	bool down(unique_lock& m) {
		assert(m.owns_lock());
		if (--counter_ >= 0) { return true; }
		return !unsafe_wait(m);
	}
	// Increments the semaphore's counter and resumes
	// one thread which has called down() if the counter
	// was less than zero prior to the call.
	void up() {
		unique_lock lock(semMutex_);
		up(lock);
	}
	// LOW-LEVEL version of up
	void up(unique_lock& m, bool transferLock = true) {
		assert(m.owns_lock());
		if (++counter_ < 1) {
			if (transferLock) { m.unlock(); }
			semCond_.notify_one();
		}
	}
	mutex& toMutex() { return semMutex_; }
private:
	BarrierSemaphore(const BarrierSemaphore&);
	BarrierSemaphore& operator=(const BarrierSemaphore&);
	typedef condition_variable cv;
	bool    unsafe_active() const { return -counter_ >= active_; }
	void    unsafe_reset(uint32 semCount) {
		int prev = counter_;
		counter_ = semCount;
		if (prev < 0) { semCond_.notify_all(); }
	}
	// Returns true for the leader, else false
	bool    unsafe_wait(unique_lock& lock) {
		assert(counter_ < 0);
		// don't put the last thread to sleep!
		if (!unsafe_active()) {
			semCond_.wait(lock);
		}
		return unsafe_active();
	}
	cv    semCond_;  // waiting threads
	mutex semMutex_; // mutex for updating counter
	int   counter_;  // semaphore's counter
	int   active_;   // number of active threads
};
/////////////////////////////////////////////////////////////////////////////////////////
// ParallelSolve::Impl
/////////////////////////////////////////////////////////////////////////////////////////
struct ParallelSolve::SharedData {
	typedef PodQueue Queue;
	enum MsgFlag {
		terminate_flag        = 1u, sync_flag  = 2u,  split_flag    = 4u,
		restart_flag          = 8u, complete_flag = 16u,
		interrupt_flag        = 32u, // set on terminate from outside
		allow_split_flag      = 64u, // set if splitting mode is active
		forbid_restart_flag   = 128u,// set if restarts are no longer allowed
		cancel_restart_flag   = 256u,// set if current restart request was cancelled by some thread
		restart_abandoned_flag= 512u,// set to signal that threads must not give up their gp
	};
	enum Message {
		msg_terminate      = (terminate_flag),
		msg_interrupt      = (terminate_flag | interrupt_flag),
		msg_sync_restart   = (sync_flag | restart_flag),
		msg_split          = split_flag
	};
	struct Generator {
		enum State { start = 0, search = 1, model = 2, done = 3 };
		Generator() : state(start) {}
		mutex genM;
		condition_variable cond;
		State waitWhile(State st) {
			State r;
			for (unique_lock lock(genM); (r = state) == st;) { cond.wait(lock); }
			return r;
		}
		void pushModel() {
			notify(model);
			waitWhile(model);
		}
		void notify(State st) {
			unique_lock lock(genM);
			state = st;
			cond.notify_one();
		}
		State state;
	};
	SharedData() : path(0) { reset(0); control = 0; }
	void reset(SharedContext* a_ctx) {
		clearQueue();
		syncT.reset();
		workSem.unsafe_init(0, a_ctx ? a_ctx->concurrency() : 0);
		globalR.reset();
		maxConflict = globalR.current();
		error       = 0;
		initVec     = 0;
		ctx         = a_ctx;
		path        = 0;
		nextId      = 1;
		workReq     = 0;
		restartReq  = 0;
		generator   = 0;
	}
	void clearQueue() {
		while (!workQ.empty()) { delete workQ.pop_ret(); }
		workQ.clear();
	}
	const LitVec* requestWork(const Solver& s) {
		const uint64 m(uint64(1) << s.id());
		if ((initVec & m) == m) {
			if (!allowSplit()) {
				// portfolio mode - all solvers can start with initial path
				initVec -= m;
				return path;
			}
			else if (initVec.fetch_and_store(0) != 0) {
				// splitting mode - only one solver must start with initial path
				return path;
			}
		}
		if (!allowSplit()) { return 0; }
		// try to get work from split
		ctx->report(MessageEvent(s, "SPLIT", MessageEvent::sent));
		const uint32 flags = uint32(terminate_flag) | uint32(sync_flag);
		for (unique_lock lock(workSem.toMutex());;) {
			if (!workQ.empty()) {
				const LitVec* res = workQ.pop_ret();
				if (workQ.empty()) { workQ.clear(); }
				return res;
			}
			postMessage(SharedData::msg_split, false);
			if (!workSem.down(lock) || hasControl(flags)) {
				return 0;
			}
		}
	}
	void pushWork(const LitVec* v) {
		unique_lock lock(workSem.toMutex());
		workQ.push(v);
		workSem.up(lock);
	}
	// MESSAGES
	bool postMessage(Message m, bool notify);
	bool hasMessage()  const { return (control & uint32(7)) != 0; }
	bool synchronize() const { return (control & uint32(sync_flag))      != 0; }
	bool terminate()   const { return (control & uint32(terminate_flag)) != 0; }
	bool split()       const { return (control & uint32(split_flag))     != 0; }
	void aboutToSplit()      { if (--workReq == 0) updateSplitFlag();  }
	void updateSplitFlag();
	// CONTROL FLAGS
	bool hasControl(uint32 f) const { return (control & f) != 0;        }
	bool interrupt()          const { return hasControl(interrupt_flag);}
	bool complete()           const { return hasControl(complete_flag); }
	bool restart()            const { return hasControl(restart_flag);  }
	bool allowSplit()         const { return hasControl(allow_split_flag); }
	bool allowRestart()       const { return !hasControl(forbid_restart_flag); }
	bool setControl(uint32 flags)   { return (control.fetch_and_or(flags) & flags) != flags; }
	bool clearControl(uint32 flags) { return (control.fetch_and_and(~flags) & flags) == flags; }
	typedef SingleOwnerPtr GeneratorPtr;
	ScheduleStrategy globalR;     // global restart strategy
	uint64           maxConflict; // current restart limit
	uint64           error;       // bitmask of erroneous solvers
	SharedContext*   ctx;         // shared context object
	const LitVec*    path;        // initial guiding path - typically empty
	atomic   initVec;     // vector of initial gp - represented as bitset
	GeneratorPtr     generator;   // optional data for model generation
	Timer  syncT;       // thread sync time
	mutex            modelM;      // model-mutex
	BarrierSemaphore workSem;     // work-semaphore
	Queue            workQ;       // work-queue (must be protected by workSem)
	uint32           nextId;      // next solver id to use
	LowerBound       lower_;      // last reported lower bound (if any)
	atomic      workReq;     // > 0: someone needs work
	atomic   restartReq;  // == numThreads(): restart
	atomic   control;     // set of active message flags
	atomic   modCount;    // coounter for synchronizing models
};

// post message to all threads
bool ParallelSolve::SharedData::postMessage(Message m, bool notifyWaiting) {
	if (m == msg_split) {
		if (++workReq == 1) { updateSplitFlag(); }
		return true;
	}
	else if (setControl(m)) {
		// control message - notify all if requested
		if (notifyWaiting) workSem.reset();
		if ((uint32(m) & uint32(sync_flag|terminate_flag)) != 0) {
			syncT.reset();
			syncT.start();
		}
		return true;
	}
	return false;
}

void ParallelSolve::SharedData::updateSplitFlag() {
	for (bool splitF;;) {
		splitF = (workReq > 0);
		if (split() == splitF) return;
		if (splitF) control.fetch_and_or(uint32(split_flag));
		else        control.fetch_and_and(~uint32(split_flag));
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// ParallelSolve
/////////////////////////////////////////////////////////////////////////////////////////
ParallelSolve::ParallelSolve(const ParallelSolveOptions& opts)
	: SolveAlgorithm(opts.limit)
	, shared_(new SharedData)
	, thread_(0)
	, distribution_(opts.distribute)
	, maxRestarts_(0)
	, intGrace_(1024)
	, intTopo_(opts.integrate.topo)
	, intFlags_(ClauseCreator::clause_not_root_sat | ClauseCreator::clause_no_add)
	, modeSplit_(opts.algorithm.mode == ParallelSolveOptions::Algorithm::mode_split) {
	setRestarts(opts.restarts.maxR, opts.restarts.sched);
	setIntegrate(opts.integrate.grace, opts.integrate.filter);
}

ParallelSolve::~ParallelSolve() {
	if (shared_->nextId > 1) {
		// algorithm was not started but there may be active threads -
		// force orderly shutdown
		ParallelSolve::doInterrupt();
		shared_->workSem.removeParty(true);
		joinThreads();
	}
	destroyThread(masterId);
	delete shared_;
}

bool ParallelSolve::beginSolve(SharedContext& ctx, const LitVec& path) {
	assert(ctx.concurrency() && "Illegal number of threads");
	if (shared_->terminate()) { return false; }
	shared_->reset(&ctx);
	if (!enumerator().supportsParallel() && numThreads() > 1) {
		ctx.warn("Selected reasoning mode implies #Threads=1.");
		shared_->workSem.unsafe_init(1);
		modeSplit_ = false;
		ctx.setConcurrency(1, SharedContext::resize_reserve);
	}
	shared_->setControl(modeSplit_ ? SharedData::allow_split_flag : SharedData::forbid_restart_flag);
	shared_->modCount = uint32(enumerator().optimize());
	shared_->path = &path;
	if (distribution_.types != 0 && ctx.distributor.get() == 0 && numThreads() > 1) {
		if (distribution_.mode == ParallelSolveOptions::Distribution::mode_local) {
			ctx.distributor.reset(new mt::LocalDistribution(distribution_, ctx.concurrency(), intTopo_));
		}
		else {
			ctx.distributor.reset(new mt::GlobalDistribution(distribution_, ctx.concurrency(), intTopo_));
		}
	}
	shared_->setControl(SharedData::sync_flag); // force initial sync with all threads
	shared_->syncT.start();
	reportProgress(MessageEvent(*ctx.master(), "SYNC", MessageEvent::sent));
	assert(ctx.master()->id() == masterId);
	allocThread(masterId, *ctx.master(), ctx.configuration()->search(masterId));
	for (uint32 i = 1; i != ctx.concurrency(); ++i) {
		uint32 id = shared_->nextId++;
		allocThread(id, *ctx.solver(id), ctx.configuration()->search(id));
		// start in new thread
		Clasp::mt::thread x(std::mem_fun(&ParallelSolve::solveParallel), this, id);
		thread_[id]->setThread(x);
	}
	return true;
}

void ParallelSolve::setIntegrate(uint32 grace, uint8 filter) {
	typedef ParallelSolveOptions::Integration Dist;
	intGrace_ = grace;
	intFlags_ = ClauseCreator::clause_no_add;
	if (filter == Dist::filter_heuristic) { store_set_bit(intFlags_, 31); }
	if (filter != Dist::filter_no)        { intFlags_ |= ClauseCreator::clause_not_root_sat; }
	if (filter == Dist::filter_sat)       { intFlags_ |= ClauseCreator::clause_not_sat; }
}

void ParallelSolve::setRestarts(uint32 maxR, const ScheduleStrategy& rs) {
	maxRestarts_         = maxR;
	shared_->globalR     = maxR ? rs : ScheduleStrategy::none();
	shared_->maxConflict = shared_->globalR.current();
}

uint32 ParallelSolve::numThreads() const { return shared_->workSem.parties(); }

void ParallelSolve::allocThread(uint32 id, Solver& s, const SolveParams& p) {
	if (!thread_) {
		uint32 n = numThreads();
		thread_  = new ParallelHandler*[n];
		std::fill(thread_, thread_+n, static_cast(0));
	}
	size_t sz   = ((sizeof(ParallelHandler)+63) / 64) * 64;
	thread_[id] = new (alignedAlloc(sz, 64)) ParallelHandler(*this, s, p);
}

void ParallelSolve::destroyThread(uint32 id) {
	if (thread_ && thread_[id]) {
		assert(!thread_[id]->joinable() && "Shutdown not completed!");
		thread_[id]->~ParallelHandler();
		alignedFree(thread_[id]);
		thread_[id] = 0;
		if (id == masterId) {
			delete [] thread_;
			thread_ = 0;
		}
	}
}

inline void ParallelSolve::reportProgress(const Event& ev) const {
	return shared_->ctx->report(ev);
}
inline void ParallelSolve::reportProgress(const Solver& s, const char* msg) const {
	return shared_->ctx->report(msg, &s);
}

// joins with and destroys all active threads
void ParallelSolve::joinThreads() {
	int    ec     = thread_[masterId]->error();
	uint32 winner = thread_[masterId]->winner() ? uint32(masterId) : UINT32_MAX;
	shared_->error= ec ? 1 : 0;
	for (uint32 i = 1, end = shared_->nextId; i != end; ++i) {
		if (thread_[i]->join() != 0) {
			shared_->error |= uint64(1) << i;
			ec = std::max(ec, thread_[i]->error());
		}
		if (thread_[i]->winner() && i < winner) {
			winner = i;
		}
		Solver* s = &thread_[i]->solver();
		reportProgress(*s, "joined");
		destroyThread(i);
		reportProgress(*s, "destroyed");
	}
	if (shared_->complete()) {
		enumerator().commitComplete();
	}
	// detach master only after all client threads are done
	thread_[masterId]->detach(*shared_->ctx, shared_->interrupt());
	thread_[masterId]->setError(!shared_->interrupt() ? thread_[masterId]->error() : ec);
	shared_->ctx->setWinner(winner);
	shared_->nextId = 1;
	shared_->syncT.stop();
	reportProgress(MessageEvent(*shared_->ctx->master(), "TERMINATE", MessageEvent::completed, shared_->syncT.total()));
}

void ParallelSolve::doStart(SharedContext& ctx, const LitVec& assume) {
	if (beginSolve(ctx, assume)) {
		// start computation in new thread
		shared_->generator = new SharedData::Generator();
		Clasp::mt::thread x(std::mem_fun(&ParallelSolve::solveParallel), this, static_cast(masterId));
		thread_[masterId]->setThread(x);
	}
}
int ParallelSolve::doNext(int) {
	CLASP_FAIL_IF(!shared_->generator.get(), "Invalid operation");
	int s = shared_->generator->state;
	if (s != SharedData::Generator::done) {
		shared_->generator->notify(SharedData::Generator::search);
		if ((s = shared_->generator->waitWhile(SharedData::Generator::search)) == SharedData::Generator::model) {
			return value_true;
		}
	}
	return shared_->complete() ? value_false : value_free;
}
void ParallelSolve::doStop() {
	if (shared_->nextId <= 1) { return; }
	reportProgress(*shared_->ctx->master(), "joining with other threads");
	if (shared_->generator.get()) {
		shared_->setControl(SharedData::terminate_flag);
		shared_->generator->notify(SharedData::Generator::done);
		thread_[masterId]->join();
	}
	joinThreads();
	int err = thread_[masterId]->error();
	destroyThread(masterId);
	shared_->generator = 0;
	shared_->ctx->distributor.reset(0);
	switch(err) {
		case error_none   : break;
		case error_oom    : throw std::bad_alloc();
		case error_runtime: throw std::runtime_error("RUNTIME ERROR!");
		default:            throw std::runtime_error("UNKNOWN ERROR!");
	}
}

// Entry point for master solver
bool ParallelSolve::doSolve(SharedContext& ctx, const LitVec& path) {
	if (beginSolve(ctx, path)) {
		solveParallel(masterId);
		ParallelSolve::doStop();
	}
	return !shared_->complete();
}

// main solve loop executed by all threads
void ParallelSolve::solveParallel(uint32 id) {
	Solver& s           = thread_[id]->solver();
	const SolveParams& p= thread_[id]->params();
	SolverStats agg;
	PathPtr a(0);
	if (id == masterId && shared_->generator.get()) {
		shared_->generator->waitWhile(SharedData::Generator::start);
	}
	try {
		// establish solver<->handler connection and attach to shared context
		// should this fail because of an initial conflict, we'll terminate
		// in requestWork.
		thread_[id]->attach(*shared_->ctx);
		BasicSolve solve(s, p, limits());
		agg.enable(s.stats);
		for (GpType t; requestWork(s, a); solve.reset()) {
			agg.accu(s.stats);
			s.stats.reset();
			thread_[id]->setGpType(t = ((a.is_owner() || modeSplit_) ? gp_split : gp_fixed));
			if (enumerator().start(s, *a, a.is_owner()) && thread_[id]->solveGP(solve, t, shared_->maxConflict) == value_free) {
				terminate(s, false);
			}
			s.clearStopConflict();
			s.undoUntil(0);
			enumerator().end(s);
		}
	}
	catch (const std::bad_alloc&)  { exception(id,a,error_oom, "ERROR: std::bad_alloc" ); }
	catch (const std::exception& e){ exception(id,a,error_runtime, e.what()); }
	catch (...)                    { exception(id,a,error_other, "ERROR: unknown");  }
	assert(shared_->terminate() || thread_[id]->error() != error_none);
	// this thread is leaving
	int active = shared_->workSem.removeParty(shared_->terminate());
	// update stats
	s.stats.accu(agg);
	if (id != masterId) {
		// remove solver<->handler connection and detach from shared context
		// note: since detach can change the problem, we must not yet detach the master
		// because some client might still be in the middle of an attach operation
		thread_[id]->detach(*shared_->ctx, shared_->interrupt());
		s.stats.addCpuTime(ThreadTime::getTime());
	}
	if (active == 1 && shared_->generator.get()) {
		shared_->generator->notify(SharedData::Generator::done);
	}
}

void ParallelSolve::exception(uint32 id, PathPtr& path, ErrorCode e, const char* what) {
	try {
		reportProgress(thread_[id]->solver(), what);
		thread_[id]->setError(e);
		if (id == masterId || shared_->workSem.active()) {
			ParallelSolve::doInterrupt();
			return;
		}
		else if (path.get() && shared_->allowSplit()) {
			shared_->workQ.push(path.release());
			shared_->workSem.up();
		}
		reportProgress(thread_[id]->solver(), "Thread failed and was removed.");
	}
	catch(...) { ParallelSolve::doInterrupt(); }
}

// forced termination from outside
bool ParallelSolve::doInterrupt() {
	// do not notify blocked threads to avoid possible
	// deadlock in semaphore!
	shared_->postMessage(SharedData::msg_interrupt, false);
	return true;
}

// tries to get new work for the given solver
bool ParallelSolve::requestWork(Solver& s, PathPtr& out) {
	const LitVec* a = 0;
	for (int popped = 0; !shared_->terminate();) {
		// only clear path and stop conflict - we don't propagate() here
		// because we would then have to handle any eventual conflicts
		if (++popped == 1 && !s.popRootLevel(s.rootLevel())) {
			// s has a real top-level conflict - problem is unsat
			terminate(s, true);
		}
		else if (shared_->synchronize()) {
			// a synchronize request is active - we are fine with
			// this but did not yet had a chance to react on it
			waitOnSync(s);
		}
		else if (a || (a = shared_->requestWork(s)) != 0) {
			assert(s.decisionLevel() == 0);
			// got new work from work-queue
			out = a;
			// do not take over ownership of initial gp!
			if (a == shared_->path) { out.release(); }
			// propagate any new facts before starting new work
			if (s.simplify())       { return true; }
			// s now has a conflict - either an artifical stop conflict
			// or a real conflict - we'll handle it in the next iteration
			// via the call to popRootLevel()
			popped = 0;
		}
		else if (!shared_->allowSplit() || !shared_->synchronize()) {
			// no work left - quitting time?
			terminate(s, true);
		}
	}
	return false;
}

// terminated from inside of algorithm
// check if there is more to do
void ParallelSolve::terminate(Solver& s, bool complete) {
	if (!shared_->terminate()) {
		if (enumerator().tentative() && complete) {
			if (shared_->setControl(SharedData::sync_flag|SharedData::complete_flag)) {
				thread_[s.id()]->setWinner();
				reportProgress(MessageEvent(s, "SYNC", MessageEvent::sent));
			}
		}
		else {
			reportProgress(MessageEvent(s, "TERMINATE", MessageEvent::sent));
			shared_->postMessage(SharedData::msg_terminate, true);
			thread_[s.id()]->setWinner();
			if (complete) { shared_->setControl(SharedData::complete_flag); }
		}
	}
}

// handles an active synchronization request
// returns true to signal that s should restart otherwise false
bool ParallelSolve::waitOnSync(Solver& s) {
	if (!thread_[s.id()]->handleRestartMessage()) {
		shared_->setControl(SharedData::cancel_restart_flag);
	}
	bool hasPath  = thread_[s.id()]->hasPath();
	bool tentative= enumerator().tentative();
	if (shared_->workSem.wait()) {
		// last man standing - complete synchronization request
		shared_->workReq     = 0;
		shared_->restartReq  = 0;
		bool restart         = shared_->hasControl(SharedData::restart_flag);
		bool init            = true;
		if (restart) {
			init = shared_->allowRestart() && !shared_->hasControl(SharedData::cancel_restart_flag);
			if (init) { shared_->globalR.next(); }
			shared_->maxConflict = shared_->allowRestart() && shared_->globalR.idx < maxRestarts_
				? shared_->globalR.current()
				: UINT64_MAX;
		}
		else if (shared_->maxConflict != UINT64_MAX && !shared_->allowRestart()) {
			shared_->maxConflict = UINT64_MAX;
		}
		if (init) { initQueue();  }
		else      { shared_->setControl(SharedData::restart_abandoned_flag); }
		if (tentative && shared_->complete()) {
			if (enumerator().commitComplete()) { shared_->setControl(SharedData::terminate_flag); }
			else                               { shared_->modCount = uint32(0); shared_->clearControl(SharedData::complete_flag); }
		}
		shared_->clearControl(SharedData::msg_split | SharedData::msg_sync_restart | SharedData::restart_abandoned_flag | SharedData::cancel_restart_flag);
		shared_->syncT.lap();
		reportProgress(MessageEvent(s, "SYNC", MessageEvent::completed, shared_->syncT.elapsed()));
		// wake up all blocked threads
		shared_->workSem.reset();
	}
	return shared_->terminate() || (hasPath && !shared_->hasControl(SharedData::restart_abandoned_flag));
}

// If guiding path scheme is active only one
// thread can start with gp (typically empty) and this
// thread must then split up search-space dynamically.
// Otherwise, all threads can start with initial gp
// TODO:
//  heuristic for initial splits?
void ParallelSolve::initQueue() {
	shared_->clearQueue();
	if (shared_->allowSplit() && modeSplit_ && !enumerator().supportsSplitting(*shared_->ctx)) {
		shared_->ctx->warn("Selected strategies imply Mode=compete.");
		shared_->clearControl(SharedData::allow_split_flag);
		shared_->setControl(SharedData::forbid_restart_flag);
		modeSplit_ = false;
	}
	shared_->initVec = UINT64_MAX;
	assert(shared_->allowSplit() || shared_->hasControl(SharedData::forbid_restart_flag));
}

// adds work to the work-queue
void ParallelSolve::pushWork(LitVec* v) {
	assert(v);
	shared_->pushWork(v);
}

// called whenever some solver proved unsat
bool ParallelSolve::commitUnsat(Solver& s) {
	const int supUnsat = enumerator().unsatType();
	if (supUnsat == Enumerator::unsat_stop || shared_->terminate() || shared_->synchronize()) {
		return false;
	}
	unique_lock lock(shared_->modelM, defer_lock_t());
	if (supUnsat == Enumerator::unsat_sync) {
		lock.lock();
	}
	bool result = enumerator().commitUnsat(s);
	if (lock.owns_lock()) {
		lock.unlock();
	}
	if (!thread_[s.id()]->disjointPath()) {
		if (result) {
			++shared_->modCount;
			if (s.lower.bound > 0) {
				lock.lock();
				if (s.lower.bound > shared_->lower_.bound || s.lower.level > shared_->lower_.level) {
					shared_->lower_ = s.lower;
					reportUnsat(s);
				}
				lock.unlock();
			}
		}
		else { terminate(s, true);  }
	}
	return result;
}

// called whenever some solver has found a model
bool ParallelSolve::commitModel(Solver& s) {
	// grab lock - models must be processed sequentially
	// in order to simplify printing and to avoid duplicates
	// in all non-trivial enumeration modes
	bool stop = false;
	{lock_guard lock(shared_->modelM);
	// first check if the model is still valid once all
	// information is integrated into the solver
	if (thread_[s.id()]->isModel(s) && (stop=shared_->terminate()) == false && enumerator().commitModel(s)) {
		if (enumerator().lastModel().num == 1 && !enumerator().supportsRestarts()) {
			// switch to backtracking based splitting algorithm
			// the solver's gp will act as the root for splitting and is
			// from now on disjoint from all other gps
			shared_->setControl(SharedData::forbid_restart_flag | SharedData::allow_split_flag);
			thread_[s.id()]->setGpType(gp_split);
			enumerator().setDisjoint(s, true);
		}
		++shared_->modCount;
		if (shared_->generator.get()) {
			shared_->generator->pushModel();
		}
		else if ((stop = !reportModel(s)) == true) {
			// must be called while holding the lock - otherwise
			// we have a race condition with solvers that
			// are currently blocking on the mutex and we could enumerate
			// more models than requested by the user
			terminate(s, !moreModels(s));
		}
	}}
	return !stop;
}

uint64 ParallelSolve::hasErrors() const {
	return shared_->error;
}
bool ParallelSolve::interrupted() const {
	return shared_->interrupt();
}
void ParallelSolve::resetSolve() {
	shared_->control = 0;
}
void ParallelSolve::enableInterrupts() {}
// updates s with new messages and uses s to create a new guiding path
// if necessary and possible
bool ParallelSolve::handleMessages(Solver& s) {
	// check if there are new messages for s
	if (!shared_->hasMessage()) {
		// nothing to do
		return true;
	}
	ParallelHandler* h = thread_[s.id()];
	if (shared_->terminate()) {
		reportProgress(MessageEvent(s, "TERMINATE", MessageEvent::received));
		h->handleTerminateMessage();
		s.setStopConflict();
		return false;
	}
	if (shared_->synchronize()) {
		reportProgress(MessageEvent(s, "SYNC", MessageEvent::received));
		if (waitOnSync(s)) {
			s.setStopConflict();
			return false;
		}
		return true;
	}
	if (h->disjointPath() && s.splittable() && shared_->workReq > 0) {
		// First declare split request as handled
		// and only then do the actual split.
		// This way, we minimize the chance for
		// "over"-splitting, i.e. one split request handled
		// by more than one thread.
		shared_->aboutToSplit();
		reportProgress(MessageEvent(s, "SPLIT", MessageEvent::received));
		h->handleSplitMessage();
		enumerator().setDisjoint(s, true);
	}
	return true;
}

bool ParallelSolve::integrateModels(Solver& s, uint32& upCount) {
	uint32 gCount = shared_->modCount;
	return gCount == upCount || (enumerator().update(s) && (upCount = gCount) == gCount);
}

void ParallelSolve::requestRestart() {
	if (shared_->allowRestart() && ++shared_->restartReq == numThreads()) {
		shared_->postMessage(SharedData::msg_sync_restart, true);
	}
}

SolveAlgorithm* ParallelSolveOptions::createSolveObject() const {
	return numSolver() > 1 ? new ParallelSolve(*this) : BasicSolveOptions::createSolveObject();
}
////////////////////////////////////////////////////////////////////////////////////
// ParallelHandler
/////////////////////////////////////////////////////////////////////////////////////////
ParallelHandler::ParallelHandler(ParallelSolve& ctrl, Solver& s, const SolveParams& p)
	: MessageHandler()
	, ctrl_(&ctrl)
	, solver_(&s)
	, params_(&p)
	, received_(0)
	, recEnd_(0)
	, intEnd_(0)
	, error_(0)
	, win_(0)
	, up_(0) {
	this->next = this;
}

ParallelHandler::~ParallelHandler() { clearDB(0); delete [] received_; }

// adds this as post propagator to its solver and attaches the solver to ctx.
bool ParallelHandler::attach(SharedContext& ctx) {
	assert(solver_ && params_);
	gp_.reset();
	error_  = 0;
	win_    = 0;
	up_     = 0;
	act_    = 0;
	next    = 0;
	if (!received_ && ctx.distributor.get()) {
		received_ = new SharedLiterals*[RECEIVE_BUFFER_SIZE];
	}
	ctx.report("attach", solver_);
	solver_->addPost(this);
	return ctx.attach(solver_->id());
}

// removes this from the list of post propagators of its solver and detaches the solver from ctx.
void ParallelHandler::detach(SharedContext& ctx, bool) {
	handleTerminateMessage();
	ctx.report("detach", solver_);
	if (solver_->sharedContext() == &ctx) {
		clearDB(!error() ? solver_ : 0);
		ctx.report("detached db", solver_);
		ctx.detach(*solver_, error() != 0);
		ctx.report("detached ctx", solver_);
	}
}

void ParallelHandler::clearDB(Solver* s) {
	for (ClauseDB::iterator it = integrated_.begin(), end = integrated_.end(); it != end; ++it) {
		ClauseHead* c = static_cast(*it);
		if (s) { s->addLearnt(c, c->size(), Constraint_t::Other); }
		else   { c->destroy(); }
	}
	integrated_.clear();
	intEnd_= 0;
	for (uint32 i = 0; i != recEnd_; ++i) { received_[i]->release(); }
	recEnd_= 0;
}

ValueRep ParallelHandler::solveGP(BasicSolve& solve, GpType t, uint64 restart) {
	ValueRep res = value_free;
	bool     term= false;
	Solver&  s   = solve.solver();
	gp_.reset(restart, t);
	assert(act_ == 0);
	do {
		ctrl_->integrateModels(s, gp_.modCount);
		up_ = act_ = 1; // activate enumerator and bounds
		res = solve.solve();
		up_ = act_ = 0; // de-activate enumerator and bounds
		if      (res == value_true)  { term = !ctrl_->commitModel(s); }
		else if (res == value_false) { term = !ctrl_->commitUnsat(s); solve.reset(term); gp_.reset(restart, gp_.type); }
	} while (!term && res != value_free);
	return res;
}

// detach from solver, i.e. ignore any further messages
void ParallelHandler::handleTerminateMessage() {
	if (this->next != this) {
		// mark removed propagator by creating "self-loop"
		solver_->removePost(this);
		this->next = this;
	}
}

// split-off new guiding path and add it to solve object
void ParallelHandler::handleSplitMessage() {
	assert(solver_ && "ParallelHandler::handleSplitMessage(): not attached!");
	assert(solver_->splittable());
	Solver& s = *solver_;
	SingleOwnerPtr newPath(new LitVec());
	s.split(*newPath);
	ctrl_->pushWork(newPath.release());
}

bool ParallelHandler::handleRestartMessage() {
	// TODO
	// we may want to implement some heuristic, like
	// computing a local var order.
	return true;
}

bool ParallelHandler::simplify(Solver& s, bool sh) {
	ClauseDB::size_type i, j, end = integrated_.size();
	for (i = j = 0; i != end; ++i) {
		Constraint* c = integrated_[i];
		if (c->simplify(s, sh)) {
			c->destroy(&s, false);
			intEnd_ -= (i < intEnd_);
		}
		else                    {
			integrated_[j++] = c;
		}
	}
	shrinkVecTo(integrated_, j);
	if (intEnd_ > sizeVec(integrated_)) intEnd_ = sizeVec(integrated_);
	return false;
}

bool ParallelHandler::propagateFixpoint(Solver& s, PostPropagator* ctx) {
	// Check for messages and integrate any new information from
	// models/lemma exchange but only if path is setup.
	// Skip updates if called from other post propagator so that we do not
	// disturb any active propagation.
	if (int up = (ctx == 0 && up_ != 0)) {
		up_ ^= (uint32)s.updateMode();
		up  += (act_ == 0 || (up_ && (s.stats.choices & 63) != 0));
		if (s.stats.conflicts >= gp_.restart)  { ctrl_->requestRestart(); gp_.restart *= 2; }
		for (uint32 cDL = s.decisionLevel();;) {
			bool ok = ctrl_->handleMessages(s) && (up > 1 ? integrate(s) : ctrl_->integrateModels(s, gp_.modCount));
			if (!ok)                         { return false; }
			if (cDL != s.decisionLevel())    { // cancel active propagation on cDL
				cancelPropagation();
				cDL = s.decisionLevel();
			}
			if      (!s.queueSize())         { if (++up == 3) return true; }
			else if (!s.propagateUntil(this)){ return false; }
		}
	}
	return ctrl_->handleMessages(s);
}

// checks whether s still has a model once all
// information from previously found models were integrated
bool ParallelHandler::isModel(Solver& s) {
	assert(s.numFreeVars() == 0);
	// either no unprocessed updates or still a model after
	// updates were integrated
	return ctrl_->integrateModels(s, gp_.modCount)
		&& s.numFreeVars() == 0
		&& s.queueSize()   == 0;
}
bool ParallelHandler::integrate(Solver& s) {
	uint32 rec = recEnd_ + s.receive(received_ + recEnd_, RECEIVE_BUFFER_SIZE - recEnd_);
	if (!rec) { return true; }
	ClauseCreator::Result ret;
	uint32 dl       = s.decisionLevel(), added = 0, i = 0;
	uint32 intFlags = ctrl_->integrateFlags();
	recEnd_         = 0;
	if (params_->reduce.strategy.glue != 0) {
		intFlags |= ClauseCreator::clause_int_lbd;
	}
	do {
		ret    = ClauseCreator::integrate(s, received_[i++], intFlags, Constraint_t::Other);
		added += ret.status != ClauseCreator::status_subsumed;
		if (ret.local) { add(ret.local); }
		if (ret.unit()){ s.stats.addIntegratedAsserting(dl, s.decisionLevel()); dl = s.decisionLevel(); }
		if (!ret.ok()) { while (i != rec) { received_[recEnd_++] = received_[i++]; } }
	} while (i != rec);
	s.stats.addIntegrated(added);
	return !s.hasConflict();
}

void ParallelHandler::add(ClauseHead* h) {
	if (intEnd_ < integrated_.size()) {
		ClauseHead* o = (ClauseHead*)integrated_[intEnd_];
		integrated_[intEnd_] = h;
		assert(o);
		if (!ctrl_->integrateUseHeuristic() || o->locked(*solver_) || o->activity().activity() > 0) {
			solver_->addLearnt(o, o->size(), Constraint_t::Other);
		}
		else {
			o->destroy(solver_, true);
			solver_->stats.removeIntegrated();
		}
	}
	else {
		integrated_.push_back(h);
	}
	if (++intEnd_ >= ctrl_->integrateGrace()) {
		intEnd_ = 0;
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// Distribution
/////////////////////////////////////////////////////////////////////////////////////////
uint64 ParallelSolveOptions::initPeerMask(uint32 id, Integration::Topology topo, uint32 maxT)  {
	if (topo == Integration::topo_all) { return Distributor::initSet(maxT) ^ Distributor::mask(id); }
	if (topo == Integration::topo_ring){
		uint32 prev = id > 0 ? id - 1 : maxT - 1;
		uint32 next = (id + 1) % maxT;
		return Distributor::mask(prev) | Distributor::mask(next);
	}
	bool ext = topo == Integration::topo_cubex;
	uint32 n = maxT;
	uint32 k = 1;
	for (uint32 i = n / 2; i > 0; i /= 2, k *= 2) { }
	uint64 res = 0, x = 1;
	for (uint32 m = 1; m <= k; m *= 2) {
		uint32 i = m ^ id;
		if      (i < n)         { res |= (x << i);     }
		else if (ext && k != m) { res |= (x << (i^k)); }
	}
	if (ext) {
		uint32 s = k ^ id;
		for(uint32 m = 1; m < k && s >= n; m *= 2) {
			uint32 i = m ^ s;
			if (i < n) { res |= (x << i); }
		}
	}
	assert( (res & (x<(topo);
	queue_     = new Queue(maxT);
	threadId_  = (ThreadInfo*)alignedAlloc((maxT * sizeof(ThreadInfo)), 64);
	for (uint32 i = 0; i != maxT; ++i) {
		new (&threadId_[i]) ThreadInfo;
		threadId_[i].id       = queue_->addThread();
		threadId_[i].peerMask = ParallelSolveOptions::initPeerMask(i, t, maxT);
	}
}
GlobalDistribution::~GlobalDistribution() {
	static_assert(sizeof(ThreadInfo) == 64, "Invalid size");
	release();
}
void GlobalDistribution::release() {
	if (queue_) {
		for (uint32 i = 0; i != queue_->maxThreads(); ++i) {
			Queue::ThreadId& id = getThreadId(i);
			for (ClausePair n; queue_->tryConsume(id, n); ) {
				if (n.sender != i) { n.lits->release(); }
			}
			threadId_[i].~ThreadInfo();
		}
		delete queue_;
		queue_ = 0;
		alignedFree(threadId_);
	}
}
void GlobalDistribution::publish(const Solver& s, SharedLiterals* n) {
	assert(n->refCount() >= (queue_->maxThreads()-1));
	queue_->publish(ClausePair(s.id(), n), getThreadId(s.id()));
}
uint32 GlobalDistribution::receive(const Solver& in, SharedLiterals** out, uint32 maxn) {
	uint32 r = 0;
	Queue::ThreadId& id = getThreadId(in.id());
	uint64 peers = getPeerMask(in.id());
	for (ClausePair n; r != maxn && queue_->tryConsume(id, n); ) {
		if (n.sender != in.id()) {
			if (inSet(peers, n.sender))  { out[r++] = n.lits; }
			else if (n.lits->size() == 1){ out[r++] = n.lits; }
			else                         { n.lits->release(); }
		}
	}
	return r;
}

/////////////////////////////////////////////////////////////////////////////////////////
// LocalDistribution
/////////////////////////////////////////////////////////////////////////////////////////
LocalDistribution::LocalDistribution(const Policy& p, uint32 maxT, uint32 topo) : Distributor(p), thread_(0), numThread_(0) {
	typedef ParallelSolveOptions::Integration::Topology Topology;
	assert(maxT <= ParallelSolveOptions::supportedSolvers());
	Topology t = static_cast(topo);
	thread_    = new ThreadData*[numThread_ = maxT];
	size_t sz  = ((sizeof(ThreadData) + 63) / 64) * 64;
	for (uint32 i = 0; i != maxT; ++i) {
		ThreadData* ti = new (alignedAlloc(sz, 64)) ThreadData;
		ti->received.init(&ti->sentinal);
		ti->peers = ParallelSolveOptions::initPeerMask(i, t, maxT);
		ti->free  = 0;
		thread_[i]= ti;
	}
}
LocalDistribution::~LocalDistribution() {
	while (numThread_) {
		ThreadData* ti      = thread_[--numThread_];
		thread_[numThread_] = 0;
		for (QNode* n; (n = ti->received.pop()) != 0; ) {
			static_cast(n->data)->release();
		}
		ti->~ThreadData();
		alignedFree(ti);
	}
	for (MPSCPtrQueue::RawNode* n; (n = blocks_.tryPop()) != 0; ) {
		alignedFree(n);
	}
	delete [] thread_;
}

void LocalDistribution::freeNode(uint32 tId, QNode* n) const {
	if (n != &thread_[tId]->sentinal) {
		n->next = thread_[tId]->free;
		thread_[tId]->free = n;
	}
}

LocalDistribution::QNode* LocalDistribution::allocNode(uint32 tId, SharedLiterals* clause) {
	for (ThreadData* td = thread_[tId];;) {
		if (QNode* n = td->free) {
			td->free = static_cast(static_cast(n->next));
			n->data  = clause;
			return n;
		}
		// alloc a new block of node;
		const uint32 nNodes = 128;
		QNode* raw = (QNode*)alignedAlloc(sizeof(QNode) * nNodes, 64);
		// add nodes [1, nNodes) to free list
		for (uint32 i = 1; i != nNodes-1; ++i) {
			raw[i].next = &raw[i+1];
		}
		raw[nNodes-1].next = 0;
		td->free = &raw[1];
		// use first node to link to block list
		blocks_.push(raw);
	}
}

void LocalDistribution::publish(const Solver& s, SharedLiterals* n) {
	assert(n->refCount() >= (numThread_-1));
	uint32 sender = s.id();
	uint32 size   = n->size();
	uint32 decRef = 0;
	for (uint32 i = 0; i != numThread_; ++i) {
		if (i == sender) { continue; }
		if (size > 1 && !inSet(thread_[i]->peers, sender)) { ++decRef; }
		else {
			QNode* node = allocNode(sender, n);
			thread_[i]->received.push(node);
		}
	}
	if (decRef) { n->release(decRef); }
}
uint32 LocalDistribution::receive(const Solver& in, SharedLiterals** out, uint32 maxn) {
	MPSCPtrQueue& q = thread_[in.id()]->received;
	QNode*        n = 0;
	uint32        r = 0;
	while (r != maxn && (n = q.pop()) != 0) {
		out[r++] = static_cast(n->data);
		freeNode(in.id(), n);
	}
	return r;
}

} } // namespace Clasp::mt

#endif
clasp-3.2.2/libclasp/src/parser.cpp000066400000000000000000000452221304134206100171770ustar00rootroot00000000000000//
// Copyright (c) Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#ifdef _MSC_VER
#pragma warning (disable : 4996)
#endif
const char* clasp_format(char* buf, unsigned size, const char* fmt, ...) {
	if (!size) return buf;
	*buf = 0;
	va_list args;
	va_start(args, fmt);
	int r = vsnprintf(buf, size, fmt, args);
	if (r < 0 || unsigned(r) >= size) { buf[size-1] = 0; }
	va_end(args);
	return buf;
}
ClaspStringBuffer& ClaspStringBuffer::append(const char* str) {
	size_t cap = static_cast(end_ - pos_);
	size_t len = std::strlen(str);
	if (len < cap || grow(len)) {
		std::memcpy(pos_, str, len + 1);
		pos_ += len;
	}
	else {
		std::memcpy(pos_, str, cap);
		(pos_ = end_)[-1] = 0;
	}
	return *this;
}
ClaspStringBuffer& ClaspStringBuffer::appendFormat(const char* fmt, ...) {
	for (;;) {
		va_list args;
		va_start(args, fmt);
		size_t cap = static_cast(end_ - pos_);
		int res = cap ? vsnprintf(pos_, cap, fmt, args) : 0;
		va_end(args);
		if (res < 0 || size_t(res) >= cap) { // overflow - grow buffer
			if (!grow(res > 0 ? size_t(res) : cap + 1)) {
				(pos_ = end_)[-1] = 0; // out of memory - truncate and return
				return *this;
			}
		}
		else {
			pos_ += res;
			return *this;
		}
	}
}
bool ClaspStringBuffer::grow(size_t n) {
	size_t nc = static_cast(end_ - buf_) * 2;
	size_t ns = static_cast(pos_ - buf_) + n + 1;
	if (nc < ns) { nc = ns; }
	if (char* nb = (char*)std::realloc(buf_ == fix_ ? 0 : buf_, nc)) {
		if (buf_ == fix_) {
			std::memcpy(nb, fix_, sizeof(fix_));
		}
		pos_ = nb + (pos_ - buf_);
		end_ = nb + nc;
		buf_ = nb;
		return true;
	}
	return false;
}
ClaspStringBuffer::~ClaspStringBuffer() {
	if (buf_ != fix_) { std::free(buf_); }
}
namespace Clasp {
using Potassco::ParseError;
ProblemType detectProblemType(std::istream& in) {
	std::istream::int_type x = std::char_traits::eof();
	while (in && (x = in.peek()) != std::char_traits::eof() ) {
		char c = static_cast(x);
		if (c == ' ' || c == '\t')  { in.get(); continue; }
		if (AspParser::accept(c))   { return Problem_t::Asp; }
		if (DimacsReader::accept(c)){ return Problem_t::Sat; }
		if (OpbReader::accept(c))   { return Problem_t::Pb;  }
		break;
	}
	char msg[] = "'c': unrecognized input format";
	msg[1]     = (char)(unsigned char)x;
	in && x != std::char_traits::eof()
		? throw ParseError(1, msg)
		: throw ParseError(0, "bad input stream");
}
/////////////////////////////////////////////////////////////////////////////////////////
// ProgramParser
/////////////////////////////////////////////////////////////////////////////////////////
ProgramParser::ProgramParser() : strat_(0) {}
ProgramParser::~ProgramParser() {}
bool ProgramParser::accept(std::istream& str, const ParserOptions& o) {
	if ((strat_ = doAccept(str, o)) != 0) {
		strat_->setMaxVar(VAR_MAX);
		return true;
	}
	return false;
}
bool ProgramParser::isOpen() const {
	return strat_ != 0;
}
bool ProgramParser::incremental() const {
	return strat_ && strat_->incremental();
}
bool ProgramParser::parse() {
	return strat_ && strat_->parse();
}
bool ProgramParser::more() {
	return strat_ && strat_->more();
}
void ProgramParser::reset() {
	if (strat_) { strat_->reset(); }
	strat_ = 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// AspParser::SmAdapter
//
// Callback interface for smodels parser
/////////////////////////////////////////////////////////////////////////////////////////
struct AspParser::SmAdapter : public Asp::LogicProgramAdapter, public Potassco::AtomTable {
	typedef Clasp::HashMap_t::map_type StrMap;
	typedef SingleOwnerPtr StrMapPtr;
	SmAdapter(Asp::LogicProgram& prg) : Asp::LogicProgramAdapter(prg) {}
	void endStep() {
		Asp::LogicProgramAdapter::endStep();
		if (inc_ && lp_->ctx()->hasMinimize()) {
			lp_->ctx()->removeMinimize();
		}
		if (!inc_) { atoms_ = 0; }
	}
	void add(Potassco::Atom_t id, const Potassco::StringSpan& name, bool output) {
		ConstString n(name);
		if (atoms_.get()) { atoms_->insert(StrMap::value_type(n, id)); }
		if (output) { lp_->addOutput(n, id); }
	}
	Potassco::Atom_t find(const Potassco::StringSpan& name) {
		if (!atoms_.get()) { return 0; }
		ConstString n(name);
		StrMap::iterator it = atoms_->find(n);
		return it != atoms_->end() ? it->second : 0;
	}
	StrMapPtr atoms_;
};
/////////////////////////////////////////////////////////////////////////////////////////
// AspParser
/////////////////////////////////////////////////////////////////////////////////////////
AspParser::AspParser(Asp::LogicProgram& prg)
	: lp_(&prg)
	, in_(0)
	, out_(0) {}
AspParser::~AspParser() {
	delete in_;
	delete out_;
}
bool AspParser::accept(char c) { return Potassco::BufferedStream::isDigit(c) || c == 'a'; }

AspParser::StrategyType* AspParser::doAccept(std::istream& str, const ParserOptions& o) {
	delete in_;
	delete out_;
	if (Potassco::BufferedStream::isDigit((char)str.peek())) {
		out_ = new SmAdapter(*lp_);
		Potassco::SmodelsInput::Options so;
		so.enableClaspExt();
		if (o.isEnabled(ParserOptions::parse_heuristic)) {
			so.convertHeuristic();
			static_cast(out_)->atoms_ = new AspParser::SmAdapter::StrMap();
		}
		if (o.isEnabled(ParserOptions::parse_acyc_edge)) {
			so.convertEdges();
		}
		in_ = new Potassco::SmodelsInput(*out_, so, static_cast(out_));
	}
	else {
		out_ = new Asp::LogicProgramAdapter(*lp_);
		in_ = new Potassco::AspifInput(*out_);
	}
	return in_->accept(str) ? in_ : 0;
}

void AspParser::write(Asp::LogicProgram& prg, std::ostream& os) {
	write(prg, os, prg.supportsSmodels() ? format_smodels : format_aspif);
}
void AspParser::write(Asp::LogicProgram& prg, std::ostream& os, Format f) {
	using namespace Potassco;
	SingleOwnerPtr out;
	if (f == format_aspif) {
		out.reset(new Potassco::AspifOutput(os));
	}
	else {
		out.reset(new Potassco::SmodelsOutput(os, true, prg.falseAtom()));
	}
	if (prg.startAtom() == 1) { out->initProgram(prg.isIncremental()); }
	out->beginStep();
	prg.accept(*out);
	out->endStep();
}
/////////////////////////////////////////////////////////////////////////////////////////
// clasp specific extensions for Dimacs/OPB
/////////////////////////////////////////////////////////////////////////////////////////
SatReader::SatReader() {}
bool SatReader::skipLines(char c) {
	while (peek(true) == c) { skipLine(); }
	return true;
}
Literal SatReader::matchLit(Var max) {
	for (char c; (c = stream()->peek()) == ' ' || c == '\t';) { stream()->get(); }
	bool sign = stream()->peek() == '-';
	if (sign) { stream()->get(); }
	if (stream()->peek() == 'x') { stream()->get(); }
	int64 id;
	require(stream()->match(id) && id >= 0 && id <= (int64)max, "identifier expected");
	return Literal(static_cast(id), sign);
}
void SatReader::parseGraph(uint32 maxVar, const char* pre, ExtDepGraph& graph) {
	int maxNode = matchPos("graph: positive number of nodes expected");
	while (match(pre)) {
		if      (match("node ")) { skipLine(); }
		else if (match("arc "))  {
			Literal lit = matchLit(maxVar);
			Var beg = matchPos(maxNode, "graph: invalid start node");
			Var end = matchPos(maxNode, "graph: invalid end node");
			graph.addEdge(lit, beg, end);
		}
		else if (match("endgraph")) { return; }
		else { break; }
	}
	require(false, "graph: endgraph expected");
}
void SatReader::parseProject(uint32 maxVar, SharedContext& ctx) {
	for (unsigned n = this->line(); (stream()->skipWs(), this->line() == n);) {
		Literal x = matchLit(maxVar);
		if (x == lit_true()) break;
		require(!x.sign(), "project: positive literal expected");
		ctx.output.addProject(x);
	}
}
void SatReader::parseAssume(uint32 maxVar) {
	for (unsigned n = this->line(); (stream()->skipWs(), this->line() == n);) {
		Literal x = matchLit(maxVar);
		if (x == lit_true()) { break; }
		addAssumption(x);
	}
}
void SatReader::parseHeuristic(uint32 maxVar, SharedContext& ctx) {
	using Potassco::Heuristic_t;
	Heuristic_t type = static_cast(matchPos(Heuristic_t::eMax, "heuristic: modifier expected"));
	Literal atom = matchLit(maxVar);
	require(!atom.sign(), "heuristic: positive literal expected");
	int16    bias = (int16)matchInt(INT16_MIN, INT16_MAX, "heuristic: bias expected");
	uint16   prio = (uint16)matchPos(UINT16_MAX, "heuristic: priority expected");
	ctx.heuristic.add(atom.var(), type, bias, prio, matchLit(maxVar));
}
void SatReader::parseOutput(uint32 maxVar, SharedContext& ctx) {
	if (match("range ")) {
		Literal lo = matchLit(maxVar);
		Literal hi = matchLit(maxVar);
		require(lo.var() <= hi.var(), "output: invalid range");
		ctx.output.setVarRange(Range32(lo.var(), hi.var() + 1));
	}
	else {
		Literal cond = matchLit(maxVar);
		while (peek(false) == ' ') { stream()->get(); }
		std::string name;
		for (char c; (c = stream()->get()) != '\n' && c;) { name += c; }
		name.erase(name.find_last_not_of(" \t")+1);
		ctx.output.add(ConstString(Potassco::toSpan(name)), cond);
	}
}
void SatReader::parseExt(const char* pre, uint32 maxVar, SharedContext& ctx) {
	const bool acyc = options.isEnabled(ParserOptions::parse_acyc_edge);
	const bool minw = options.isEnabled(ParserOptions::parse_minimize);
	const bool proj = options.isEnabled(ParserOptions::parse_project);
	const bool heur = options.isEnabled(ParserOptions::parse_heuristic);
	const bool assu = options.isEnabled(ParserOptions::parse_assume);
	uint32     outp = options.isEnabled(ParserOptions::parse_output);
	for (ExtDepGraph* g = 0; match(pre);) {
		if (acyc && match("graph ")) {
			require(g == 0, "graph: only one graph supported");
			g = ctx.extGraph.get();
			if (!g) { ctx.extGraph = (g = new ExtDepGraph()); }
			else { g->update(); }
			parseGraph(maxVar, pre, *g);
			g->finalize(ctx);
		}
		else if (minw && match("minweight ")) {
			WeightLitVec min;
			for (int lit, weight, max = static_cast(maxVar); (lit = matchInt(-max, max)) != 0;) {
				weight = matchInt(CLASP_WEIGHT_T_MIN, CLASP_WEIGHT_T_MAX, "minweight: weight expected");
				min.push_back(WeightLiteral(toLit(lit), weight));
			}
			addObjective(min);
		}
		else if (proj && match("project "))   { parseProject(maxVar, ctx); }
		else if (heur && match("heuristic ")) { parseHeuristic(maxVar, ctx); }
		else if (assu && match("assume "))    { parseAssume(maxVar); }
		else if (outp && match("output "))    {
			if (outp++ == 1) { ctx.output.setVarRange(Range32(0, 0)); }
			parseOutput(maxVar, ctx);
		}
		else { skipLine(); }
	}
}

SatParser::SatParser(SatBuilder& prg) : reader_(new DimacsReader(prg)) {}
SatParser::SatParser(PBBuilder& prg)  : reader_(new OpbReader(prg)) {}
SatParser::~SatParser() { delete reader_; }
ProgramParser::StrategyType* SatParser::doAccept(std::istream& str, const ParserOptions& o) {
	reader_->options = o;
	return reader_->accept(str) ? reader_ : 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// DimacsReader
/////////////////////////////////////////////////////////////////////////////////////////
DimacsReader::DimacsReader(SatBuilder& prg) : program_(&prg) {}

// Parses the p line: p [w]cnf[+] #vars #clauses [max clause weight]
bool DimacsReader::doAttach(bool& inc) {
	inc = false;
	if (!accept(peek(false))) { return false; }
	skipLines('c');
	require(match("p "), "missing problem line");
	wcnf_ = match("w");
	require(match("cnf", false), "unrecognized format, [w]cnf expected");
	if (stream()->peek() == '+') { stream()->get(); }
	require(stream()->get() == ' ', "invalid problem line: expected ' ' after format");
	numVar_     = matchPos(ProgramParser::VAR_MAX, "#vars expected");
	uint32 numC = matchPos("#clauses expected");
	wsum_t cw   = 0;
	while (stream()->peek() == ' ')  { stream()->get(); };
	if (wcnf_ && peek(false) != '\n'){ stream()->match(cw); }
	while (stream()->peek() == ' ')  { stream()->get(); };
	require(stream()->get() == '\n', "invalid extra characters in problem line");
	program_->prepareProblem(numVar_, cw, numC);
	if (options.ext != 0) {
		parseExt("c ", numVar_, *program_->ctx());
	}
	return true;
}
bool DimacsReader::doParse() {
	LitVec cc; WeightLitVec wlc;
	const bool  wcnf = wcnf_;
	const int64 maxV = static_cast(numVar_);
	for (int64 cw = 0, lit = 0; skipLines('c') && peek(true); lit = 0, cc.clear()) {
		if (wcnf) { require(stream()->match(cw) && cw > 0, "wcnf: positive clause weight expected"); }
		while (stream()->match(lit) && lit != 0) {
			require(lit >= -maxV && lit <= maxV, "invalid variable in clause");
			cc.push_back(toLit(static_cast(lit)));
		}
		if (lit == 0) { program_->addClause(cc, cw); }
		else {
			require(!wcnf, "invalid character in clause");
			const int  sign = match("<= ") ? -1 : int(require(match(">= "), "invalid constraint operator"));
			const int bound = matchInt(CLASP_WEIGHT_T_MIN, CLASP_WEIGHT_T_MAX, "invalid constraint bound");
			wlc.clear();
			for (LitVec::const_iterator it = cc.begin(), end = cc.end(); it != end; ++it) {
				wlc.push_back(WeightLiteral(*it, sign));
			}
			program_->addConstraint(wlc, bound * sign);
		}
	}
	return require(!more(), "unrecognized format");
}
void DimacsReader::addObjective(const WeightLitVec& vec) {
	program_->addObjective(vec);
}
void DimacsReader::addAssumption(Literal x) {
	program_->addAssumption(x);
}
/////////////////////////////////////////////////////////////////////////////////////////
// OpbReader
/////////////////////////////////////////////////////////////////////////////////////////
OpbReader::OpbReader(PBBuilder& prg) : program_(&prg) {}

void OpbReader::addObjective(const WeightLitVec& vec) {
	program_->addObjective(vec);
}
void OpbReader::addAssumption(Literal x) {
	program_->addAssumption(x);
}

// * #variable= int #constraint= int [#product= int sizeproduct= int] [#soft= int mincost= int maxcost= int sumcost= int]
// where [] indicate optional parts, i.e.
//  LIN-PBO: * #variable= int #constraint= int
//  NLC-PBO: * #variable= int #constraint= int #product= int sizeproduct= int
//  LIN-WBO: * #variable= int #constraint= int #soft= int mincost= int maxcost= int sumcost= int
//  NLC-WBO: * #variable= int #constraint= int #product= int sizeproduct= int #soft= int mincost= int maxcost= int sumcost= int
bool OpbReader::doAttach(bool& inc) {
	inc = false;
	if (!accept(peek(false))) { return false; }
	require(match("* #variable="), "missing problem line '* #variable='");
	unsigned numV = matchPos(ProgramParser::VAR_MAX, "number of vars expected");
	require(match("#constraint="), "bad problem line: missing '#constraint='");
	unsigned numC = matchPos("number of constraints expected");
	unsigned numProd = 0, sizeProd = 0, numSoft = 0;
	minCost_ = 0, maxCost_ = 0;
	if (match("#product=")) { // NLC instance
		numProd = matchPos();
		require(match("sizeproduct="), "'sizeproduct=' expected");
		sizeProd= matchPos();
		(void)sizeProd;
	}
	if (match("#soft=")) { // WBO instance
		numSoft = matchPos();
		require(match("mincost="), "'mincost=' expected");
		minCost_= (weight_t)matchPos(CLASP_WEIGHT_T_MAX, "invalid min costs");
		require(match("maxcost="), "'maxcost=' expected");
		maxCost_= (weight_t)matchPos(CLASP_WEIGHT_T_MAX, "invalid max costs");
		require(match("sumcost="), "'sumcost=' expected");
		wsum_t sum;
		require(stream()->match(sum) && sum > 0, "positive integer expected");
	}
	program_->prepareProblem(numV, numProd, numSoft, numC);
	return true;
}
bool OpbReader::doParse() {
	if (options.ext && options.ext != ParserOptions::parse_minimize) {
		options.ext &= ~uint8(ParserOptions::parse_minimize);
		parseExt("* ", program_->numVars(), *program_->ctx());
	}
	skipLines('*');
	parseOptObjective();
	for (;;) {
		skipLines('*');
		if (!more()) { return true; }
		parseConstraint();
	}
}
// ::= "min:"    ";"
// OR
//   ::= "soft:" [] ";"
void OpbReader::parseOptObjective() {
	if (match("min:")) {
		parseSum();
		program_->addObjective(active_.lits);
	}
	else if (match("soft:")) {
		wsum_t softCost;
		require(stream()->match(softCost) && softCost > 0, "positive integer expected");
		require(match(";"), "semicolon missing after constraint");
		program_->setSoftBound(softCost);
	}
}

// ::=      ";"
// OR
// ::= "["    "]" 
void OpbReader::parseConstraint() {
	weight_t cost = 0;
	if (match("[")) {
		cost = matchInt(minCost_, maxCost_, "invalid soft constraint cost");
		require(match("]"), "invalid soft constraint");
	}
	parseSum();
	active_.eq = match("=");
	require(active_.eq || match(">=", false), "relational operator expected");
	active_.bound = matchInt(CLASP_WEIGHT_T_MIN, CLASP_WEIGHT_T_MAX, "invalid coefficient on rhs of constraint");
	require(match(";"), "semicolon missing after constraint");
	program_->addConstraint(active_.lits, active_.bound, active_.eq, cost);
}

// ::=  |  
// ::=    
void OpbReader::parseSum() {
	active_.lits.clear();
	while (!match(";")) {
		int coeff = matchInt(INT_MIN+1, INT_MAX, "coefficient expected");
		parseTerm();
		Literal x = active_.term.size() == 1 ? active_.term[0] : program_->addProduct(active_.term);
		active_.lits.push_back(WeightLiteral(x, coeff));
		char p = peek(true);
		if (p == '>' || p == '=') break;
	}
}
// ::=
// OR
// ::=  |  + 
void OpbReader::parseTerm() {
	active_.term.clear();
	char peek;
	do  {
		match("*");             // optionally
		bool sign = match("~"); // optionally
		require(match("x"), "identifier expected");
		Var var   = matchAtom();
		require(var <= program_->numVars(), "identifier out of range");
		active_.term.push_back(Literal(var, sign));
		peek = this->peek(true);
	} while (peek == '*' || peek == '~' || peek == 'x');
}

}
clasp-3.2.2/libclasp/src/program_builder.cpp000066400000000000000000000344431304134206100210630ustar00rootroot00000000000000//
// Copyright (c) 2006-2016 Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp {

/////////////////////////////////////////////////////////////////////////////////////////
// class ProgramBuilder
/////////////////////////////////////////////////////////////////////////////////////////
ProgramBuilder::ProgramBuilder() : ctx_(0), frozen_(true) {}
ProgramBuilder::~ProgramBuilder() {}
bool ProgramBuilder::ok() const { return ctx_ && ctx_->ok(); }
bool ProgramBuilder::startProgram(SharedContext& ctx) {
	ctx.report(Event::subsystem_load);
	ctx_    = &ctx;
	frozen_ = ctx.frozen();
	return ctx_->ok() && doStartProgram();
}
bool ProgramBuilder::updateProgram() {
	CLASP_ASSERT_CONTRACT_MSG(ctx_, "startProgram() not called!");
	bool up = frozen();
	bool ok = ctx_->ok() && ctx_->unfreeze() && doUpdateProgram() && (ctx_->setSolveMode(SharedContext::solve_multi), true);
	frozen_ = ctx_->frozen();
	if (up && !frozen()){ ctx_->report(Event::subsystem_load); }
	return ok;
}
bool ProgramBuilder::endProgram() {
	CLASP_ASSERT_CONTRACT_MSG(ctx_, "startProgram() not called!");
	bool ok = ctx_->ok();
	if (ok && !frozen_) {
		ctx_->report(Event::subsystem_prepare);
		ok = doEndProgram();
		frozen_ = true;
	}
	return ok;
}
void ProgramBuilder::getAssumptions(LitVec& out) const {
	CLASP_ASSERT_CONTRACT(ctx_ && frozen());
	doGetAssumptions(out);
}
void ProgramBuilder::getWeakBounds(SumVec& out) const {
	CLASP_ASSERT_CONTRACT(ctx_ && frozen());
	doGetWeakBounds(out);
}
ProgramParser& ProgramBuilder::parser() {
	if (!parser_.get()) {
		parser_.reset(doCreateParser());
	}
	return *parser_;
}
bool ProgramBuilder::parseProgram(std::istream& input) {
	CLASP_ASSERT_CONTRACT(ctx_ && !frozen());
	ProgramParser& p = parser();
	CLASP_FAIL_IF(!p.accept(input), "unrecognized input format");
	return p.parse();
}
void ProgramBuilder::addMinLit(weight_t prio, WeightLiteral x) {
	ctx_->addMinimize(x, prio);
}
void ProgramBuilder::markOutputVariables() const {
	const OutputTable& out = ctx_->output;
	for (OutputTable::range_iterator it = out.vars_begin(), end = out.vars_end(); it != end; ++it) {
		ctx_->setOutput(*it, true);
	}
	for (OutputTable::pred_iterator it = out.pred_begin(), end = out.pred_end(); it != end; ++it) {
		ctx_->setOutput(it->cond.var(), true);
	}
}
void ProgramBuilder::doGetWeakBounds(SumVec&) const  {}
/////////////////////////////////////////////////////////////////////////////////////////
// class SatBuilder
/////////////////////////////////////////////////////////////////////////////////////////
SatBuilder::SatBuilder(bool maxSat) : ProgramBuilder(), hardWeight_(0), vars_(0), pos_(0), maxSat_(maxSat) {}
bool SatBuilder::markAssigned() {
	if (pos_ == ctx()->master()->trail().size()) { return true; }
	bool ok = ctx()->ok() && ctx()->master()->propagate();
	for (const LitVec& trail = ctx()->master()->trail(); pos_ < trail.size(); ++pos_) {
		markLit(~trail[pos_]);
	}
	return ok;
}
void SatBuilder::prepareProblem(uint32 numVars, wsum_t cw, uint32 clauseHint) {
	CLASP_ASSERT_CONTRACT_MSG(ctx(), "startProgram() not called!");
	Var start = ctx()->addVars(numVars, Var_t::Atom, VarInfo::Input | VarInfo::Nant);
	ctx()->output.setVarRange(Range32(start, start + numVars));
	ctx()->startAddConstraints(std::min(clauseHint, uint32(10000)));
	varState_.resize(start + numVars);
	vars_       = ctx()->numVars();
	hardWeight_ = cw;
	markAssigned();
}
bool SatBuilder::addObjective(const WeightLitVec& min) {
	for (WeightLitVec::const_iterator it = min.begin(), end = min.end(); it != end; ++it) {
		addMinLit(0, *it);
		varState_[it->first.var()] |= (falseValue(it->first) << 2u);
	}
	return ctx()->ok();
}
void SatBuilder::addProject(Var v) {
	ctx()->output.addProject(posLit(v));
}
void SatBuilder::addAssumption(Literal x) {
	assume_.push_back(x);
}
bool SatBuilder::addClause(LitVec& clause, wsum_t cw) {
	if (!ctx()->ok() || satisfied(clause)) { return ctx()->ok(); }
	CLASP_ASSERT_CONTRACT_MSG(cw >= 0 && (cw <= std::numeric_limits::max() || cw == hardWeight_), "Clause weight out of bounds!");
	if (cw == 0 && maxSat_){ cw = 1; }
	if (cw == hardWeight_) {
		return ClauseCreator::create(*ctx()->master(), clause, Constraint_t::Static).ok() && markAssigned();
	}
	else {
		// Store weight, relaxtion var, and (optionally) clause
		softClauses_.push_back(Literal::fromRep((uint32)cw));
		if      (clause.size() > 1){ softClauses_.push_back(posLit(++vars_)); softClauses_.insert(softClauses_.end(), clause.begin(), clause.end()); }
		else if (!clause.empty())  { softClauses_.push_back(~clause.back());  }
		else                       { softClauses_.push_back(lit_true()); }
		softClauses_.back().flag(); // mark end of clause
	}
	return true;
}
bool SatBuilder::satisfied(LitVec& cc) {
	bool sat = false;
	LitVec::iterator j = cc.begin();
	for (LitVec::const_iterator it = cc.begin(), end = cc.end(); it != end; ++it) {
		Literal x = *it;
		uint32  m = 1+x.sign();
		uint32  n = uint32(varState_[it->var()] & 3u) + m;
		if      (n == m) { varState_[it->var()] |= m; x.unflag(); *j++ = x; }
		else if (n == 3u){ sat = true; break; }
	}
	cc.erase(j, cc.end());
	for (LitVec::const_iterator it = cc.begin(), end = cc.end(); it != end; ++it) {
		if (!sat) { varState_[it->var()] |= (varState_[it->var()] & 3u) << 2; }
		varState_[it->var()] &= ~3u;
	}
	return sat;
}
bool SatBuilder::addConstraint(WeightLitVec& lits, weight_t bound) {
	if (!ctx()->ok()) { return false; }
	WeightLitsRep rep = WeightLitsRep::create(*ctx()->master(), lits, bound);
	if (rep.open()) {
		for (const WeightLiteral* x = rep.lits, *end = rep.lits + rep.size; x != end; ++x) {
			varState_[x->first.var()] |= (trueValue(x->first) << 2);
		}
	}
	return WeightConstraint::create(*ctx()->master(), lit_true(), rep, 0u).ok();
}
bool SatBuilder::doStartProgram() {
	vars_ = ctx()->numVars();
	pos_  = 0;
	assume_.clear();
	return markAssigned();
}
ProgramParser* SatBuilder::doCreateParser() {
	return new SatParser(*this);
}
bool SatBuilder::doEndProgram() {
	bool ok = ctx()->ok();
	if (!softClauses_.empty() && ok) {
		ctx()->setPreserveModels(true);
		uint32 softVars = vars_ - ctx()->numVars();
		ctx()->addVars(softVars, Var_t::Atom, VarInfo::Nant);
		ctx()->startAddConstraints();
		LitVec cc;
		for (LitVec::const_iterator it = softClauses_.begin(), end = softClauses_.end(); it != end && ok; ++it) {
			weight_t w     = (weight_t)it->rep();
			Literal  relax = *++it;
			if (!relax.flagged()) {
				cc.assign(1, relax);
				do { cc.push_back(*++it); } while (!cc.back().flagged());
				cc.back().unflag();
				ok = ClauseCreator::create(*ctx()->master(), cc, Constraint_t::Static).ok();
			}
			addMinLit(0, WeightLiteral(relax.unflag(), w));
		}
		LitVec().swap(softClauses_);
	}
	if (ok) {
		const uint32 seen = 12;
		const bool   elim = !ctx()->preserveModels();
		for (Var v = 1; v != (Var)varState_.size() && ok; ++v) {
			uint32 m = varState_[v];
			if ( (m & seen) != seen ) {
				if      (m)   { ctx()->setNant(v, false); ctx()->master()->setPref(v, ValueSet::def_value, ValueRep(m >> 2)); }
				else if (elim){ ctx()->eliminate(v); }
			}
		}
		markOutputVariables();
	}
	return ok;
}
/////////////////////////////////////////////////////////////////////////////////////////
// class PBBuilder
/////////////////////////////////////////////////////////////////////////////////////////
PBBuilder::PBBuilder() : auxVar_(1) {}
void PBBuilder::prepareProblem(uint32 numVars, uint32 numProd, uint32 numSoft, uint32 numCons) {
	CLASP_ASSERT_CONTRACT_MSG(ctx(), "startProgram() not called!");
	Var out = ctx()->addVars(numVars, Var_t::Atom, VarInfo::Nant | VarInfo::Input);
	auxVar_ = ctx()->addVars(numProd + numSoft, Var_t::Atom, VarInfo::Nant);
	endVar_ = auxVar_ + numProd + numSoft;
	ctx()->output.setVarRange(Range32(out, out + numVars));
	ctx()->startAddConstraints(numCons);
}
uint32 PBBuilder::getAuxVar() {
	CLASP_ASSERT_CONTRACT_MSG(ctx()->validVar(auxVar_), "Variables out of bounds");
	return auxVar_++;
}
bool PBBuilder::addConstraint(WeightLitVec& lits, weight_t bound, bool eq, weight_t cw) {
	if (!ctx()->ok()) { return false; }
	Var eqVar = 0;
	if (cw > 0) { // soft constraint
		if (lits.size() != 1) {
			eqVar = getAuxVar();
			addMinLit(0, WeightLiteral(negLit(eqVar), cw));
		}
		else {
			if (lits[0].second < 0)    { bound += (lits[0].second = -lits[0].second); lits[0].first = ~lits[0].first; }
			if (lits[0].second < bound){ lits[0].first = lit_false(); }
			addMinLit(0, WeightLiteral(~lits[0].first, cw));
			return true;
		}
	}
	return WeightConstraint::create(*ctx()->master(), posLit(eqVar), lits, bound, !eq ? 0 : WeightConstraint::create_eq_bound).ok();
}

bool PBBuilder::addObjective(const WeightLitVec& min) {
	for (WeightLitVec::const_iterator it = min.begin(), end = min.end(); it != end; ++it) {
		addMinLit(0, *it);
	}
	return ctx()->ok();
}
void PBBuilder::addProject(Var v) {
	ctx()->output.addProject(posLit(v));
}
void PBBuilder::addAssumption(Literal x) {
	assume_.push_back(x);
}
bool PBBuilder::setSoftBound(wsum_t b) {
	if (b > 0) { soft_ = b-1; }
	return true;
}

void PBBuilder::doGetWeakBounds(SumVec& out) const {
	if (soft_ != std::numeric_limits::max()) {
		if      (out.empty())   { out.push_back(soft_); }
		else if (out[0] > soft_){ out[0] = soft_; }
	}
}

Literal PBBuilder::addProduct(LitVec& lits) {
	if (!ctx()->ok()) { return lit_false(); }
	prod_.lits.reserve(lits.size() + 1);
	if (productSubsumed(lits, prod_)){
		return lits[0];
	}
	Literal& eq = products_[prod_];
	if (eq != lit_true()) {
		return eq;
	}
	eq = posLit(getAuxVar());
	addProductConstraints(eq, lits);
	return eq;
}
bool PBBuilder::productSubsumed(LitVec& lits, PKey& prod) {
	Literal last       = lit_true();
	LitVec::iterator j = lits.begin();
	Solver& s          = *ctx()->master();
	uint32  abst       = 0;
	prod.lits.assign(1, lit_true()); // room for abst
	for (LitVec::const_iterator it = lits.begin(), end = lits.end(); it != end; ++it) {
		if (s.isFalse(*it) || ~*it == last) { // product is always false
			lits.assign(1, lit_false());
			return true;
		}
		else if (last.var() > it->var()) { // not sorted - redo with sorted product
			std::sort(lits.begin(), lits.end());
			return productSubsumed(lits, prod);
		}
		else if (!s.isTrue(*it) && last != *it) {
			prod.lits.push_back(*it);
			abst += hashLit(*it);
			last  = *it;
			*j++  = last;
		}
	}
	prod.lits[0].rep() = abst;
	lits.erase(j, lits.end());
	if (lits.empty()) { lits.assign(1, lit_true()); }
	return lits.size() < 2;
}
void PBBuilder::addProductConstraints(Literal eqLit, LitVec& lits) {
	Solver& s = *ctx()->master();
	assert(s.value(eqLit.var()) == value_free);
	bool ok   = ctx()->ok();
	for (LitVec::iterator it = lits.begin(), end = lits.end(); it != end && ok; ++it) {
		assert(s.value(it->var()) == value_free);
		ok    = ctx()->addBinary(~eqLit, *it);
		*it   = ~*it;
	}
	lits.push_back(eqLit);
	if (ok) { ClauseCreator::create(s, lits, ClauseCreator::clause_no_prepare); }
}

bool PBBuilder::doStartProgram() {
	auxVar_ = ctx()->numVars() + 1;
	soft_   = std::numeric_limits::max();
	assume_.clear();
	return true;
}
bool PBBuilder::doEndProgram() {
	while (auxVar_ != endVar_) {
		if (!ctx()->addUnary(negLit(getAuxVar()))) { return false; }
	}
	markOutputVariables();
	return true;
}
ProgramParser* PBBuilder::doCreateParser() {
	return new SatParser(*this);
}
/////////////////////////////////////////////////////////////////////////////////////////
// class BasicProgramAdapter
/////////////////////////////////////////////////////////////////////////////////////////
BasicProgramAdapter::BasicProgramAdapter(ProgramBuilder& prg) : prg_(&prg), inc_(false) {
	int t = prg_->type();
	CLASP_FAIL_IF(t != Problem_t::Sat && t != Problem_t::Pb, "unknown program type");
}
void BasicProgramAdapter::initProgram(bool inc) { inc_ = inc; }
void BasicProgramAdapter::beginStep() { if (inc_ || prg_->frozen()) { prg_->updateProgram(); } }

void BasicProgramAdapter::rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, const Potassco::LitSpan& body) {
	using namespace Potassco;
	CLASP_FAIL_IF(ht != Head_t::Disjunctive || !empty(head), "unsupported rule type");
	if (prg_->type() == Problem_t::Sat) {
		clause_.clear();
		for (LitSpan::iterator it = begin(body), end = Potassco::end(body); it != end; ++it) { clause_.push_back(~toLit(*it)); }
		static_cast(*prg_).addClause(clause_);
	}
	else {
		constraint_.clear();
		for (LitSpan::iterator it = begin(body), end = Potassco::end(body); it != end; ++it) { constraint_.push_back(WeightLiteral(~toLit(*it), 1)); }
		static_cast(*prg_).addConstraint(constraint_, 1);
	}
}
void BasicProgramAdapter::rule(Potassco::Head_t ht, const Potassco::AtomSpan& head, Potassco::Weight_t bound, const Potassco::WeightLitSpan& body) {
	using namespace Potassco;
	CLASP_FAIL_IF(ht != Head_t::Disjunctive || !empty(head) || prg_->type() == Problem_t::Sat, "unsupported rule type");
	constraint_.clear();
	Potassco::Weight_t sum = 0;
	for (WeightLitSpan::iterator it = begin(body), end = Potassco::end(body); it != end; ++it) {
		constraint_.push_back(WeightLiteral(~toLit(it->lit), it->weight));
		sum += it->weight;
	}
	static_cast(*prg_).addConstraint(constraint_, (sum - bound) + 1);
}
void BasicProgramAdapter::minimize(Potassco::Weight_t prio, const Potassco::WeightLitSpan& lits) {
	CLASP_FAIL_IF(prio != 0 || prg_->type() == Problem_t::Sat, "unsupported rule type");
	using namespace Potassco;
	constraint_.clear();
	for (WeightLitSpan::iterator it = begin(lits), end = Potassco::end(lits); it != end; ++it) { constraint_.push_back(WeightLiteral(toLit(it->lit), it->weight)); }
	static_cast(*prg_).addObjective(constraint_);
}
}
clasp-3.2.2/libclasp/src/satelite.cpp000066400000000000000000000445561304134206100175260ustar00rootroot00000000000000//
// Copyright (c) 2006-2010, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 

namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// SatElite preprocessing
//
/////////////////////////////////////////////////////////////////////////////////////////
SatElite::SatElite()
	: occurs_(0)
	, elimHeap_(LessOccCost(occurs_))
	, qFront_(0)
	, facts_(0) {
}

SatElite::~SatElite() {
	SatElite::doCleanUp();
}

void SatElite::reportProgress(Progress::EventOp id, uint32 curr, uint32 max) {
	ctx_->report(Progress(this, id, curr, max));
}

Clasp::SatPreprocessor* SatElite::clone() {
	SatElite* cp = new SatElite();
	return cp;
}

void SatElite::doCleanUp() {
	delete [] occurs_;  occurs_ = 0;
	ClauseList().swap(resCands_);
	VarVec().swap(occT_[pos]);
	VarVec().swap(occT_[neg]);
	LitVec().swap(resolvent_);
	VarVec().swap(queue_);
	elimHeap_.clear();
	qFront_ = facts_ = 0;
}

SatPreprocessor::Clause* SatElite::popSubQueue() {
	if (Clause* c = clause( queue_[qFront_++] )) {
		c->setInQ(false);
		return c;
	}
	return 0;
}

void SatElite::addToSubQueue(uint32 clauseId) {
	assert(clause(clauseId) != 0);
	if (!clause(clauseId)->inQ()) {
		queue_.push_back(clauseId);
		clause(clauseId)->setInQ(true);
	}
}

void SatElite::attach(uint32 clauseId, bool initialClause) {
	Clause& c = *clause(clauseId);
	c.abstraction() = 0;
	for (uint32 i = 0; i != c.size(); ++i) {
		Var v = c[i].var();
		occurs_[v].add(clauseId, c[i].sign());
		occurs_[v].unmark();
		c.abstraction() |= Clause::abstractLit(c[i]);
		if (elimHeap_.is_in_queue(v)) {
			elimHeap_.decrease(v);
		}
		else if (initialClause) {
			updateHeap(v);
		}
	}
	occurs_[c[0].var()].addWatch(clauseId);
	addToSubQueue(clauseId);
	stats.clAdded += !initialClause;
}

void SatElite::detach(uint32 id) {
	Clause& c = *clause(id);
	occurs_[c[0].var()].removeWatch(id);
	for (uint32 i = 0; i != c.size(); ++i) {
		Var v = c[i].var();
		occurs_[v].remove(id, c[i].sign(), false);
		updateHeap(v);
	}
	destroyClause(id);
}

void SatElite::bceVeRemove(uint32 id, bool freeId, Var ev, bool blocked) {
	Clause& c  = *clause(id);
	occurs_[c[0].var()].removeWatch(id);
	uint32 pos = 0;
	for (uint32 i = 0; i != c.size(); ++i) {
		Var v = c[i].var();
		if (v != ev) {
			occurs_[v].remove(id, c[i].sign(), freeId);
			updateHeap(v);
		}
		else {
			occurs_[ev].remove(id, c[i].sign(), false);
			pos = i;
		}
	}
	std::swap(c[0], c[pos]);
	c.setMarked(blocked);
	eliminateClause(id);
}

bool SatElite::initPreprocess(Options& opts) {
	reportProgress(Progress::event_algorithm, 0,100);
	opts_     = &opts;
	occurs_   = new OccurList[ctx_->numVars()+1];
	qFront_   = 0;
	occurs_[0].bce = (opts.type == Options::sat_pre_full);
	return true;
}
bool SatElite::doPreprocess() {
	// 1. add clauses to occur lists
	for (uint32 i  = 0, end = numClauses(); i != end; ++i) {
		attach(i, true);
	}
	// 2. remove subsumed clauses, eliminate vars by clause distribution
	timeout_ = opts_->limTime ? time(0) + opts_->limTime : std::numeric_limits::max();
	for (uint32 i = 0, end = opts_->limIters ? opts_->limIters : UINT32_MAX; queue_.size()+elimHeap_.size() > 0; ++i) {
		if (!backwardSubsume())   { return false; }
		if (timeout() || i == end){ break;        }
		if (!eliminateVars())     { return false; }
	}
	reportProgress(Progress::event_algorithm, 100,100);
	return true;
}

// (Destructive) unit propagation on clauses.
// Removes satisfied clauses and shortens clauses w.r.t. false literals.
// Pre:   Assignment is propagated w.r.t other non-clause constraints
// Post:  Assignment is fully propagated and no clause contains an assigned literal
bool SatElite::propagateFacts() {
	Solver* s = ctx_->master();
	assert(s->queueSize() == 0);
	while (facts_ != s->numAssignedVars()) {
		Literal l     = s->trail()[facts_++];
		OccurList& ov = occurs_[l.var()];
		ClRange cls   = occurs_[l.var()].clauseRange();
		for (ClIter x = cls.first; x != cls.second; ++x) {
			if      (clause(x->var()) == 0)          { continue; }
			else if (x->sign() == l.sign())          { detach(x->var()); }
			else if (!strengthenClause(x->var(), ~l)){ return false; }
		}
		ov.clear();
		ov.mark(!l.sign());
	}
	assert(s->queueSize() == 0);
	return true;
}

// Backward subsumption and self-subsumption resolution until fixpoint
bool SatElite::backwardSubsume() {
	if (!propagateFacts()) return false;
	while (qFront_ != queue_.size()) {
		if ((qFront_ & 8191) == 0) {
			if (timeout()) break;
			if (queue_.size() > 1000) reportProgress(Progress::event_subsumption, qFront_, queue_.size());
		}
		if (peekSubQueue() == 0) { ++qFront_; continue; }
		Clause& c = *popSubQueue();
		// Try to minimize effort by testing against the var in c that occurs least often;
		Literal best = c[0];
		for (uint32 i = 1; i < c.size(); ++i) {
			if (occurs_[c[i].var()].numOcc() < occurs_[best.var()].numOcc()) {
				best  = c[i];
			}
		}
		// Test against all clauses containing best
		ClWList& cls = occurs_[best.var()].refs;
		Literal res  = lit_false();
		uint32  j    = 0;
		// must use index access because cls might change!
		for (uint32 i = 0, end = cls.left_size(); i != end; ++i) {
			Literal cl     = cls.left(i);
			uint32 otherId = cl.var();
			Clause* other  = clause(otherId);
			if (other && other!= &c && (res = subsumes(c, *other, best.sign()==cl.sign()?lit_true():best)) != lit_false()) {
				if (res == lit_true()) {
					// other is subsumed - remove it
					detach(otherId);
					other = 0;
				}
				else {
					// self-subsumption resolution; other is subsumed by c\{res} U {~res}
					// remove ~res from other, add it to subQ so that we can check if it now subsumes c
					res = ~res;
					occurs_[res.var()].remove(otherId, res.sign(), res.var() != best.var());
					updateHeap(res.var());
					if (!strengthenClause(otherId, res))              { return false; }
					if (res.var() == best.var() || !clause(otherId))  { other = 0; }
				}
			}
			if (other && j++ != i)  { cls.left(j-1) = cl; }
		}
		cls.shrink_left(cls.left_begin()+j);
		occurs_[best.var()].dirty = 0;
		assert(occurs_[best.var()].numOcc() == (uint32)cls.left_size());
		if (!propagateFacts()) return false;
	}
	queue_.clear();
	qFront_ = 0;
	return true;
}

// checks if 'c' subsumes 'other', and at the same time, if it can be used to
// simplify 'other' by subsumption resolution.
// Return:
//  - lit_false() - No subsumption or simplification
//  - lit_true() - 'c' subsumes 'other'
//  - l         - The literal l can be deleted from 'other'
Literal SatElite::subsumes(const Clause& c, const Clause& other, Literal res) const {
	if (other.size() < c.size() || (c.abstraction() & ~other.abstraction()) != 0) {
		return lit_false();
	}
	if (c.size() < 10 || other.size() < 10) {
		for (uint32 i = 0; i != c.size(); ++i) {
			for (uint32 j = 0; j != other.size(); ++j) {
				if (c[i].var() == other[j].var()) {
					if (c[i].sign() == other[j].sign())     { goto found; }
					else if (res != lit_true() && res!=c[i]) { return lit_false(); }
					res = c[i];
					goto found;
				}
			}
			return lit_false();
		found:;
		}
	}
	else {
		markAll(&other[0], other.size());
		for (uint32 i = 0; i != c.size(); ++i) {
			if (occurs_[c[i].var()].litMark == 0) { res = lit_false(); break; }
			if (occurs_[c[i].var()].marked(!c[i].sign())) {
				if (res != lit_true()&&res!=c[i]) { res = lit_false(); break; }
				res = c[i];
			}
		}
		unmarkAll(&other[0], other.size());
	}
	return res;
}

uint32 SatElite::findUnmarkedLit(const Clause& c, uint32 x) const {
	for (; x != c.size() && occurs_[c[x].var()].marked(c[x].sign()); ++x)
		;
	return x;
}

// checks if 'cl' is subsumed by one of the existing clauses and at the same time
// strengthens 'cl' if possible.
// Return:
//  - true  - 'cl' is subsumed
//  - false - 'cl' is not subsumed but may itself subsume other clauses
// Pre: All literals of l are marked, i.e.
// for each literal l in cl, occurs_[l.var()].marked(l.sign()) == true
bool SatElite::subsumed(LitVec& cl) {
	Literal l;
	uint32 x = 0;
	uint32 str = 0;
	LitVec::size_type j = 0;
	for (LitVec::size_type i = 0; i != cl.size(); ++i) {
		l = cl[i];
		if (occurs_[l.var()].litMark == 0) { --str; continue; }
		ClWList& cls   = occurs_[l.var()].refs; // right: all clauses watching either l or ~l
		WIter wj       = cls.right_begin();
		for (WIter w = wj, end = cls.right_end(); w != end; ++w) {
			Clause& c = *clause(*w);
			if (c[0] == l)  {
				if ( (x = findUnmarkedLit(c, 1)) == c.size() ) {
					while (w != end) { *wj++ = *w++; }
					cls.shrink_right( wj );
					return true;
				}
				c[0] = c[x];
				c[x] = l;
				occurs_[c[0].var()].addWatch(*w);
				if (occurs_[c[0].var()].litMark != 0 && findUnmarkedLit(c, x+1) == c.size()) {
					occurs_[c[0].var()].unmark();  // no longer part of cl
					++str;
				}
			}
			else if ( findUnmarkedLit(c, 1) == c.size() ) {
				occurs_[l.var()].unmark(); // no longer part of cl
				while (w != end) { *wj++ = *w++; }
				cls.shrink_right( wj );
				goto removeLit;
			}
			else { *wj++ = *w; }
		}
		cls.shrink_right(wj);
		if (j++ != i) { cl[j-1] = cl[i]; }
removeLit:;
	}
	cl.erase(cl.begin()+j, cl.end());
	if (str > 0) {
		for (LitVec::size_type i = 0; i != cl.size();) {
			if (occurs_[cl[i].var()].litMark == 0) {
				cl[i] = cl.back();
				cl.pop_back();
				if (--str == 0) break;
			}
			else { ++i; }
		}
	}
	return false;
}

// Pre: c contains l
// Pre: c was already removed from l's occur-list
bool SatElite::strengthenClause(uint32 clauseId, Literal l) {
	Clause& c = *clause(clauseId);
	if (c[0] == l) {
		occurs_[c[0].var()].removeWatch(clauseId);
		// Note: Clause::strengthen shifts literals after l to the left. Thus
		// c[1] will be c[0] after strengthen
		occurs_[c[1].var()].addWatch(clauseId);
	}
	++stats.litsRemoved;
	c.strengthen(l);
	if (c.size() == 1) {
		Literal unit = c[0];
		detach(clauseId);
		return ctx_->addUnary(unit) && ctx_->master()->propagate();
	}
	addToSubQueue(clauseId);
	return true;
}

// Split occurrences of v into pos and neg and
// mark all clauses containing v
SatElite::ClRange SatElite::splitOcc(Var v, bool mark) {
	ClRange cls      = occurs_[v].clauseRange();
	occurs_[v].dirty = 0;
	occT_[pos].clear(); occT_[neg].clear();
	ClIter j = cls.first;
	for (ClIter x = j; x != cls.second; ++x) {
		if (Clause* c = clause(x->var())) {
			assert(c->marked() == false);
			c->setMarked(mark);
			int sign = (int)x->sign();
			occT_[sign].push_back(x->var());
			if (j != x) *j = *x;
			++j;
		}
	}
	occurs_[v].refs.shrink_left(j);
	return occurs_[v].clauseRange();
}

void SatElite::markAll(const Literal* lits, uint32 size) const {
	for (uint32 i = 0; i != size; ++i) {
		occurs_[lits[i].var()].mark(lits[i].sign());
	}
}
void SatElite::unmarkAll(const Literal* lits, uint32 size) const {
	for (uint32 i = 0; i != size; ++i) {
		occurs_[lits[i].var()].unmark();
	}
}

// Run variable and/or blocked clause elimination on var v.
// If the number of non-trivial resolvents is <= maxCnt,
// v is eliminated by clause distribution. If bce is enabled,
// clauses blocked on a literal of v are removed.
bool SatElite::bceVe(Var v, uint32 maxCnt) {
	Solver* s = ctx_->master();
	if (s->value(v) != value_free) return true;
	assert(!ctx_->varInfo(v).frozen() && !ctx_->eliminated(v));
	resCands_.clear();
	// distribute clauses on v
	// check if number of clauses decreases if we'd eliminate v
	uint32 bce     = opts_->bce();
	ClRange cls    = splitOcc(v, bce > 1);
	uint32 cnt     = 0;
	uint32 markMax = ((uint32)occT_[neg].size() * (bce>1));
	uint32 blocked = 0;
	bool stop      = false;
	Clause* lhs, *rhs;
	for (VarVec::const_iterator i = occT_[pos].begin(); i != occT_[pos].end() && !stop; ++i) {
		lhs         = clause(*i);
		markAll(&(*lhs)[0], lhs->size());
		lhs->setMarked(bce != 0);
		for (VarVec::const_iterator j = occT_[neg].begin(); j != occT_[neg].end(); ++j) {
			if (!trivialResolvent(*(rhs = clause(*j)), v)) {
				markMax -= rhs->marked();
				rhs->setMarked(false); // not blocked on v
				lhs->setMarked(false); // not blocked on v
				if (++cnt <= maxCnt) {
					resCands_.push_back(lhs);
					resCands_.push_back(rhs);
				}
				else if (!markMax) {
					stop = (bce == 0);
					break;
				}
			}
		}
		unmarkAll(&(*lhs)[0], lhs->size());
		if (lhs->marked()) {
			occT_[pos][blocked++] = *i;
		}
	}
	if (cnt <= maxCnt) {
		// eliminate v by clause distribution
		ctx_->eliminate(v);  // mark var as eliminated
		// remove old clauses, store them in the elimination table so that
		// (partial) models can be extended.
		for (ClIter it = cls.first; it != cls.second; ++it) {
			// reuse first cnt ids for resolvents
			if (clause(it->var())) {
				bool freeId = (cnt && cnt--);
				bceVeRemove(it->var(), freeId, v, false);
			}
		}
		// add non trivial resolvents
		assert( resCands_.size() % 2 == 0 );
		ClIter it = cls.first;
		for (VarVec::size_type i = 0; i != resCands_.size(); i+=2, ++it) {
			if (!addResolvent(it->var(), *resCands_[i], *resCands_[i+1])) {
				return false;
			}
		}
		assert(occurs_[v].numOcc() == 0);
		// release memory
		occurs_[v].clear();
	}
	else if ( (blocked + markMax) > 0 ) {
		// remove blocked clauses
		for (uint32 i = 0; i != blocked; ++i) {
			bceVeRemove(occT_[pos][i], false, v, true);
		}
		for (VarVec::const_iterator it = occT_[neg].begin(); markMax; ++it) {
			if ( (rhs = clause(*it))->marked() ) {
				bceVeRemove(*it, false, v, true);
				--markMax;
			}
		}
	}
	return opts_->limIters != 0 || backwardSubsume();
}

bool SatElite::bce() {
	uint32 ops = 0;
	for (ClWList& bce= occurs_[0].refs; bce.right_size() != 0; ++ops) {
		Var v          = *(bce.right_end()-1);
		bce.pop_right();
		occurs_[v].bce=0;
		if ((ops & 1023) == 0)   {
			if (timeout())         { bce.clear(); return true; }
			if ((ops & 8191) == 0) { reportProgress(Progress::event_bce, ops, 1+bce.size()); }
		}
		if (!cutoff(v) && !bceVe(v, 0)) { return false; }
	}
	return true;
}

bool SatElite::eliminateVars() {
	Var     v          = 0;
	uint32  occ        = 0;
	if (!bce()) return false;
	for (uint32 ops = 0; !elimHeap_.empty(); ++ops) {
		v   = elimHeap_.top();  elimHeap_.pop();
		occ = occurs_[v].numOcc();
		if ((ops & 1023) == 0)   {
			if (timeout())         { elimHeap_.clear(); return true; }
			if ((ops & 8191) == 0) { reportProgress(Progress::event_var_elim, ops, 1+elimHeap_.size()); }
		}
		if (!cutoff(v) && !bceVe(v, occ)) {
			return false;
		}
	}
	return opts_->limIters != 0 || bce();
}

// returns true if the result of resolving c1 (implicitly given) and c2 on v yields a tautologous clause
bool SatElite::trivialResolvent(const Clause& c2, Var v) const {
	for (uint32 i = 0, end = c2.size(); i != end; ++i) {
		Literal x = c2[i];
		if (occurs_[x.var()].marked(!x.sign()) && x.var() != v) {
			return true;
		}
	}
	return false;
}

// Pre: lhs and rhs can be resolved on lhs[0].var()
// Pre: trivialResolvent(lhs, rhs, lhs[0].var()) == false
bool SatElite::addResolvent(uint32 id, const Clause& lhs, const Clause& rhs) {
	resolvent_.clear();
	Solver* s = ctx_->master();
	assert(lhs[0] == ~rhs[0]);
	uint32 i, end;
	Literal l;
	for (i = 1, end = lhs.size(); i != end; ++i) {
		l = lhs[i];
		if (!s->isFalse(l)) {
			if (s->isTrue(l)) goto unmark;
			occurs_[l.var()].mark(l.sign());
			resolvent_.push_back(l);
		}
	}
	for (i = 1, end = rhs.size(); i != end; ++i) {
		l = rhs[i];
		if (!s->isFalse(l) && !occurs_[l.var()].marked(l.sign())) {
			if (s->isTrue(l)) goto unmark;
			occurs_[l.var()].mark(l.sign());
			resolvent_.push_back(l);
		}
	}
	if (!subsumed(resolvent_))  {
		if (resolvent_.empty())   {
			return s->force(negLit(0));
		}
		if (resolvent_.size()==1) {
			occurs_[resolvent_[0].var()].unmark();
			return s->force(resolvent_[0]) && s->propagate() && propagateFacts();
		}
		setClause(id, resolvent_);
		attach(id, false);
		return true;
	}
unmark:
	if (!resolvent_.empty()) {
		unmarkAll(&resolvent_[0], resolvent_.size());
	}
	return true;
}

// extends the model given in assign by the vars that were eliminated
void SatElite::doExtendModel(ValueVec& m, LitVec& unconstr) {
	if (!elimTop_) return;
	const ValueRep value_eliminated = 4u;
	// compute values of eliminated vars / blocked literals by "unit propagating"
	// eliminated/blocked clauses in reverse order
	uint32 uv = 0;
	uint32 us = unconstr.size();
	Clause* r = elimTop_;
	do {
		Literal x  = (*r)[0];
		Var last   = x.var();
		bool check = true;
		if (!r->marked()) {
			// eliminated var - compute the implied value
			m[last] = value_eliminated;
		}
		if (uv != us && unconstr[uv].var() == last) {
			// last is unconstraint w.r.t the current model -
			// set remembered value
			check   = false;
			m[last] = trueValue(unconstr[uv]);
			++uv;
		}
		do {
			Clause& c = *r;
			if (m[x.var()] != trueValue(x) && check) {
				for (uint32 i = 1, end = c.size(); i != end; ++i) {
					ValueRep vi = m[c[i].var()] & 3u;
					if (vi != falseValue(c[i])) {
						x = c[i];
						break;
					}
				}
				if (x == c[0]) {
					// all lits != x are false
					// clause is unit or conflicting
					assert(c.marked() || m[x.var()] != falseValue(x));
					m[x.var()] = trueValue(x);
					check      = false;
				}
			}
			r = r->next();
		} while (r && (x = (*r)[0]).var() == last);
		if (m[last] == value_eliminated) {
			// last seems unconstraint w.r.t the model
			m[last] |= value_true;
			unconstr.push_back(posLit(last));
		}
	} while (r);
	// check whether newly added unconstraint vars are really unconstraint w.r.t the model
	// or if they are implied by some blocked clause.
	LitVec::iterator j = unconstr.begin()+us;
	for (LitVec::iterator it = j, end = unconstr.end(); it != end; ++it) {
		if ((m[it->var()] & value_eliminated) != 0) {
			// var is unconstraint - assign to true and remember it
			// so that we can later enumerate the model containing ~var
			m[it->var()] = value_true;
			*j++ = *it;
		}
	}
	unconstr.erase(j, unconstr.end());
}
SatPreprocessor* SatPreParams::create(const SatPreParams& opts) {
	if (opts.type != 0) { return new SatElite(); }
	return 0;
}
}
clasp-3.2.2/libclasp/src/shared_context.cpp000066400000000000000000001121641304134206100207150ustar00rootroot00000000000000//
// Copyright (c) 2010-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#if WITH_THREADS
#include 
#endif
namespace Clasp {
#define PS_STATS( APPLY ) \
	APPLY(vars               , VALUE(vars.num))            \
	APPLY(vars_eliminated    , VALUE(vars.eliminated))     \
	APPLY(vars_frozen        , VALUE(vars.frozen))         \
	APPLY(constraints        , VALUE(constraints.other))   \
	APPLY(constraints_binary , VALUE(constraints.binary))  \
	APPLY(constraints_ternary, VALUE(constraints.ternary)) \
	APPLY(acyc_edges         , VALUE(acycEdges))           \
	APPLY(complexity         , VALUE(complexity))

static const char* const stats_s[] = {
#define KEY(X,Y) #X,
	PS_STATS(KEY)
#undef KEY
	"ctx"
};
uint32 ProblemStats::size()             { return (sizeof(stats_s)/sizeof(stats_s[0])) - 1; }
const char* ProblemStats::key(uint32 i) { return i < size() ? stats_s[i] : throw std::out_of_range("ProblemStats::key"); }
StatisticObject ProblemStats::at(const char* key) const {
#define VALUE(X) StatisticObject::value(&X)
#define APPLY(x, y) if (std::strcmp(key, #x) == 0) return y;
	PS_STATS(APPLY)
	throw std::out_of_range("ProblemStats::at");
#undef VALUE
#undef APPLY
}
#undef PS_STATS
/////////////////////////////////////////////////////////////////////////////////////////
// EventHandler
/////////////////////////////////////////////////////////////////////////////////////////
uint32 Event::nextId() { static uint32 id = 0; return id++; }
EventHandler::EventHandler(Event::Verbosity verbosity) : verb_(0), sys_(0){
	if (uint32 x = verbosity) {
		uint32 r = (x | (x<<4) | (x<<8) | (x<<12));
		verb_ = static_cast(r);
	}
}
EventHandler::~EventHandler() {}
void EventHandler::setVerbosity(Event::Subsystem sys, Event::Verbosity verb) {
	uint32 s = (uint32(sys)<(r);
}
bool EventHandler::setActive(Event::Subsystem sys) {
	if (sys == static_cast(sys_)) { return false; }
	sys_ = static_cast(sys);
	return true;
}
Event::Subsystem EventHandler::active() const {
	return static_cast(sys_);
}
/////////////////////////////////////////////////////////////////////////////////////////
// ShortImplicationsGraph::ImplicationList
/////////////////////////////////////////////////////////////////////////////////////////
#if WITH_THREADS
ShortImplicationsGraph::Block::Block() {
	for (int i = 0; i != block_cap; ++i) { data[i] = lit_true(); }
	size_lock = 0;
	next      = 0;
}
void ShortImplicationsGraph::Block::addUnlock(uint32 lockedSize, const Literal* x, uint32 xs) {
	std::copy(x, x+xs, data+lockedSize);
	size_lock = ((lockedSize+xs) << 1);
}
bool ShortImplicationsGraph::Block::tryLock(uint32& size) {
	uint32 s = size_lock;
	if ((s & 1) == 0 && size_lock.compare_and_swap(s | 1, s) == s) {
		size = s >> 1;
		return true;
	}
	return false;
}

#define FOR_EACH_LEARNT(x, Y) \
	for (Block* b = (x).learnt; b ; b = b->next) \
		for (const Literal* Y = b->begin(), *endof = b->end(); Y != endof; Y += 2 - Y->flagged())


ShortImplicationsGraph::ImplicationList::~ImplicationList() {
	clear(true);
}

void ShortImplicationsGraph::ImplicationList::clear(bool b) {
	ImpListBase::clear(b);
	for (Block* x = learnt; x; ) {
		Block* t = x;
		x = x->next;
		delete t;
	}
	learnt = 0;
}
void ShortImplicationsGraph::ImplicationList::simplifyLearnt(const Solver& s) {
	Block* x = learnt;
	learnt   = 0;
	while (x) {
		for (const Literal* Y = x->begin(), *endof = x->end(); Y != endof; Y += 2 - Y->flagged()) {
			Literal p = Y[0], q = !Y->flagged() ? Y[1] : lit_false();
			if (!s.isTrue(p) && !s.isTrue(q)) {
				addLearnt(p, q);
			}
		}
		Block* t = x;
		x = x->next;
		delete t;
	}
}
void ShortImplicationsGraph::ImplicationList::addLearnt(Literal p, Literal q) {
	Literal nc[2] = {p, q};
	uint32  ns    = 1 + !isSentinel(q);
	if (ns == 1) { nc[0].flag(); }
	for (Block* x;;) {
		x = learnt;
		if (x) {
			uint32 lockedSize;
			if (x->tryLock(lockedSize)) {
				if ( (lockedSize + ns) <=  Block::block_cap ) {
					x->addUnlock(lockedSize, nc, ns);
				}
				else {
					Block* t = new Block();
					t->addUnlock(0, nc, ns);
					t->next   = x; // x is full and remains locked forever
					x = learnt= t; // publish new block - unlocks x and learnt
				}
				return;
			}
			else {
				Clasp::mt::this_thread::yield();
			}
		}
		else {
			x = new Block();
			if (learnt.compare_and_swap(x, 0) != 0) {
				delete x;
			}
		}
	}
}

bool ShortImplicationsGraph::ImplicationList::hasLearnt(Literal q, Literal r) const {
	const bool binary = isSentinel(r);
	FOR_EACH_LEARNT(*this, imp) {
		if (imp[0] == q || imp[0] == r) {
			// binary clause subsumes new bin/tern clause
			if (imp->flagged())                          { return true; }
			// existing ternary clause subsumes new tern clause
			if (!binary && (imp[1] == q || imp[1] == r)) { return true; }
		}
	}
	return false;
}

void ShortImplicationsGraph::ImplicationList::move(ImplicationList& other) {
	ImpListBase::move(other);
	delete static_cast(learnt);
	learnt = static_cast(other.learnt);
	other.learnt = 0;
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////
// ShortImplicationsGraph
/////////////////////////////////////////////////////////////////////////////////////////
ShortImplicationsGraph::ShortImplicationsGraph() {
	bin_[0]  = bin_[1]  = 0;
	tern_[0] = tern_[1] = 0;
	shared_  = false;
}
ShortImplicationsGraph::~ShortImplicationsGraph() {
	PodVector::destruct(graph_);
}
void ShortImplicationsGraph::resize(uint32 nodes) {
	if (nodes <= graph_.size()) {
		while (graph_.size() != nodes) {
			graph_.back().clear(true);
			graph_.pop_back();
		}
	}
	else if (graph_.capacity() >= nodes) {
		graph_.resize(nodes);
	}
	else {
		ImpLists temp; temp.resize(nodes);
		for (ImpLists::size_type i = 0; i != graph_.size(); ++i) {
			temp[i].move(graph_[i]);
		}
		graph_.swap(temp);
	}
}

uint32 ShortImplicationsGraph::numEdges(Literal p) const { return graph_[p.id()].size(); }

bool ShortImplicationsGraph::add(ImpType t, bool learnt, const Literal* lits) {
	uint32& stats= (t == ternary_imp ? tern_ : bin_)[learnt];
	Literal p = lits[0], q = lits[1], r = (t == ternary_imp ? lits[2] : lit_false());
	p.unflag(), q.unflag(), r.unflag();
	if (!shared_) {
		if (learnt) { p.flag(), q.flag(), r.flag(); }
		if (t == binary_imp) {
			getList(~p).push_left(q);
			getList(~q).push_left(p);
		}
		else {
			getList(~p).push_right(std::make_pair(q, r));
			getList(~q).push_right(std::make_pair(p, r));
			getList(~r).push_right(std::make_pair(p, q));
		}
		++stats;
		return true;
	}
#if WITH_THREADS
	else if (learnt && !getList(~p).hasLearnt(q, r)) {
		getList(~p).addLearnt(q, r);
		getList(~q).addLearnt(p, r);
		if (t == ternary_imp) {
			getList(~r).addLearnt(p, q);
		}
		++stats;
		return true;
	}
#endif
	return false;
}

void ShortImplicationsGraph::remove_bin(ImplicationList& w, Literal p) {
	w.erase_left_unordered(std::find(w.left_begin(), w.left_end(), p));
	w.try_shrink();
}
void ShortImplicationsGraph::remove_tern(ImplicationList& w, Literal p) {
	w.erase_right_unordered(std::find_if(w.right_begin(), w.right_end(), PairContains(p)));
	w.try_shrink();
}

// Removes all binary clauses containing p - those are now SAT.
// Binary clauses containing ~p are unit and therefore likewise SAT. Those
// are removed when their second literal is processed.
//
// Ternary clauses containing p are SAT and therefore removed.
// Ternary clauses containing ~p are now either binary or SAT. Those that
// are SAT are removed when the satisfied literal is processed.
// All conditional binary-clauses are replaced with real binary clauses.
// Note: clauses containing p watch ~p. Those containing ~p watch p.
void ShortImplicationsGraph::removeTrue(const Solver& s, Literal p) {
	assert(!shared_);
	typedef ImplicationList SWL;
	SWL& negPList = graph_[(~p).id()];
	SWL& pList    = graph_[ (p).id()];
	// remove every binary clause containing p -> clause is satisfied
	for (SWL::left_iterator it = negPList.left_begin(), end = negPList.left_end(); it != end; ++it) {
		--bin_[it->flagged()];
		remove_bin(graph_[(~*it).id()], p);
	}
	// remove every ternary clause containing p -> clause is satisfied
	for (SWL::right_iterator it = negPList.right_begin(), end = negPList.right_end(); it != end; ++it) {
		--tern_[it->first.flagged()];
		remove_tern(graph_[ (~it->first).id() ], p);
		remove_tern(graph_[ (~it->second).id() ], p);
	}
#if WITH_THREADS
	FOR_EACH_LEARNT(negPList, imp) {
		graph_[(~imp[0]).id()].simplifyLearnt(s);
		if (!imp->flagged()){
			--tern_[1];
			graph_[(~imp[1]).id()].simplifyLearnt(s);
		}
		if (imp->flagged()) { --bin_[1]; }
	}
#endif
	// transform ternary clauses containing ~p to binary clause
	for (SWL::right_iterator it = pList.right_begin(), end = pList.right_end(); it != end; ++it) {
		Literal q = it->first;
		Literal r = it->second;
		--tern_[q.flagged()];
		remove_tern(graph_[(~q).id()], ~p);
		remove_tern(graph_[(~r).id()], ~p);
		if (s.value(q.var()) == value_free && s.value(r.var()) == value_free) {
			// clause is binary on dl 0
			Literal imp[2] = {q,r};
			add(binary_imp, false, imp);
		}
		// else: clause is SAT and removed when the satisfied literal is processed
	}
	graph_[(~p).id()].clear(true);
	graph_[ (p).id()].clear(true);
}
#undef FOR_EACH_LEARNT
struct ShortImplicationsGraph::Propagate {
	Propagate(Solver& a_s) : s(&a_s) {}
	bool unary(Literal p, Literal x) const { return s->isTrue(x) || s->force(x, Antecedent(p)); }
	bool binary(Literal p, Literal x, Literal y) const {
		ValueRep vx = s->value(x.var()), vy;
		if (vx != trueValue(x) && (vy=s->value(y.var())) != trueValue(y) && vx + vy) {
			return vx != 0 ? s->force(y, Antecedent(p, ~x)) : s->force(x, Antecedent(p, ~y));
		}
		return true;
	}
	Solver* s;
};
struct ShortImplicationsGraph::ReverseArc {
	ReverseArc(const Solver& a_s, uint32 m, Antecedent& o) : s(&a_s), out(&o), maxL(m) {}
	bool unary(Literal, Literal x) const {
		if (!isRevLit(*s, x, maxL)) { return true; }
		*out = Antecedent(~x);
		return false;
	}
	bool binary(Literal, Literal x, Literal y) const {
		if (!isRevLit(*s, x, maxL) || !isRevLit(*s, y, maxL)) { return true; }
		*out = Antecedent(~x, ~y);
		return false;
	}
	const Solver* s; Antecedent* out; uint32 maxL;
};
bool ShortImplicationsGraph::propagate(Solver& s, Literal p) const { return forEach(p, Propagate(s)); }
bool ShortImplicationsGraph::reverseArc(const Solver& s, Literal p, uint32 maxLev, Antecedent& out) const { return !forEach(p, ReverseArc(s, maxLev, out)); }
bool ShortImplicationsGraph::propagateBin(Assignment& out, Literal p, uint32 level) const {
	const ImplicationList& x = graph_[p.id()];
	Antecedent ante(p);
	for (ImplicationList::const_left_iterator it = x.left_begin(), end = x.left_end(); it != end; ++it) {
		if (!out.assign(*it, level, p)) { return false; }
	}
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// SatPreprocessor
/////////////////////////////////////////////////////////////////////////////////////////
SatPreprocessor::SatPreprocessor() : ctx_(0), opts_(0), elimTop_(0), seen_(1,1) {}
SatPreprocessor::~SatPreprocessor() {
	discardClauses(true);
}
void SatPreprocessor::discardClauses(bool full) {
	for (ClauseList::size_type i = 0; i != clauses_.size(); ++i) {
		if (clauses_[i]) { clauses_[i]->destroy(); }
	}
	ClauseList().swap(clauses_);
	if (Clause* r = (full ? elimTop_ : 0)) {
		do {
			Clause* t = r;
			 r = r->next();
			 t->destroy();
		} while (r);
		elimTop_ = 0;
	}
	if (full) { seen_ = Range32(1,1); }
}
void SatPreprocessor::cleanUp(bool full) {
	if (ctx_) { seen_.hi = ctx_->numVars() + 1; }
	doCleanUp();
	discardClauses(full);
}

bool SatPreprocessor::addClause(const Literal* lits, uint32 size) {
	if (size > 1) {
		clauses_.push_back( Clause::newClause(lits, size) );
	}
	else if (size == 1) {
		units_.push_back(lits[0]);
	}
	else {
		return false;
	}
	return true;
}

void SatPreprocessor::freezeSeen() {
	if (!ctx_->validVar(seen_.lo)) { seen_.lo = 1; }
	if (!ctx_->validVar(seen_.hi)) { seen_.hi = ctx_->numVars() + 1; }
	for (Var v = seen_.lo; v != seen_.hi; ++v) {
		if (!ctx_->eliminated(v)) { ctx_->setFrozen(v, true); }
	}
	seen_.lo = seen_.hi;
}

bool SatPreprocessor::preprocess(SharedContext& ctx, Options& opts) {
	ctx_  = &ctx;
	opts_ = &opts;
	Solver* s = ctx_->master();
	struct OnExit {
		SharedContext*   ctx;
		SatPreprocessor* self;
		SatPreprocessor* rest;
		OnExit(SatPreprocessor* s, SharedContext* c) : ctx(c), self(s), rest(0) {
			if (ctx && ctx->satPrepro.get() == s) { rest = ctx->satPrepro.release(); }
		}
		~OnExit() {
			if (self) self->cleanUp();
			if (rest) ctx->satPrepro.reset(rest);
		}
	} onExit(this, &ctx);
	for (LitVec::const_iterator it = units_.begin(), end = units_.end(); it != end; ++it) {
		if (!ctx.addUnary(*it)) return false;
	}
	units_.clear();
	// skip preprocessing if other constraints are UNSAT
	if (!s->propagate()) return false;
	if (ctx.preserveModels()) {
		opts.disableBce();
	}
	if (ctx.preserveShown()) {
		for (OutputTable::pred_iterator it = ctx.output.pred_begin(), end = ctx.output.pred_end(); it != end; ++it) {
			ctx.setFrozen(it->cond.var(), true);
		}
		for (OutputTable::range_iterator it = ctx.output.vars_begin(), end = ctx.output.vars_end(); it != end; ++it) {
			ctx.setFrozen(*it, true);
		}
	}
	// preprocess only if not too many vars are frozen or not too many clauses
	bool limFrozen = false;
	if (opts.limFrozen != 0 && ctx_->stats().vars.frozen) {
		uint32 varFrozen = ctx_->stats().vars.frozen;
		for (LitVec::const_iterator it = s->trail().begin(), end = s->trail().end(); it != end; ++it) {
 			varFrozen -= (ctx_->varInfo(it->var()).frozen());
 		}
		limFrozen = ((varFrozen / double(s->numFreeVars())) * 100.0) > double(opts.limFrozen);
	}
	// 1. remove SAT-clauses, strengthen clauses w.r.t false literals, attach
	if (opts.type != 0 && !opts.clauseLimit(numClauses()) && !limFrozen && initPreprocess(opts)) {
		ClauseList::size_type j = 0;
		for (ClauseList::size_type i = 0; i != clauses_.size(); ++i) {
			Clause* c   = clauses_[i]; assert(c);
			clauses_[i] = 0;
			c->simplify(*s);
			Literal x   = (*c)[0];
			if (s->value(x.var()) == value_free) {
				clauses_[j++] = c;
			}
			else {
				c->destroy();
				if (!ctx.addUnary(x)) { return false; }
			}
		}
		clauses_.erase(clauses_.begin()+j, clauses_.end());
		// 2. run preprocessing
		freezeSeen();
		if (!s->propagate() || !doPreprocess()) {
			return false;
		}
	}
	// simplify other constraints w.r.t any newly derived top-level facts
	if (!s->simplify()) return false;
	// 3. move preprocessed clauses to ctx
	for (ClauseList::size_type i = 0; i != clauses_.size(); ++i) {
		if (Clause* c = clauses_[i]) {
			if (!ClauseCreator::create(*s, ClauseRep::create(&(*c)[0], c->size()), 0)) {
				return false;
			}
			clauses_[i] = 0;
			c->destroy();
		}
	}
	ClauseList().swap(clauses_);
	return true;
}
bool SatPreprocessor::preprocess(SharedContext& ctx) {
	SatPreParams opts = ctx.configuration()->context().satPre;
	return preprocess(ctx, opts);
}
void SatPreprocessor::extendModel(ValueVec& m, LitVec& open) {
	if (!open.empty()) {
		// flip last unconstraint variable to get "next" model
		open.back() = ~open.back();
	}
	doExtendModel(m, open);
	// remove unconstraint vars already flipped
	while (!open.empty() && open.back().sign()) {
		open.pop_back();
	}
}
SatPreprocessor::Clause* SatPreprocessor::Clause::newClause(const Literal* lits, uint32 size) {
	assert(size > 0);
	void* mem = ::operator new( sizeof(Clause) + (size-1)*sizeof(Literal) );
	return new (mem) Clause(lits, size);
}
SatPreprocessor::Clause::Clause(const Literal* lits, uint32 size) : size_(size), inQ_(0), marked_(0) {
	std::memcpy(lits_, lits, size*sizeof(Literal));
}
void SatPreprocessor::Clause::strengthen(Literal p) {
	uint64 a = 0;
	uint32 i, end;
	for (i   = 0; lits_[i] != p; ++i) { a |= Clause::abstractLit(lits_[i]); }
	for (end = size_-1; i < end; ++i) { lits_[i] = lits_[i+1]; a |= Clause::abstractLit(lits_[i]); }
	--size_;
	data_.abstr = a;
}
void SatPreprocessor::Clause::simplify(Solver& s) {
	uint32 i;
	for (i = 0; i != size_ && s.value(lits_[i].var()) == value_free; ++i) {;}
	if      (i == size_)        { return; }
	else if (s.isTrue(lits_[i])){ std::swap(lits_[i], lits_[0]); return;  }
	uint32 j = i++;
	for (; i != size_; ++i) {
		if (s.isTrue(lits_[i]))   { std::swap(lits_[i], lits_[0]); return;  }
		if (!s.isFalse(lits_[i])) { lits_[j++] = lits_[i]; }
	}
	size_ = j;
}
void SatPreprocessor::Clause::destroy() {
	void* mem = this;
	this->~Clause();
	::operator delete(mem);
}
/////////////////////////////////////////////////////////////////////////////////////////
// ConstString
/////////////////////////////////////////////////////////////////////////////////////////
struct StrRef {
	typedef Atomic_t::type RefCount;
	static uint64      lit(const char* str) {
		if (!str) str = "";
		return set_bit(static_cast(reinterpret_cast(str)), 63);
	}
	static uint64      create(const char* str, std::size_t len) {
		char*   mem = (char*)malloc(sizeof(RefCount) + len + 1);
		RefCount* p = new (mem) RefCount();
		std::memcpy(mem + sizeof(RefCount), str, len);
		mem[sizeof(RefCount) + len] = 0;
		*p = 1;
		return static_cast(reinterpret_cast(mem));
	}
	static RefCount*   asShared(uint64 ref) {
		return !test_bit(ref, 63) ? reinterpret_cast(static_cast(ref)) : 0;
	}
	static uint64      share(uint64 ref) {
		if (RefCount* p = asShared(ref)) { ++*p; }
		return ref;
	}
	static uint64      release(uint64 ref) {
		RefCount* p = asShared(ref);
		if (p && !--*p) {
			p->~RefCount();
			free((void*)p);
		}
		return 0;
	}
	static const char* get(uint64 ref) {
		return reinterpret_cast(static_cast(
			!test_bit(ref, 63)
			? ref + sizeof(RefCount)
			: clear_bit(ref, 63)));
	}
};
ConstString::ConstString(const char* str, Ownership_t::Type o) : ref_(str && *str && o == Ownership_t::Acquire ? StrRef::create(str, std::strlen(str)) : StrRef::lit(str)) {}
ConstString::ConstString(const StrView& str) : ref_(str.size ? StrRef::create(str.first, str.size) : StrRef::lit("")) {}
ConstString::ConstString(const ConstString& other) : ref_(StrRef::share(other.ref_)) { }
ConstString::~ConstString() {  StrRef::release(ref_); }
void ConstString::swap(ConstString& rhs) { std::swap(ref_, rhs.ref_); }
ConstString& ConstString::operator=(const ConstString& rhs) {
	ConstString temp(rhs);
	swap(temp);
	return *this;
}
const char* ConstString::c_str() const { return StrRef::get(ref_); }
/////////////////////////////////////////////////////////////////////////////////////////
// OutputTable
/////////////////////////////////////////////////////////////////////////////////////////
OutputTable::OutputTable() : theory(0), vars_(0, 0), hide_(0) {}
OutputTable::~OutputTable() {
	PodVector::destruct(facts_);
	PodVector::destruct(preds_);
}

void OutputTable::setFilter(char c) {
	hide_ = c;
}
bool OutputTable::filter(const NameType& n) const {
	char c = *n;
	return c == hide_ || !c;
}
bool OutputTable::add(const NameType& fact) {
	if (!filter(fact)) {
		facts_.push_back(fact);
		return true;
	}
	return false;
}

bool OutputTable::add(const NameType& n, Literal c, uint32 u) {
	if (!filter(n)) {
		PredType p = {n, c, u};
		preds_.push_back(p);
		return true;
	}
	return false;
}

void OutputTable::setVarRange(const RangeType& r) {
	CLASP_ASSERT_CONTRACT(r.lo <= r.hi);
	vars_ = r;
}
void OutputTable::addProject(Literal x) {
	proj_.push_back(x);
}

uint32 OutputTable::size() const {
	return numFacts() + numPreds() + numVars();
}
OutputTable::Theory::~Theory() {}
/////////////////////////////////////////////////////////////////////////////////////////
// DomainTable
/////////////////////////////////////////////////////////////////////////////////////////
DomainTable::ValueType::ValueType(Var v, DomModType t, int16 bias, uint16 prio, Literal cond)
	: cond_(cond.id())
	, comp_(t == DomModType::True || t == DomModType::False)
	, var_(v)
	, type_(uint32(t) <= 3u ? t : uint32(t == DomModType::False))
	, bias_(bias)
	, prio_(prio) {
}
DomModType DomainTable::ValueType::type() const { return static_cast(comp_ == 0 ? type_ : uint32(DomModType::True + type_)); }
DomainTable::DomainTable() : domRec(0), seen_(0) {}
void DomainTable::add(Var v, DomModType t, int16 b, uint16 p, Literal c) {
	if (c != lit_false() && (t != DomModType::Init || c == lit_true())) {
		entries_.push_back(ValueType(v, t, b, p, c));
	}
}
uint32 DomainTable::simplify() {
	if (seen_ >= size()) { return size(); }
	std::stable_sort(entries_.begin() + seen_, entries_.end(), cmp);
	DomVec::iterator j = entries_.begin() + seen_;
	for (DomVec::const_iterator it = j, end = entries_.end(), n; it != end; it = n) {
		Var     v = it->var();
		Literal c = it->cond();
		for (n = it + 1; n != end && n->var() == v && n->cond() == c; ) { ++n; }
		if ((n - it) == 1) {
			*j++ = *it;
		}
		else {
			static_assert(DomModType::Level == 0 && DomModType::Sign == 1 && DomModType::True == 4, "check enumeration constants");
			enum { n_simp = 4u };
			int const mod_level = DomModType::Level, mod_sign = DomModType::Sign;
			int16 const NO_BIAS = INT16_MAX;
			uint16 prio[n_simp] ={0, 0, 0, 0};
			int16  bias[n_simp] ={NO_BIAS, NO_BIAS, NO_BIAS, NO_BIAS};
			for (; it != n; ++it) {
				if (!it->comp() && it->prio() >= prio[it->type()]) {
					bias[it->type()] = it->bias();
					prio[it->type()] = it->prio();
				}
				else if (it->comp()) {
					if (it->prio() >= prio[mod_level]) {
						bias[mod_level] = it->bias();
						prio[mod_level] = it->prio();
					}
					if (it->prio() >= prio[mod_sign]) {
						bias[mod_sign] = it->type() == DomModType::True ? 1 : -1;
						prio[mod_sign] = it->prio();
					}
				}
			}
			int s = 0;
			if (bias[mod_level] != NO_BIAS && bias[mod_sign] != NO_BIAS && bias[mod_sign] && prio[mod_level] == prio[mod_sign]) {
				*j++ = ValueType(v, bias[mod_sign] > 0 ? DomModType::True : DomModType::False, bias[mod_level], prio[mod_level], c);
				s = mod_sign + 1;
			}
			for (int t = s; t != n_simp; ++t) {
				if (bias[t] != NO_BIAS) {
					*j++ = ValueType(v, static_cast(t), bias[t], prio[t], c);
				}
			}
		}
	}
	entries_.erase(j, entries_.end());
	if (entries_.capacity() > static_cast(entries_.size() * 1.75)) {
		DomVec(entries_).swap(entries_);
	}
	return (seen_ = size());
}
void DomainTable::reset() {
	DomVec().swap(entries_);
	domRec = 0;
}
bool   DomainTable::empty() const { return entries_.empty(); }
uint32 DomainTable::size()  const { return static_cast(entries_.size()); }
DomainTable::iterator DomainTable::begin() const { return entries_.begin(); }
DomainTable::iterator DomainTable::end()   const { return entries_.end(); }
/////////////////////////////////////////////////////////////////////////////////////////
// SharedContext::Minimize
/////////////////////////////////////////////////////////////////////////////////////////
struct SharedContext::Minimize {
	typedef SingleOwnerPtr ProductPtr;
	void add(weight_t p, const WeightLiteral& lit) {
		builder.add(p, lit);
	}
	bool reset() const {
		if (product.get()) { product->resetBounds(); }
		return true;
	}
	SharedMinimizeData* get(SharedContext& ctx) {
		if (builder.empty()) { return product.get(); }
		if (product.get()) {
			builder.add(*product);
			product = 0;
		}
		return (product = builder.build(ctx)).get();
	}
	MinimizeBuilder builder;
	ProductPtr      product;
};
/////////////////////////////////////////////////////////////////////////////////////////
// SharedContext
/////////////////////////////////////////////////////////////////////////////////////////
static BasicSatConfig config_def_s;
SharedContext::SharedContext()
	: mini_(0), progress_(0), lastTopLevel_(0) {
	// sentinel always present
	setFrozen(addVar(Var_t::Atom, 0), true);
	stats_.vars.num = 0;
	config_ = &config_def_s;
	config_.release();
	pushSolver();
}

bool SharedContext::ok() const { return master()->decisionLevel() || !master()->hasConflict() || master()->hasStopConflict(); }
void SharedContext::enableStats(uint32 lev) {
	if (lev > 0) { master()->stats.enableExtended(); }
}
SharedContext::~SharedContext() {
	while (!solvers_.empty()) { delete solvers_.back(); solvers_.pop_back(); }
	delete mini_;
}

void SharedContext::reset() {
	this->~SharedContext();
	new (this) SharedContext();
}

void SharedContext::setConcurrency(uint32 n, ResizeMode mode) {
	if (n <= 1) { share_.count = 1; }
	else        { share_.count = n; solvers_.reserve(n); }
	while (solvers_.size() < share_.count && (mode & resize_push) != 0u) {
		pushSolver();
	}
	while (solvers_.size() > share_.count && (mode & resize_pop) != 0u) {
		delete solvers_.back();
		solvers_.pop_back();
	}
	if ((share_.shareM & ContextParams::share_auto) != 0) {
		setShareMode(ContextParams::share_auto);
	}
}

void SharedContext::setShareMode(ContextParams::ShareMode m) {
	if ( (share_.shareM = static_cast(m)) == ContextParams::share_auto && share_.count > 1) {
		share_.shareM |= static_cast(ContextParams::share_all);
	}
}
void SharedContext::setShortMode(ContextParams::ShortMode m) {
	share_.shortM = static_cast(m);
}

void SharedContext::setPreproMode(uint32 m, bool b) {
	share_.satPreM &= ~m;
	if (b) { share_.satPreM |= m; }
}

Solver& SharedContext::pushSolver() {
	uint32 id    = (uint32)solvers_.size();
	share_.count = std::max(share_.count, id + 1);
	Solver* s    = new Solver(this, id);
	solvers_.push_back(s);
	return *s;
}

void SharedContext::setConfiguration(Configuration* c, Ownership_t::Type ownership) {
	bool own = ownership == Ownership_t::Acquire;
	if (c == 0) { c = &config_def_s; own = false; }
	report(Event::subsystem_facade);
	if (config_.get() != c) {
		config_ = c;
		if (!own) config_.release();
		config_->prepare(*this);
		const ContextParams& opts = config_->context();
		setShareMode(static_cast(opts.shareMode));
		setShortMode(static_cast(opts.shortMode));
		share_.seed   = opts.seed;
		if (satPrepro.get() == 0 && opts.satPre.type != SatPreParams::sat_pre_no) {
			satPrepro.reset(SatPreParams::create(opts.satPre));
		}
		enableStats(opts.stats);
		// force update on next call to Solver::startInit()
		for (uint32 i = 0; i != solvers_.size(); ++i) {
			solvers_[i]->resetConfig();
		}
	}
	else if (own != config_.is_owner()) {
		if (own) config_.acquire();
		else     config_.release();
	}
}

bool SharedContext::unfreeze() {
	if (frozen()) {
		share_.frozen = 0;
		share_.winner = 0;
		heuristic.domRec = 0;
		btig_.markShared(false);
		return master()->popRootLevel(master()->rootLevel())
		  &&   btig_.propagate(*master(), lit_true()) // any newly learnt facts
		  &&   unfreezeStep()
		  &&   (!mini_ || mini_->reset());
	}
	return true;
}

bool SharedContext::unfreezeStep() {
	Var tag = step_.var();
	for (SolverVec::size_type i = solvers_.size(); i--;) {
		Solver& s = *solvers_[i];
		share_.frozen = i > 0;
		if (!s.validVar(tag)) { continue; }
		s.endStep(lastTopLevel_, configuration()->solver(s.id()));
	}
	if (tag) {
		varInfo_[tag] = VarInfo();
		step_ = lit_false();
		popVars(1);
		++stats_.vars.num;
	}
	return !master()->hasConflict();
}

Var SharedContext::addVars(uint32 nVars, VarType t, uint8 flags) {
	flags &= ~3u;
	flags |= VarInfo::flags(t);
	varInfo_.insert(varInfo_.end(), nVars, VarInfo(flags));
	stats_.vars.num += nVars;
	return static_cast(varInfo_.size() - nVars);
}

void SharedContext::popVars(uint32 nVars) {
	CLASP_ASSERT_CONTRACT_MSG(!frozen(), "Cannot pop vars from frozen program");
	CLASP_FAIL_IF(nVars > numVars(), "Invalid parameter");
	uint32 newVars = numVars() - nVars;
	uint32 comVars = master()->numVars();
	if (newVars >= comVars) {
		// vars not yet committed
		varInfo_.erase(varInfo_.end() - nVars, varInfo_.end());
		stats_.vars.num -= nVars;
	}
	else {
		for (Var v = numVars(); v && nVars; --nVars, --v) {
			stats_.vars.eliminated -= eliminated(v);
			stats_.vars.frozen -= varInfo(v).frozen();
			--stats_.vars.num;
			varInfo_.pop_back();
		}
		btig_.resize((numVars()+1)<<1);
		for (SolverVec::size_type i = solvers_.size(); i--;) {
			solvers_[i]->updateVars();
		}
		lastTopLevel_ = std::min(lastTopLevel_, master()->assign_.front);
	}
}

void SharedContext::setSolveMode(SolveMode m) { share_.solveM = m; }
void SharedContext::requestStepVar() { if (step_ == lit_true()) { step_ = lit_false(); } }
void SharedContext::setFrozen(Var v, bool b) {
	assert(validVar(v));
	if (v && b != varInfo_[v].has(VarInfo::Frozen)) {
		varInfo_[v].toggle(VarInfo::Frozen);
		b ? ++stats_.vars.frozen : --stats_.vars.frozen;
	}
}

bool SharedContext::eliminated(Var v) const {
	assert(validVar(v));
	return !master()->assign_.valid(v);
}

void SharedContext::eliminate(Var v) {
	assert(validVar(v) && !frozen() && master()->decisionLevel() == 0);
	if (!eliminated(v)) {
		++stats_.vars.eliminated;
		// eliminate var from assignment - no longer a decision variable!
		master()->assign_.eliminate(v);
	}
}

Literal SharedContext::addStepLit() {
	VarInfo nv; nv.set(VarInfo::Frozen);
	varInfo_.push_back(nv);
	btig_.resize((numVars() + 1) << 1);
	return posLit(master()->pushAuxVar());
}
Solver& SharedContext::startAddConstraints(uint32 constraintGuess) {
	if (!unfreeze()) { return *master(); }
	btig_.resize((numVars() + 1 + uint32(step_ == lit_false() || solveMode() == solve_multi))<<1);
	master()->startInit(constraintGuess, configuration()->solver(0));
	return *master();
}
bool SharedContext::addUnary(Literal x) {
	CLASP_ASSERT_CONTRACT(!frozen() || !isShared());
	return master()->force(x);
}
bool SharedContext::addBinary(Literal x, Literal y) {
	CLASP_ASSERT_CONTRACT(allowImplicit(Constraint_t::Static));
	Literal lits[2] = {x, y};
	return ClauseCreator::create(*master(), ClauseRep(lits, 2), ClauseCreator::clause_force_simplify);
}
bool SharedContext::addTernary(Literal x, Literal y, Literal z) {
	CLASP_ASSERT_CONTRACT(allowImplicit(Constraint_t::Static));
	Literal lits[3] = {x, y, z};
	return ClauseCreator::create(*master(), ClauseRep(lits, 3), ClauseCreator::clause_force_simplify);
}
void SharedContext::add(Constraint* c) {
	CLASP_ASSERT_CONTRACT(!frozen());
	master()->add(c);
}
void SharedContext::addMinimize(WeightLiteral x, weight_t p) {
	if (!mini_) { mini_ = new Minimize(); }
	mini_->add(p, x);
}
bool SharedContext::hasMinimize() const {
	return mini_ != 0;
}
void SharedContext::removeMinimize() {
	delete mini_;
	mini_ = 0;
}
SharedMinimizeData* SharedContext::minimize() {
	return mini_ ? mini_->get(*this) : 0;
}
int SharedContext::addImp(ImpGraph::ImpType t, const Literal* lits, ConstraintType ct) {
	if (!allowImplicit(ct)) { return -1; }
	bool learnt = ct != Constraint_t::Static;
	if (!learnt && !frozen() && satPrepro.get()) {
		satPrepro->addClause(lits, static_cast(t));
		return 1;
	}
	return int(btig_.add(t, learnt, lits));
}

uint32 SharedContext::numConstraints() const { return numBinary() + numTernary() + sizeVec(master()->constraints_); }

bool SharedContext::endInit(bool attachAll) {
	assert(!frozen());
	report(Event::subsystem_prepare);
	initStats(*master());
	heuristic.simplify();
	SatPrePtr temp;
	satPrepro.swap(temp);
	bool ok = !master()->hasConflict() && master()->preparePost() && (!temp.get() || temp->preprocess(*this)) && master()->endInit();
	satPrepro.swap(temp);
	master()->dbIdx_ = (uint32)master()->constraints_.size();
	lastTopLevel_    = (uint32)master()->assign_.front;
	stats_.constraints.other  = sizeVec(master()->constraints_);
	stats_.constraints.binary = btig_.numBinary();
	stats_.constraints.ternary= btig_.numTernary();
	stats_.acycEdges          = extGraph.get() ? extGraph->edges() : 0;
	stats_.complexity         = std::max(stats_.complexity, problemComplexity());
	if (ok && step_ == lit_false()) {
		step_ = addStepLit();
	}
	btig_.markShared(concurrency() > 1);
	share_.frozen = 1;
	for (uint32 i = ok && attachAll ? 1 : concurrency(); i != concurrency(); ++i) {
		if (!hasSolver(i)) { pushSolver(); }
		if (!attach(i))    { ok = false; break; }
	}
	return ok || (detach(*master(), false), master()->setStopConflict(), false);
}

bool SharedContext::attach(Solver& other) {
	assert(frozen() && other.shared_ == this);
	if (other.validVar(step_.var())) {
		if (!other.popRootLevel(other.rootLevel())){ return false; }
		if (&other == master())                    { return true;  }
	}
	initStats(other);
	// 1. clone vars & assignment
	Var lastVar = other.numVars();
	other.startInit(static_cast(master()->constraints_.size()), configuration()->solver(other.id()));
	Antecedent null;
	for (LitVec::size_type i = 0, end = master()->trail().size(); i != end; ++i) {
		if (!other.force(master()->trail()[i], null)) { return false; }
	}
	for (Var v = satPrepro.get() ? lastVar+1 : varMax, end = master()->numVars(); v <= end; ++v) {
		if (eliminated(v) && other.value(v) == value_free) {
			other.assign_.eliminate(v);
		}
	}
	if (other.constraints_.empty()) { other.lastSimp_ = master()->lastSimp_; }
	// 2. clone & attach constraints
	if (!other.cloneDB(master()->constraints_)) {
		return false;
	}
	Constraint* c = master()->enumerationConstraint();
	other.setEnumerationConstraint( c ? c->cloneAttach(other) : 0 );
	// 3. endInit
	return (other.preparePost() && other.endInit()) || (detach(other, false), false);
}

void SharedContext::detach(Solver& s, bool reset) {
	assert(s.shared_ == this);
	if (reset) { s.reset(); }
	s.setEnumerationConstraint(0);
	s.popAuxVar();
}
void SharedContext::initStats(Solver& s) const {
	s.stats.enable(master()->stats);
	s.stats.reset();
}
SolverStats& SharedContext::solverStats(uint32 sId) const {
	CLASP_FAIL_IF(!hasSolver(sId), "solver id out of range");
	return solver(sId)->stats;
}
const SolverStats& SharedContext::accuStats(SolverStats& out) const {
	for (uint32 i = 0; i != solvers_.size(); ++i) {
		out.accu(solvers_[i]->stats, true);
	}
	return out;
}
void SharedContext::warn(const char* what) const {
	if (progress_) {
		progress_->dispatch(LogEvent(progress_->active(), Event::verbosity_quiet, LogEvent::Warning, 0, what));
	}
}
void SharedContext::report(const char* what, const Solver* s) const {
	if (progress_) {
		progress_->dispatch(LogEvent(progress_->active(), Event::verbosity_high, LogEvent::Message, s, what));
	}
}
void SharedContext::report(Event::Subsystem sys) const {
	if (progress_ && progress_->setActive(sys)) {
		const char* m = "";
		Event::Verbosity v = Event::verbosity_high;
		switch(sys) {
			default: return;
			case Event::subsystem_load:    m = "Reading";       break;
			case Event::subsystem_prepare: m = "Preprocessing"; break;
			case Event::subsystem_solve:   m = "Solving"; v = Event::verbosity_low; break;
		}
		progress_->onEvent(LogEvent(sys, v, LogEvent::Message, 0, m));
	}
}
void SharedContext::simplify(bool shuffle) {
	Solver::ConstraintDB& db = master()->constraints_;
	if (concurrency() == 1 || master()->dbIdx_ == 0) {
		Clasp::simplifyDB(*master(), db, shuffle);
	}
	else {
		uint32 rem = 0;
		for (Solver::ConstraintDB::size_type i = 0, end = db.size(); i != end; ++i) {
			Constraint* c = db[i];
			if (c->simplify(*master(), shuffle)) { c->destroy(master(), false); db[i] = 0; ++rem; }
		}
		if (rem) {
			for (SolverVec::size_type s = 1; s != solvers_.size(); ++s) {
				Solver& x = *solvers_[s];
				CLASP_FAIL_IF(x.dbIdx_ > db.size(), "Invalid DB idx!");
				if      (x.dbIdx_ == db.size()) { x.dbIdx_ -= rem; }
				else if (x.dbIdx_ != 0)         { x.dbIdx_ -= (uint32)std::count_if(db.begin(), db.begin()+x.dbIdx_, IsNull()); }
			}
			db.erase(std::remove_if(db.begin(), db.end(), IsNull()), db.end());
		}
	}
	master()->dbIdx_ = sizeVec(db);
}
void SharedContext::removeConstraint(uint32 idx, bool detach) {
	Solver::ConstraintDB& db = master()->constraints_;
	CLASP_ASSERT_CONTRACT(idx < db.size());
	Constraint* c = db[idx];
	for (SolverVec::size_type s = 1; s != solvers_.size(); ++s) {
		Solver& x = *solvers_[s];
		x.dbIdx_ -= (idx < x.dbIdx_);
	}
	db.erase(db.begin()+idx);
	master()->dbIdx_ = sizeVec(db);
	c->destroy(master(), detach);
}

void SharedContext::simplifyShort(const Solver& s, Literal p) {
	if (!isShared() && p.id() < btig_.size()) { btig_.removeTrue(s, p); }
}

uint32 SharedContext::problemComplexity() const {
	if (isExtended()) {
		uint32 r = numBinary() + numTernary();
		for (uint32 i = 0; i != master()->constraints_.size(); ++i) {
			r += master()->constraints_[i]->estimateComplexity(*master());
		}
		return r;
	}
	return numConstraints();
}
/////////////////////////////////////////////////////////////////////////////////////////
// Distributor
/////////////////////////////////////////////////////////////////////////////////////////
Distributor::Distributor(const Policy& p) : policy_(p)  {}
Distributor::~Distributor() {}

}
clasp-3.2.2/libclasp/src/solve_algorithms.cpp000066400000000000000000000412711304134206100212640ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// Basic solve
/////////////////////////////////////////////////////////////////////////////////////////
struct BasicSolve::State {
	typedef BasicSolveEvent EventType;
	typedef SingleOwnerPtr BlockPtr;
	State(Solver& s, const SolveParams& p);
	ValueRep solve(Solver& s, const SolveParams& p, SolveLimits* lim);
	uint64           dbGrowNext;
	double           dbMax;
	double           dbHigh;
	ScheduleStrategy dbRed;
	BlockPtr         rsBlock;
	uint32           nRestart;
	uint32           nGrow;
	uint32           dbRedInit;
	uint32           dbPinned;
	uint32           rsShuffle;
};

BasicSolve::BasicSolve(Solver& s, const SolveLimits& lim) : solver_(&s), params_(&s.searchConfig()), limits_(lim), state_(0) {}
BasicSolve::BasicSolve(Solver& s, const SolveParams& p, const SolveLimits& lim)
	: solver_(&s)
	, params_(&p)
	, limits_(lim)
	, state_(0) {
}

BasicSolve::~BasicSolve(){ delete state_; }
void BasicSolve::reset(bool reinit) {
	if (!state_ || reinit) {
		delete state_;
		state_ = 0;
	}
	else {
		state_->~State();
		new (state_) State(*solver_, *params_);
	}
}
void BasicSolve::reset(Solver& s, const SolveParams& p, const SolveLimits& lim) {
	solver_ = &s;
	params_ = &p;
	limits_ = lim;
	reset(true);
}

ValueRep BasicSolve::solve() {
	if (limits_.reached())                       { return value_free;  }
	if (!state_ && !params_->randomize(*solver_)){ return value_false; }
	if (!state_)                                 { state_ = new State(*solver_, *params_); }
	return state_->solve(*solver_, *params_, hasLimit() ? &limits_ : 0);
}

bool BasicSolve::satisfiable(const LitVec& path, bool init) {
	if (!solver_->clearAssumptions() || !solver_->pushRoot(path)){ return false; }
	if (init && !params_->randomize(*solver_))                   { return false; }
	State temp(*solver_, *params_);
	return temp.solve(*solver_, *params_, 0) == value_true;
}

bool BasicSolve::assume(const LitVec& path) {
	return solver_->pushRoot(path);
}

BasicSolve::State::State(Solver& s, const SolveParams& p) {
	Range32 dbLim= p.reduce.sizeInit(*s.sharedContext());
	dbGrowNext   = p.reduce.growSched.current();
	dbMax        = dbLim.lo;
	dbHigh       = dbLim.hi;
	dbRed        = p.reduce.cflSched;
	nRestart     = 0;
	nGrow        = 0;
	dbRedInit    = p.reduce.cflInit(*s.sharedContext());
	dbPinned     = 0;
	rsShuffle    = p.restart.shuffle;
	if (dbLim.lo < s.numLearntConstraints()) {
		dbMax      = std::min(dbHigh, double(s.numLearntConstraints() + p.reduce.initRange.lo));
	}
	if (dbRedInit && dbRed.type != ScheduleStrategy::Luby) {
		if (dbRedInit < dbRed.base) {
			dbRedInit  = std::min(dbRed.base, std::max(dbRedInit,(uint32)5000));
			dbRed.grow = dbRedInit != dbRed.base ? std::min(dbRed.grow, dbRedInit/2.0f) : dbRed.grow;
			dbRed.base = dbRedInit;
		}
		dbRedInit = 0;
	}
	if (p.restart.dynamic()) {
		s.stats.enableLimit(p.restart.sched.base);
		s.stats.limit->reset();
	}
	if (p.restart.blockScale > 0.0f && p.restart.blockWindow > 0) {
		rsBlock.reset(new BlockLimit(p.restart.blockWindow, p.restart.blockScale));
		rsBlock->inc  = std::max(p.restart.sched.base, uint32(50));
		rsBlock->next = std::max(p.restart.blockWindow, p.restart.blockFirst);
	}
	s.stats.lastRestart = s.stats.analyzed;
}

ValueRep BasicSolve::State::solve(Solver& s, const SolveParams& p, SolveLimits* lim) {
	assert(!lim || !lim->reached());
	if (s.hasConflict() && s.decisionLevel() == s.rootLevel()) {
		return value_false;
	}
	struct ConflictLimits {
		uint64 reduce;  // current reduce limit
		uint64 grow;    // current limit for next growth operation
		uint64 restart; // current restart limit
		uint64 global;  // current global limit
		uint64 min()      const { return std::min(std::min(reduce, grow), std::min(restart, global)); }
		void  update(uint64 x)  { reduce -= x; grow -= x; restart -= x; global -= x; }
	};
	WeightLitVec inDegree;
	SearchLimits sLimit;
	ScheduleStrategy rs     = p.restart.sched;
	ScheduleStrategy dbGrow = p.reduce.growSched;
	Solver::DBInfo  db      = {0,0,dbPinned};
	ValueRep result         = value_free;
	ConflictLimits cLimit   = {dbRed.current() + dbRedInit, dbGrowNext, UINT64_MAX, lim ? lim->conflicts : UINT64_MAX};
	uint64  limRestarts     = lim ? lim->restarts : UINT64_MAX;
	if (!dbGrow.disabled())  { dbGrow.advanceTo(nGrow); }
	if (nRestart == UINT32_MAX && p.restart.update() == RestartParams::seq_disable) {
		sLimit = SearchLimits();
	}
	else if (p.restart.dynamic() && s.stats.limit) {
		if (!nRestart) { s.stats.limit->init((float)p.restart.sched.grow, DynamicLimit::lbd_limit); }
		sLimit.restart.dynamic   = s.stats.limit;
		sLimit.restart.conflicts = s.stats.limit->adjust.limit - std::min(s.stats.limit->adjust.samples, s.stats.limit->adjust.limit - 1);
	}
	else {
		rs.advanceTo(!rs.disabled() ? nRestart : 0);
		sLimit.restart.conflicts = rs.current();
	}
	sLimit.restart.local = p.restart.local();
	sLimit.restart.block = rsBlock.get();
	if (p.reduce.memMax) {
		sLimit.memory = static_cast(p.reduce.memMax)<<20;
	}
	uint64 n = 0;
	for (EventType progress(s, EventType::event_restart, 0, 0); cLimit.global; ) {
		cLimit.restart   = !p.restart.local() ? sLimit.restart.conflicts : UINT64_MAX;
		sLimit.used      = 0;
		sLimit.learnts   = (uint32)std::min(dbMax + (db.pinned*p.reduce.strategy.noGlue), dbHigh);
		sLimit.conflicts = cLimit.min(); assert(sLimit.conflicts);
		progress.cLimit  = sLimit.conflicts;
		progress.lLimit  = sLimit.learnts;
		if (progress.op) { s.sharedContext()->report(progress); progress.op = (uint32)EventType::event_none; }
		result = s.search(sLimit, p.randProb);
		cLimit.update(n = std::min(sLimit.used, sLimit.conflicts)); // number of conflicts in this iteration
		if (result != value_free) {
			progress.op = static_cast(EventType::event_exit);
			if (result == value_true && p.restart.update() != RestartParams::seq_continue) {
				if      (p.restart.update() == RestartParams::seq_repeat) { nRestart = 0; }
				else if (p.restart.update() == RestartParams::seq_disable){ nRestart = UINT32_MAX; }
			}
			if (!dbGrow.disabled()) { dbGrowNext = std::max(cLimit.grow, uint64(1)); }
			s.sharedContext()->report(progress);
			break;
		}
		if (s.restartReached(sLimit)) {
			// restart reached - do restart
			++nRestart;
			if (p.restart.counterRestart && (nRestart % p.restart.counterRestart) == 0 ) {
				inDegree.clear();
				s.heuristic()->bump(s, inDegree, p.restart.counterBump / (double)s.inDegree(inDegree));
			}
			if (sLimit.restart.dynamic) {
				n = sLimit.restart.dynamic->runLen();
				sLimit.restart.conflicts = sLimit.restart.dynamic->restart(rs.len ? rs.len : UINT32_MAX, (float)rs.grow);
			}
			else {
				sLimit.restart.conflicts = n = rs.next();
			}
			s.restart();
			if (p.reduce.strategy.fRestart){ db        = s.reduceLearnts(p.reduce.fRestart(), p.reduce.strategy); }
			if (nRestart == rsShuffle)     { rsShuffle+= p.restart.shuffleNext; s.shuffleOnNextSimplify();}
			if (--limRestarts == 0)        { break; }
			s.stats.lastRestart = s.stats.analyzed;
			progress.op         = (uint32)EventType::event_restart;
		}
		else if (!p.restart.local()) {
			sLimit.restart.conflicts -= std::min(n, sLimit.restart.conflicts);
		}
		if (cLimit.reduce == 0 || s.reduceReached(sLimit)) {
			// reduction reached - remove learnt constraints
			db              = s.reduceLearnts(p.reduce.fReduce(), p.reduce.strategy);
			cLimit.reduce   = dbRedInit + (cLimit.reduce == 0 ? dbRed.next() : dbRed.current());
			progress.op     = std::max(progress.op, (uint32)EventType::event_deletion);
			if (s.reduceReached(sLimit) || db.pinned >= dbMax) {
				ReduceStrategy t; t.algo = 2; t.score = 2; t.glue = 0;
				db.pinned /= 2;
				db.size    = s.reduceLearnts(0.5f, t).size;
				if (db.size >= sLimit.learnts) { dbMax = std::min(dbMax + std::max(100.0, s.numLearntConstraints()/10.0), dbHigh); }
			}
		}
		if (cLimit.grow == 0 || (dbGrow.defaulted() && progress.op == (uint32)EventType::event_restart)) {
			// grow sched reached - increase max db size
			if (cLimit.grow == 0)                      { cLimit.grow = n = dbGrow.next(); ++nGrow; }
			if ((s.numLearntConstraints() + n) > dbMax){ dbMax  *= p.reduce.fGrow; progress.op = std::max(progress.op, (uint32)EventType::event_grow); }
			if (dbMax > dbHigh)                        { dbMax   = dbHigh; cLimit.grow = UINT64_MAX; dbGrow = ScheduleStrategy::none(); }
		}
	}
	dbPinned            = db.pinned;
	s.stats.lastRestart = s.stats.analyzed - s.stats.lastRestart;
	if (lim) {
		if (lim->conflicts != UINT64_MAX) { lim->conflicts = cLimit.global; }
		if (lim->restarts  != UINT64_MAX) { lim->restarts  = limRestarts;   }
	}
	return result;
}
/////////////////////////////////////////////////////////////////////////////////////////
// SolveAlgorithm
/////////////////////////////////////////////////////////////////////////////////////////
SolveAlgorithm::SolveAlgorithm(const SolveLimits& lim) : limits_(lim), ctx_(0), enum_(0), onModel_(0), enumLimit_(UINT64_MAX), time_(0.0), last_(0)  {
}
SolveAlgorithm::~SolveAlgorithm() {}
void SolveAlgorithm::setEnumerator(Enumerator& e) {
	enum_.reset(&e);
	enum_.release();
}
const Model& SolveAlgorithm::model() const {
	return enum_->lastModel();
}
bool SolveAlgorithm::interrupt() {
	return doInterrupt();
}
bool SolveAlgorithm::attach(SharedContext& ctx, ModelHandler* onModel) {
	CLASP_FAIL_IF(ctx_, "SolveAlgorithm is already running!");
	if (!ctx.frozen()) { ctx.endInit(); }
	ctx.report(Event::subsystem_solve);
	if (ctx.master()->hasConflict() || !limits_.conflicts || interrupted()) {
		last_  = !ctx.ok() ? value_false : value_free;
		return false;
	}
	ctx_     = &ctx;
	time_    = ThreadTime::getTime();
	onModel_ = onModel;
	last_    = value_free;
	if (!enum_.get()) { enum_ = EnumOptions::nullEnumerator(); }
	return true;
}
void SolveAlgorithm::detach() {
	if (ctx_) {
		ctx_->master()->stats.addCpuTime(ThreadTime::getTime() - time_);
		onModel_ = 0;
		ctx_     = 0;
		path_    = 0;
	}
}

bool SolveAlgorithm::solve(SharedContext& ctx, const LitVec& assume, ModelHandler* onModel) {
	struct Scoped {
		Scoped(SolveAlgorithm* s) : self(s) {}
		~Scoped() { self->detach(); }
		bool solve(const LitVec& assume) {
			if (self->maxModels() != UINT64_MAX) {
				if (self->enumerator().optimize() && !self->enumerator().tentative()) {
					self->ctx().warn("#models not 0: optimality of last model not guaranteed.");
				}
				if (self->enumerator().lastModel().consequences()) {
					self->ctx().warn("#models not 0: last model may not cover consequences.");
				}
			}
			self->path_.reset(&assume);
			self->path_.release();
			return self->doSolve(self->ctx(), assume);
		}
		SolveAlgorithm* self;
	};
	return attach(ctx, onModel) ? Scoped(this).solve(assume) : ctx.ok();
}

void SolveAlgorithm::start(SharedContext& ctx, const LitVec& assume, ModelHandler* onModel) {
	if (attach(ctx, onModel)) {
		doStart(ctx, *(path_ = new LitVec(assume)));
	}
}
bool SolveAlgorithm::next() {
	if (!ctx_) { return false; }
	if (last_ != value_stop && (last_ != value_true || !enum_->commitSymmetric(*ctx_->solver(model().sId)))) {
		last_ = doNext(last_);
	}
	if (last_ == value_true) {
		Solver& s = *ctx_->solver(model().sId);
		if (onModel_ && !onModel_->onModel(s, model())) { last_ = value_stop; }
		if (!ctx_->report(s, model())) { last_ = value_stop; }
		if (!enum_->tentative() && model().num >= enumLimit_) { last_ = value_stop; }
		return true;
	}
	else {
		stop();
		return false;
	}
}
bool SolveAlgorithm::more() {
	return last_ != value_false;
}
void SolveAlgorithm::stop() {
	if (ctx_) {
		doStop();
		detach();
	}
}
bool SolveAlgorithm::reportModel(Solver& s) const {
	for (const Model& m = enum_->lastModel();;) {
		bool r1 = !onModel_ || onModel_->onModel(s, m);
		bool r2 = s.sharedContext()->report(s, m);
		bool res= r1 && r2 && (enumLimit_ > m.num || enum_->tentative());
		if (!res || (res = !interrupted()) == false || !enum_->commitSymmetric(s)) { return res; }
	}
}
bool SolveAlgorithm::reportUnsat(Solver& s) const {
	const Model&  m = enum_->lastModel();
	EventHandler* h = s.sharedContext()->eventHandler();
	bool r1 = !onModel_ || onModel_->onUnsat(s, m);
	bool r2 = !h || h->onUnsat(s, m);
	return r1 && r2;
}
bool SolveAlgorithm::moreModels(const Solver& s) const {
	return s.decisionLevel() != 0 || !s.symmetric().empty() || (!s.sharedContext()->preserveModels() && s.sharedContext()->numEliminatedVars());
}
void SolveAlgorithm::doStart(SharedContext&, const LitVec&) {
	throw std::logic_error("Iterative model generation not supported by this algorithm!");
}
int SolveAlgorithm::doNext(int) {
	throw std::logic_error("Iterative model generation not supported by this algorithm!");
}
void SolveAlgorithm::doStop() {}
/////////////////////////////////////////////////////////////////////////////////////////
// SequentialSolve
/////////////////////////////////////////////////////////////////////////////////////////
namespace {
struct InterruptHandler : public MessageHandler {
	InterruptHandler(Solver* s, volatile int* t) : solver(s), term(t) {
		if (s && t) { s->addPost(this); }
	}
	~InterruptHandler()  { if (solver) { solver->removePost(this); solver = 0; } }
	bool handleMessages(){ return !*term || (solver->setStopConflict(), false); }
	bool propagateFixpoint(Solver&, PostPropagator*){ return InterruptHandler::handleMessages(); }
	Solver*       solver;
	volatile int* term;
};
}
SequentialSolve::SequentialSolve(const SolveLimits& limit)
	: SolveAlgorithm(limit)
	, solve_(0)
	, term_(-1) {
}
void SequentialSolve::resetSolve()       { if (term_ > 0) { term_ = 0; } }
bool SequentialSolve::doInterrupt()      { return term_ >= 0 && ++term_ != 0; }
void SequentialSolve::enableInterrupts() { if (term_ < 0) { term_ = 0; } }
bool SequentialSolve::interrupted() const{ return term_ > 0; }
void SequentialSolve::doStart(SharedContext& ctx, const LitVec& gp) {
	solve_.reset(new BasicSolve(*ctx.master(), ctx.configuration()->search(0), limits()));
	if (!enumerator().start(solve_->solver(), gp)) { SequentialSolve::doStop(); }
}
int SequentialSolve::doNext(int last) {
	if (term_ > 0 || !solve_.get()) { return solve_.get() ? value_free : value_false; }
	Solver& s = solve_->solver();
	for (InterruptHandler term(term_ == 0 ? &s : (Solver*)0, &term_);;) {
		if (last != value_free) { enumerator().update(s); }
		last = solve_->solve();
 		if (last != value_true) {
 			if      (last == value_free || term_ > 0) { return value_free; }
			else if (enumerator().commitUnsat(s))     { reportUnsat(s); solve_->reset(); }
			else if (enumerator().commitComplete())   { break; }
 			else {
				enumerator().end(s);
				if (!enumerator().start(s, path())) { break; }
				last = value_free;
 			}
 		}
		else if (enumerator().commitModel(s)) { break; }
 	}
 	return last;
}
void SequentialSolve::doStop() {
	if (solve_.get()) {
		enumerator().end(solve_->solver());
		ctx().detach(solve_->solver());
		solve_ = 0;
	}
}
bool SequentialSolve::doSolve(SharedContext& ctx, const LitVec& gp) {
	BasicSolve solve(*ctx.master(), ctx.configuration()->search(0), limits());
	// Add assumptions - if this fails, the problem is unsat
	// under the current assumptions but not necessarily unsat.
	Solver& s = solve.solver();
	bool more = !interrupted() && ctx.attach(s) && enumerator().start(s, gp);
	for (InterruptHandler term(term_ == 0 ? &s : (Solver*)0, &term_); more; solve.reset()) {
		ValueRep res;
		while ((res = solve.solve()) == value_true && (!enumerator().commitModel(s) || reportModel(s))) {
			enumerator().update(s);
		}
		if      (res != value_false)           { more = (res == value_free || moreModels(s)); break; }
		else if (interrupted())                { more = true; break; }
		else if (enumerator().commitUnsat(s))  { reportUnsat(s); enumerator().update(s); }
		else if (enumerator().commitComplete()){ more = false; break; }
		else                                   { enumerator().end(s); more = enumerator().start(s, gp); }
	}
	enumerator().end(s);
	ctx.detach(s);
	return more;
}
}
clasp-3.2.2/libclasp/src/solver.cpp000066400000000000000000001722231304134206100172170ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
namespace Clasp {
namespace {
	typedef HashSet_t::set_type ConstraintSet;
	struct InSet {
		bool operator()(Constraint* c)        const { return set->find(c) != set->end(); }
		bool operator()(const ClauseWatch& w) const { return (*this)(w.head); }
		bool operator()(const GenericWatch&w) const { return (*this)(w.con);  }
		const ConstraintSet* set;
	};
}
DecisionHeuristic::~DecisionHeuristic() {}
/////////////////////////////////////////////////////////////////////////////////////////
// CCMinRecursive
/////////////////////////////////////////////////////////////////////////////////////////
struct CCMinRecursive {
	enum State { state_open = 0, state_removable = 1, state_poison = 2 };
	uint32 encodeState(State st)     const { return open + uint32(st); }
	State  decodeState(uint32 epoch) const { return epoch <= open ? state_open : static_cast(epoch - open); }
	void    push(Literal p) { todo.push_back(p); }
	Literal pop()           { Literal p = todo.back(); todo.pop_back(); return p; }
	LitVec todo;
	uint32 open;
};
/////////////////////////////////////////////////////////////////////////////////////////
// SelectFirst selection strategy
/////////////////////////////////////////////////////////////////////////////////////////
// selects the first free literal
Literal SelectFirst::doSelect(Solver& s) {
	for (Var i = 1; i <= s.numVars(); ++i) {
		if (s.value(i) == value_free) {
			return selectLiteral(s, i, 0);
		}
	}
	assert(!"SelectFirst::doSelect() - precondition violated!\n");
	return Literal();
}
/////////////////////////////////////////////////////////////////////////////////////////
// Dirty list
/////////////////////////////////////////////////////////////////////////////////////////
struct Solver::Dirty {
	static const std::size_t min_size = static_cast(4);
	Dirty() : last(0) {}
	bool add(Literal p, WatchList& wl, Constraint* c) {
		if (wl.right_size() <= min_size) { return false; }
		uintp o = wl.left_size() > 0 ? reinterpret_cast(wl.left_begin()->head) : 0;
		if (add(wl.right_begin()->con, o, c)) { dirty.push_left(p); }
		return true;
	}
	bool add(Literal p, WatchList& wl, ClauseHead* c) {
		if (wl.left_size() <= min_size) { return false; }
		uintp o = wl.right_size() > 0 ? reinterpret_cast(wl.right_begin()->con) : 0;
		if (add(wl.left_begin()->head, o, c)) { dirty.push_left(p); }
		return true;
	}
	bool add(uint32 dl, ConstraintDB& wl, Constraint* c) {
		if (wl.size() <= min_size) { return false; }
		if (add(wl[0], 0, c)) { dirty.push_right(dl); }
		return true;
	}
	template 
	bool add(T*& list, uintp other, Constraint* c) {
		other |= reinterpret_cast(list);
		list = reinterpret_cast( set_bit(reinterpret_cast(list), 0) );
		if (c != last) { cons.insert(last = c); }
		return !test_bit(other, 0);
	}
	template 
	bool test_and_clear(T*& x) const {
		uintp old = reinterpret_cast(x);
		return test_bit(old, 0) && (x = reinterpret_cast(clear_bit(old, 0))) != 0;
	}
	void cleanup(Watches& watches, DecisionLevels& levels) {
		InSet inCons = { &cons };
		for (DirtyList::left_iterator it = dirty.left_begin(), end = dirty.left_end(); it != end; ++it) {
			WatchList& wl = watches[it->id()];
			if (wl.left_size() && test_and_clear(wl.left_begin()->head)) { wl.shrink_left(std::remove_if(wl.left_begin(), wl.left_end(), inCons)); }
			if (wl.right_size()&& test_and_clear(wl.right_begin()->con)) { wl.shrink_right(std::remove_if(wl.right_begin(), wl.right_end(), inCons)); }
		}
		ConstraintDB* db = 0;
		for (DirtyList::right_iterator it = dirty.right_begin(), end = dirty.right_end(); it != end; ++it) {
			if (*it < levels.size() && !(db = levels[*it].undo)->empty() && test_and_clear(*db->begin())) {
				db->erase(std::remove_if(db->begin(), db->end(), inCons), db->end());
			}
		}
		dirty.clear();
		cons.clear();
		last = 0;
	}
	typedef bk_lib::left_right_sequence DirtyList;
	DirtyList     dirty;
	ConstraintSet cons;
	Constraint*   last;
};
/////////////////////////////////////////////////////////////////////////////////////////
// Solver: Construction/Destruction/Setup
/////////////////////////////////////////////////////////////////////////////////////////
#define FOR_EACH_POST(x, head) \
	for (PostPropagator** __r__ = (head), *x; (x = *__r__) != 0; __r__ = (x == *__r__) ? &x->next : __r__)

static PostPropagator* sent_list;
Solver::Solver(SharedContext* ctx, uint32 id)
	: shared_(ctx)
	, ccMin_(0)
	, postHead_(&sent_list)
	, undoHead_(0)
	, enum_(0)
	, memUse_(0)
	, lazyRem_(0)
	, ccInfo_(Constraint_t::Conflict)
	, dbIdx_(0)
	, lastSimp_(0)
	, shufSimp_(0)
	, initPost_(0){
	Var sentVar = assign_.addVar();
	assign_.setValue(sentVar, value_true);
	markSeen(sentVar);
	strategy_.id = id;
}

Solver::~Solver() {
	freeMem();
}

void Solver::freeMem() {
	std::for_each( constraints_.begin(), constraints_.end(), DestroyObject());
	std::for_each( learnts_.begin(), learnts_.end(), DestroyObject() );
	constraints_.clear();
	learnts_.clear();
	post_.clear();
	if (enum_) { enum_->destroy(); }
	heuristic_.reset(0);
	PodVector::destruct(watches_);
	// free undo lists
	// first those still in use
	for (DecisionLevels::size_type i = 0; i != levels_.size(); ++i) {
		delete levels_[i].undo;
	}
	// then those in the free list
	for (ConstraintDB* x = undoHead_; x; ) {
		ConstraintDB* t = x;
		x = (ConstraintDB*)x->front();
		delete t;
	}
	delete ccMin_;
	ccMin_  = 0;
	memUse_ = 0;
}

SatPreprocessor*    Solver::satPrepro()     const { return shared_->satPrepro.get(); }
const SolveParams&  Solver::searchConfig()  const { return shared_->configuration()->search(id()); }

void Solver::reset() {
	SharedContext* myCtx = shared_;
	uint32         myId  = strategy_.id;
	this->~Solver();
	new (this) Solver(myCtx, myId);
}
void Solver::setHeuristic(DecisionHeuristic* h, Ownership_t::Type t) {
	CLASP_ASSERT_CONTRACT_MSG(h, "Heuristic must not be null");
	resetHeuristic();
	heuristic_.reset(h);
	if (t == Ownership_t::Retain) { heuristic_.release(); }
}
void Solver::resetHeuristic() {
	if (heuristic_.get()) { heuristic_->detach(*this); }
	heuristic_ = 0;
}
void Solver::resetConfig() {
	if (strategy_.hasConfig) {
		if (PostPropagator* pp = getPost(PostPropagator::priority_reserved_look)) { pp->destroy(this, true); }
		delete ccMin_;
		ccMin_ = 0;
	}
	strategy_.hasConfig = 0;
}
void Solver::startInit(uint32 numConsGuess, const SolverParams& params) {
	assert(!lazyRem_ && decisionLevel() == 0);
	if (watches_.empty()) {
		assign_.trail.reserve(shared_->numVars() + 2);
		watches_.reserve((shared_->numVars() + 2)<<1);
		assign_.reserve(shared_->numVars() + 2);
	}
	updateVars();
	// pre-allocate some memory
	constraints_.reserve(numConsGuess/2);
	levels_.reserve(25);
	if (undoHead_ == 0)  {
		for (uint32 i = 0; i != 25; ++i) {
			undoFree(new ConstraintDB(10));
		}
	}
	if (!popRootLevel(rootLevel())) { return; }
	if (!strategy_.hasConfig) {
		uint32 id           = this->id();
		uint32 hId          = strategy_.heuId; // remember active heuristic
		strategy_           = params;
		strategy_.id        = id; // keep id
		strategy_.hasConfig = 1;  // strategy is now "up to date"
		if      (!params.ccMinRec)  { delete ccMin_; ccMin_ = 0; }
		else if (!ccMin_)           { ccMin_ = new CCMinRecursive; }
		if (id == params.id || !shared_->seedSolvers()) {
			rng.srand(params.seed);
		}
		else {
			RNG x(14182940); for (uint32 i = 0; i != id; ++i) { x.rand(); }
			rng.srand(x.seed());
		}
		if (hId != params.heuId) { // heuristic has changed
			resetHeuristic();
		}
		else if (heuristic_.get() != 0 && heuristic_.is_owner()) {
			heuristic_->setConfig(params.heuristic);
		}
	}
	if (heuristic_.get() == 0) {
		heuristic_.reset(shared_->configuration()->heuristic(id()));
	}
	postHead_ = &sent_list; // disable post propagators during setup
	initPost_ = 0;          // defer calls to PostPropagator::init()
	heuristic_->startInit(*this);
}

void Solver::updateVars() {
	if (numVars() > shared_->numVars()) {
		popVars(numVars() - shared_->numVars(), false, 0);
	}
	else {
		assign_.resize(shared_->numVars() + 1);
		watches_.resize(assign_.numVars()<<1);
	}
}

bool Solver::cloneDB(const ConstraintDB& db) {
	assert(!hasConflict());
	while (dbIdx_ < (uint32)db.size() && !hasConflict()) {
		if (Constraint* c = db[dbIdx_++]->cloneAttach(*this)) {
			constraints_.push_back(c);
		}
	}
	return !hasConflict();
}
bool Solver::preparePost() {
	if (hasConflict()) { return false; }
	if (initPost_ == 0){
		initPost_ = 1;
		FOR_EACH_POST(x, post_.head()) {
			if (!x->init(*this)) { return false; }
		}
	}
	return shared_->configuration()->addPost(*this);
}

bool Solver::endInit() {
	if (hasConflict()) { return false; }
	heuristic_->endInit(*this);
	if (strategy_.signFix) {
		for (Var v = 1; v <= numVars(); ++v) {
			Literal x = DecisionHeuristic::selectLiteral(*this, v, 0);
			setPref(v, ValueSet::user_value, x.sign() ? value_false : value_true);
		}
	}
	postHead_ = post_.head(); // enable all post propagators
	return propagate() && simplify();
}

bool Solver::endStep(uint32 top, const SolverParams& params) {
	if (!popRootLevel(rootLevel())) { return false; }
	popAuxVar();
	Literal x = shared_->stepLiteral();
	top = std::min(top, (uint32)lastSimp_);
	if (PostPropagator* pp = getPost(PostPropagator::priority_reserved_look)) {
		pp->destroy(this, true);
	}
	if ((value(x.var()) != value_free || force(~x)) && simplify() && this != shared_->master() && shared_->ok()) {
		Solver& m = *shared_->master();
		for (uint32 end = (uint32)assign_.trail.size(); top < end; ++top) {
			Literal u = assign_.trail[top];
			if (u.var() != x.var() && !m.force(u)) { break; }
		}
	}
	if (params.forgetLearnts())   { reduceLearnts(1.0f); }
	if (params.forgetHeuristic()) { resetHeuristic(); }
	if (params.forgetSigns())     { resetPrefs(); }
	if (params.forgetActivities()){ resetLearntActivities(); }
	return true;
}

void Solver::add(Constraint* c) {
	constraints_.push_back(c);
}
bool Solver::add(const ClauseRep& c, bool isNew) {
	typedef ShortImplicationsGraph::ImpType ImpType;
	if (c.prep == 0) {
		return ClauseCreator::create(*this, c, ClauseCreator::clause_force_simplify).ok();
	}
	int added = 0;
	if (c.size > 1) {
		if (allowImplicit(c)) { added = shared_->addImp(static_cast(c.size), c.lits, c.info.type()); }
		else                  { return ClauseCreator::create(*this, c, ClauseCreator::clause_explicit).ok(); }
	}
	else {
		Literal u = c.size ? c.lits[0] : lit_false();
		uint32  ts= sizeVec(trail());
		force(u);
		added     = int(ts != trail().size());
	}
	if (added > 0 && isNew && c.info.learnt()) {
		stats.addLearnt(c.size, c.info.type());
		distribute(c.lits, c.size, c.info);
	}
	return !hasConflict();
}
bool Solver::addPost(PostPropagator* p, bool init) {
	post_.add(p);
	return !init || p->init(*this);
}
bool Solver::addPost(PostPropagator* p)   { return addPost(p, initPost_ != 0); }
void Solver::removePost(PostPropagator* p){ post_.remove(p); }
PostPropagator* Solver::getPost(uint32 prio) const { return post_.find(prio); }
uint32 Solver::receive(SharedLiterals** out, uint32 maxOut) const {
	if (shared_->distributor.get()) {
		return shared_->distributor->receive(*this, out, maxOut);
	}
	return 0;
}
SharedLiterals* Solver::distribute(const Literal* lits, uint32 size, const ConstraintInfo& extra) {
	if (shared_->distributor.get() && !extra.aux() && (size <= 3 || shared_->distributor->isCandidate(size, extra.lbd(), extra.type()))) {
		uint32 initialRefs = shared_->concurrency() - (size <= Clause::MAX_SHORT_LEN || !shared_->physicalShare(extra.type()));
		SharedLiterals* x  = SharedLiterals::newShareable(lits, size, extra.type(), initialRefs);
		shared_->distributor->publish(*this, x);
		stats.addDistributed(extra.lbd(), extra.type());
		return initialRefs == shared_->concurrency() ? x : 0;
	}
	return 0;
}
void Solver::setEnumerationConstraint(Constraint* c) {
	if (enum_) enum_->destroy(this, true);
	enum_ = c;
}

uint32 Solver::numConstraints() const {
	return static_cast(constraints_.size())
		+ (shared_ ? shared_->numBinary()+shared_->numTernary() : 0);
}

Var Solver::pushAuxVar() {
	assert(!lazyRem_);
	Var aux = assign_.addVar();
	setPref(aux, ValueSet::def_value, value_false);
	watches_.insert(watches_.end(), 2, WatchList());
	if (heuristic_.get()) { heuristic_->updateVar(*this, aux, 1); }
	return aux;
}
void Solver::popAuxVar(uint32 num, ConstraintDB* auxCons) {
	num = numVars() >= shared_->numVars() ? std::min(numVars() - shared_->numVars(), num) : 0;
	if (!num) { return; }
	shared_->report("removing aux vars", this);
	Dirty dirty;
	lazyRem_ = &dirty;
	popVars(num, true, auxCons);
	lazyRem_ = 0;
	shared_->report("removing aux watches", this);
	dirty.cleanup(watches_, levels_);
}
Literal Solver::popVars(uint32 num, bool popLearnt, ConstraintDB* popAux) {
	Literal pop = posLit(assign_.numVars() - num);
	uint32  dl  = decisionLevel() + 1;
	for (ImpliedList::iterator it = impliedLits_.begin(); it != impliedLits_.end(); ++it) {
		if (!(it->lit < pop)) { dl = std::min(dl, it->level); }
	}
	for (Var v = pop.var(), end = pop.var()+num; v != end; ++v) {
		if (value(v) != value_free) { dl = std::min(dl, level(v)); }
	}
	// 1. remove aux vars from assignment and watch lists
	if (dl > rootLevel()) {
		undoUntil(dl-1, undo_pop_proj_level);
	}
	else {
		popRootLevel((rootLevel() - dl) + 1);
		if (dl == 0) { // top-level has aux vars - cleanup manually
			uint32 j = shared_->numUnary(), units = assign_.units();
			for (uint32 i = j, end = sizeVec(assign_.trail); i != end; ++i) {
				if (assign_.trail[i] < pop) { assign_.trail[j++] = assign_.trail[i]; }
				else {
					units         -= (i < units);
					assign_.front -= (i < assign_.front);
					lastSimp_     -= (i < lastSimp_);
				}
			}
			shrinkVecTo(assign_.trail, j);
			assign_.setUnits(units);
		}
	}
	for (uint32 n = num; n--;) {
		watches_.back().clear(true);
		watches_.pop_back();
		watches_.back().clear(true);
		watches_.pop_back();
	}
	// 2. remove learnt constraints over aux
	if (popLearnt) {
		shared_->report("removing aux constraints", this);
		ConstraintDB::size_type i, j, end = learnts_.size();
		LitVec cc;
		for (i = j = 0; i != end; ++i) {
			learnts_[j++] = learnts_[i];
			ClauseHead* c = learnts_[i]->clause();
			if (c && c->aux()) {
				cc.clear();
				c->toLits(cc);
				if (std::find_if(cc.begin(), cc.end(), std::not1(std::bind2nd(std::less(), pop))) != cc.end()) {
					c->destroy(this, true);
					--j;
				}
			}
		}
		learnts_.erase(learnts_.begin()+j, learnts_.end());
	}
	if (popAux) { destroyDB(*popAux); }
	// 3. remove vars from solver and heuristic
	assign_.resize(assign_.numVars()-num);
	if (!validVar(tag_.var())) { tag_ = lit_true(); }
	if (heuristic_.get()) {
		heuristic_->updateVar(*this, pop.var(), num);
	}
	return pop;
}

bool Solver::pushRoot(const LitVec& path) {
	// make sure we are on the current root level
	if (!popRootLevel(0) || !simplify() || !propagate()) { return false; }
	// push path
	stats.addPath(path.size());
	for (LitVec::const_iterator it = path.begin(), end = path.end(); it != end; ++it) {
		if (!pushRoot(*it)) { return false; }
	}
	ccInfo_.setActivity(1);
	return true;
}

bool Solver::pushRoot(Literal x) {
	if (hasConflict())                 { return false; }
	if (decisionLevel()!= rootLevel()) { popRootLevel(0);  }
	if (queueSize() && !propagate())   { return false;    }
	if (value(x.var()) != value_free)  { return isTrue(x);}
	assume(x); --stats.choices;
	pushRootLevel();
	return propagate();
}

bool Solver::popRootLevel(uint32 n, LitVec* popped, bool aux)  {
	clearStopConflict();
	uint32 newRoot = levels_.root - std::min(n, rootLevel());
	if (popped && newRoot < rootLevel()) {
		for (uint32 i = newRoot+1; i <= rootLevel(); ++i) {
			Literal x = decision(i);
			if (aux || !auxVar(x.var())) { popped->push_back(x); }
		}
	}
	levels_.root  = newRoot;
	levels_.flip = rootLevel();
	levels_.mode = 0;
	impliedLits_.front = 0;
	bool tagActive     = isTrue(tagLiteral());
	// go back to new root level and re-assert still implied literals
	undoUntil(rootLevel(), undo_pop_proj_level);
	if (tagActive && !isTrue(tagLiteral())) {
		removeConditional();
	}
	return !hasConflict();
}

bool Solver::clearAssumptions()  {
	return popRootLevel(rootLevel())
		&& simplify();
}

void Solver::clearStopConflict() {
	if (hasStopConflict()) {
		levels_.root  = conflict_[1].rep();
		levels_.flip  = conflict_[2].rep();
		assign_.front = conflict_[3].rep();
		conflict_.clear();
	}
}

void Solver::setStopConflict() {
	if (!hasConflict()) {
		// we use the nogood {FALSE} to represent the unrecoverable conflict -
		// note that {FALSE} can otherwise never be a violated nogood because
		// TRUE is always true in every solver
		conflict_.push_back(lit_false());
		// remember the current root-level
		conflict_.push_back(Literal::fromRep(rootLevel()));
		// remember the current bt-level
		conflict_.push_back(Literal::fromRep(backtrackLevel()));
		// remember the current propagation queue
		conflict_.push_back(Literal::fromRep(assign_.front));
	}
	// artificially increase root level -
	// this way, the solver is prevented from resolving the conflict
	pushRootLevel(decisionLevel());
}

void Solver::copyGuidingPath(LitVec& gpOut) {
	uint32 aux = rootLevel()+1;
	gpOut.clear();
	for (uint32 i = 1, end = rootLevel()+1; i != end; ++i) {
		Literal x = decision(i);
		if      (!auxVar(x.var())) { gpOut.push_back(x); }
		else if (i < aux)          { aux = i; }
	}
	for (ImpliedList::iterator it = impliedLits_.begin(); it != impliedLits_.end(); ++it) {
		if (it->level <= rootLevel() && (it->ante.ante().isNull() || it->level < aux) && !auxVar(it->lit.var())) {
			gpOut.push_back(it->lit);
		}
	}
}
bool Solver::splittable() const {
	if (decisionLevel() == rootLevel() || frozenLevel(rootLevel()+1)) { return false; }
	if (numAuxVars()) { // check if gp would contain solver local aux var
		uint32 minAux = rootLevel() + 2;
		for (uint32 i = 1; i != minAux; ++i) {
			if (auxVar(decision(i).var()) && decision(i) != tag_) { return false; }
		}
		for (ImpliedList::iterator it = impliedLits_.begin(); it != impliedLits_.end(); ++it) {
			if (it->ante.ante().isNull() && it->level < minAux && auxVar(it->lit.var()) && it->lit != tag_) { return false; }
		}
	}
	return true;
}
bool Solver::split(LitVec& out) {
	if (!splittable()) { return false; }
	copyGuidingPath(out);
	pushRootLevel();
	out.push_back(~decision(rootLevel()));
	stats.addSplit();
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Solver: Watch management
////////////////////////////////////////////////////////////////////////////////////////
uint32 Solver::numWatches(Literal p) const {
	assert( validVar(p.var()) );
	if (!validWatch(p)) return 0;
	uint32 n = static_cast(watches_[p.id()].size());
	if (!auxVar(p.var())){
		n += shared_->shortImplications().numEdges(p);
	}
	return n;
}

bool Solver::hasWatch(Literal p, Constraint* c) const {
	if (!validWatch(p)) return false;
	const WatchList& pList = watches_[p.id()];
	return std::find_if(pList.right_begin(), pList.right_end(), GenericWatch::EqConstraint(c)) != pList.right_end();
}

bool Solver::hasWatch(Literal p, ClauseHead* h) const {
	if (!validWatch(p)) return false;
	const WatchList& pList = watches_[p.id()];
	return std::find_if(pList.left_begin(), pList.left_end(), ClauseWatch::EqHead(h)) != pList.left_end();
}

GenericWatch* Solver::getWatch(Literal p, Constraint* c) const {
	if (!validWatch(p)) return 0;
	const WatchList& pList = watches_[p.id()];
	WatchList::const_right_iterator it = std::find_if(pList.right_begin(), pList.right_end(), GenericWatch::EqConstraint(c));
	return it != pList.right_end()
		? &const_cast(*it)
		: 0;
}

void Solver::removeWatch(const Literal& p, Constraint* c) {
	if (!validWatch(p)) { return; }
	WatchList& pList = watches_[p.id()];
	if (!lazyRem_ || !lazyRem_->add(p, pList, c)) {
		pList.erase_right(std::find_if(pList.right_begin(), pList.right_end(), GenericWatch::EqConstraint(c)));
	}
}

void Solver::removeWatch(const Literal& p, ClauseHead* h) {
	if (!validWatch(p)) { return; }
	WatchList& pList = watches_[p.id()];
	if (!lazyRem_ || !lazyRem_->add(p, pList, h)) {
		pList.erase_left(std::find_if(pList.left_begin(), pList.left_end(), ClauseWatch::EqHead(h)));
	}
}

bool Solver::removeUndoWatch(uint32 dl, Constraint* c) {
	assert(dl != 0 && dl <= decisionLevel() );
	if (levels_[dl-1].undo) {
		ConstraintDB& uList = *levels_[dl-1].undo;
		if (!lazyRem_ || !lazyRem_->add(dl - 1, uList, c)) {
			ConstraintDB::iterator it = std::find(uList.begin(), uList.end(), c);
			if (it != uList.end()) {
				*it = uList.back();
				uList.pop_back();
				return true;
			}
		}
	}
	return false;
}
void Solver::destroyDB(ConstraintDB& db) {
	if (!db.empty()) {
		Dirty dirty;
		if (!lazyRem_) { lazyRem_ = &dirty; }
		for (ConstraintDB::const_iterator it = db.begin(), end = db.end(); it != end; ++it) {
			(*it)->destroy(this, true);
		}
		db.clear();
		if (lazyRem_ == &dirty) {
			lazyRem_ = 0;
			dirty.cleanup(watches_, levels_);
		}
	}
}
/////////////////////////////////////////////////////////////////////////////////////////
// Solver: Basic DPLL-functions
////////////////////////////////////////////////////////////////////////////////////////

// removes all satisfied binary and ternary clauses as well
// as all constraints for which Constraint::simplify returned true.
bool Solver::simplify() {
	if (decisionLevel() != 0) return true;
	if (hasConflict())        return false;
	if (lastSimp_ != (uint32)assign_.trail.size()) {
		uint32 old = lastSimp_;
		if (!simplifySAT()) { return false; }
		assert(lastSimp_ == (uint32)assign_.trail.size());
		heuristic_->simplify(*this, old);
	}
	if (shufSimp_) { simplifySAT(); }
	return true;
}
Var  Solver::pushTagVar(bool pushToRoot) {
	if (isSentinel(tag_)) { tag_ = posLit(pushAuxVar()); }
	if (pushToRoot)       { pushRoot(tag_); }
	return tag_.var();
}
void Solver::removeConditional() {
	Literal p = ~tagLiteral();
	if (!isSentinel(p)) {
		ConstraintDB::size_type i, j, end = learnts_.size();
		for (i = j = 0; i != end; ++i) {
			ClauseHead* c = learnts_[i]->clause();
			if (!c || !c->tagged()) {
				learnts_[j++] = learnts_[i];
			}
			else {
				c->destroy(this, true);
			}
		}
		learnts_.erase(learnts_.begin()+j, learnts_.end());
	}
}

void Solver::strengthenConditional() {
	Literal p = ~tagLiteral();
	if (!isSentinel(p)) {
		ConstraintDB::size_type i, j, end = learnts_.size();
		for (i = j = 0; i != end; ++i) {
			ClauseHead* c = learnts_[i]->clause();
			if (!c || !c->tagged() || !c->strengthen(*this, p, true).second) {
				learnts_[j++] = learnts_[i];
			}
			else {
				assert((decisionLevel() == rootLevel() || !c->locked(*this)) && "Solver::strengthenConditional(): must not remove locked constraint!");
				c->destroy(this, false);
			}
		}
		learnts_.erase(learnts_.begin()+j, learnts_.end());
	}
}

bool Solver::simplifySAT() {
	if (queueSize() > 0 && !propagate()) {
		return false;
	}
	assert(assign_.qEmpty());
	assign_.front = lastSimp_;
	lastSimp_     = (uint32)assign_.trail.size();
	for (Literal p; !assign_.qEmpty(); ) {
		p = assign_.qPop();
		releaseVec(watches_[p.id()]);
		releaseVec(watches_[(~p).id()]);
		shared_->simplifyShort(*this, p);
	}
	bool shuffle = shufSimp_ != 0;
	shufSimp_    = 0;
	if (shuffle) {
		std::random_shuffle(constraints_.begin(), constraints_.end(), rng);
		std::random_shuffle(learnts_.begin(), learnts_.end(), rng);
	}
	if (isMaster()) { shared_->simplify(shuffle); }
	else            { simplifyDB(*this, constraints_, shuffle); }
	simplifyDB(*this, learnts_, shuffle);
	FOR_EACH_POST(x, postHead_) {
		if (x->simplify(*this, shuffle)) {
			post_.remove(x);
			x->destroy(this, false);
		}
	}
	if (enum_ && enum_->simplify(*this, shuffle)) {
		enum_->destroy(this, false);
		enum_ = 0;
	}
	return true;
}

void Solver::setConflict(Literal p, const Antecedent& a, uint32 data) {
	++stats.conflicts;
	conflict_.push_back(~p);
	if (searchMode() != SolverStrategies::no_learning && !a.isNull()) {
		if (data == UINT32_MAX) {
			a.reason(*this, p, conflict_);
		}
		else {
			// temporarily replace old data with new data
			uint32 saved = assign_.data(p.var());
			assign_.setData(p.var(), data);
			// extract conflict using new data
			a.reason(*this, p, conflict_);
			// restore old data
			assign_.setData(p.var(), saved);
		}
	}
}
bool Solver::force(const ImpliedLiteral& p) {
	// Already implied?
	if (isTrue(p.lit)) {
		if (level(p.lit.var()) <= p.level) { return true; }
		if (ImpliedLiteral* x = impliedLits_.find(p.lit)) {
			if (x->level > p.level) {
				*x = p;
				setReason(p.lit, p.ante.ante(), p.ante.data());
			}
			return true;
		}
	}
	if (undoUntil(p.level) != p.level) {
		// Logically the implication is on level p.level.
		// Store enough information so that p can be re-assigned once we backtrack.
		impliedLits_.add(decisionLevel(), p);
	}
	return (isTrue(p.lit) && setReason(p.lit, p.ante.ante(), p.ante.data())) || force(p.lit, p.ante.ante(), p.ante.data());
}

bool Solver::assume(const Literal& p) {
	if (value(p.var()) == value_free) {
		assert(decisionLevel() != assign_.maxLevel());
		++stats.choices;
		levels_.push_back(DLevel(numAssignedVars(), 0));
		return assign_.assign(p, decisionLevel(), Antecedent());
	}
	return isTrue(p);
}

void Solver::cancelPropagation() {
	assign_.qReset();
	for (PostPropagator* r = *postHead_; r; r = r->next) { r->reset(); }
}

bool Solver::propagate() {
	if (unitPropagate() && postPropagate(0)) {
		assert(queueSize() == 0);
		return true;
	}
	cancelPropagation();
	return false;
}

bool Solver::propagateUntil(PostPropagator* p) {
	assert((!p || *postHead_) && "OP not allowed during init!");
	return unitPropagate() && (p == *postHead_ || postPropagate(p));
}

Constraint::PropResult ClauseHead::propagate(Solver& s, Literal p, uint32&) {
	Literal* head = head_;
	uint32 wLit   = (head[1] == ~p); // pos of false watched literal
	if (s.isTrue(head[1-wLit])) {
		return Constraint::PropResult(true, true);
	}
	else if (!s.isFalse(head[2])) {
		assert(!isSentinel(head[2]) && "Invalid ClauseHead!");
		head[wLit] = head[2];
		head[2]    = ~p;
		s.addWatch(~head[wLit], ClauseWatch(this));
		return Constraint::PropResult(true, false);
	}
	else if (updateWatch(s, wLit)) {
		assert(!s.isFalse(head_[wLit]));
		s.addWatch(~head[wLit], ClauseWatch(this));
		return Constraint::PropResult(true, false);
	}
	return PropResult(s.force(head_[1^wLit], this), true);
}

bool Solver::unitPropagate() {
	assert(!hasConflict());
	Literal p, q, r;
	uint32 idx, ignore, DL = decisionLevel();
	const ShortImplicationsGraph& btig = shared_->shortImplications();
	const uint32 maxIdx = btig.size();
	while ( !assign_.qEmpty() ) {
		p             = assign_.qPop();
		idx           = p.id();
		WatchList& wl = watches_[idx];
		// first: short clause BCP
		if (idx < maxIdx && !btig.propagate(*this, p)) {
			return false;
		}
		// second: clause BCP
		if (wl.left_size() != 0) {
			WatchList::left_iterator it, end, j = wl.left_begin();
			Constraint::PropResult res;
			for (it = wl.left_begin(), end = wl.left_end();  it != end;  ) {
				ClauseWatch& w = *it++;
				res = w.head->ClauseHead::propagate(*this, p, ignore);
				if (res.keepWatch) {
					*j++ = w;
				}
				if (!res.ok) {
					wl.shrink_left(std::copy(it, end, j));
					return false;
				}
			}
			wl.shrink_left(j);
		}
		// third: general constraint BCP
		if (wl.right_size() != 0) {
			WatchList::right_iterator it, end, j = wl.right_begin();
			Constraint::PropResult res;
			for (it = wl.right_begin(), end = wl.right_end(); it != end; ) {
				GenericWatch& w = *it++;
				res = w.propagate(*this, p);
				if (res.keepWatch) {
					*j++ = w;
				}
				if (!res.ok) {
					wl.shrink_right(std::copy(it, end, j));
					return false;
				}
			}
			wl.shrink_right(j);
		}
	}
	return DL || assign_.markUnits();
}

bool Solver::postPropagate(PostPropagator* stop) {
	for (PostPropagator** r = postHead_, *t; *r != stop;) {
		t = *r;
		if (!t->propagateFixpoint(*this, stop)) { return false; }
		assert(queueSize() == 0);
		if (t == *r) { r = &t->next; }
		// else: t was removed during propagate
	}
	return true;
}

bool Solver::test(Literal p, PostPropagator* c) {
	assert(value(p.var()) == value_free && !hasConflict());
	assume(p); --stats.choices;
	uint32 pLevel = decisionLevel();
	freezeLevel(pLevel); // can't split-off this level
	if (propagateUntil(c)) {
		assert(decisionLevel() == pLevel && "Invalid PostPropagators");
		if (c) c->undoLevel(*this);
		undoUntil(pLevel-1);
		return true;
	}
	assert(decisionLevel() == pLevel && "Invalid PostPropagators");
	unfreezeLevel(pLevel);
	cancelPropagation();
	return false;
}

bool Solver::resolveConflict() {
	assert(hasConflict());
	if (decisionLevel() > rootLevel()) {
		if (decisionLevel() != backtrackLevel() && searchMode() != SolverStrategies::no_learning) {
			uint32 uipLevel = analyzeConflict();
			stats.addConflict(decisionLevel(), uipLevel, backtrackLevel(), ccInfo_.lbd());
			if (shared_->reportMode()) {
				sharedContext()->report(NewConflictEvent(*this, cc_, ccInfo_));
			}
			undoUntil( uipLevel );
			return ClauseCreator::create(*this, cc_, ClauseCreator::clause_no_prepare, ccInfo_);
		}
		else {
			return backtrack();
		}
	}
	return false;
}

bool Solver::backtrack() {
	Literal lastChoiceInverted;
	do {
		if (decisionLevel() == rootLevel()) {
			setStopConflict();
			return false;
		}
		lastChoiceInverted = ~decision(decisionLevel());
		undoUntil(decisionLevel() - 1, undo_pop_proj_level);
		setBacktrackLevel(decisionLevel(), undo_pop_bt_level);
	} while (hasConflict() || !force(lastChoiceInverted, 0));
	// remember flipped literal for copyGuidingPath()
	impliedLits_.add(decisionLevel(), ImpliedLiteral(lastChoiceInverted, decisionLevel(), 0));
	return true;
}

bool ImpliedList::assign(Solver& s) {
	assert(front <= lits.size());
	bool ok             = !s.hasConflict();
	const uint32 DL     = s.decisionLevel();
	VecType::iterator j = lits.begin() + front;
	for (VecType::iterator it = j, end = lits.end(); it != end; ++it) {
		if(it->level <= DL) {
			ok = ok && s.force(it->lit, it->ante.ante(), it->ante.data());
			if (it->level < DL || it->ante.ante().isNull()) { *j++ = *it; }
		}
	}
	lits.erase(j, lits.end());
	level = DL * uint32(!lits.empty());
	front = level > s.rootLevel() ? front  : sizeVec(lits);
	return ok;
}
bool Solver::isUndoLevel() const {
	return decisionLevel() > backtrackLevel();
}
uint32 Solver::undoUntilImpl(uint32 level, bool forceSave) {
	level      = std::max( level, backtrackLevel() );
	if (level >= decisionLevel()) { return decisionLevel(); }
	uint32& n  = (levels_.jump = decisionLevel() - level);
	bool sp    = forceSave || (strategy_.saveProgress > 0 && ((uint32)strategy_.saveProgress) <= n);
	bool ok    = conflict_.empty() && levels_.back().freeze == 0;
	conflict_.clear();
	heuristic_->undoUntil( *this, levels_[level].trailPos);
	undoLevel(sp && ok);
	while (--n) { undoLevel(sp); }
	return level;
}
uint32 Solver::undoUntil(uint32 level, uint32 mode) {
	assert(backtrackLevel() >= rootLevel());
	if (level < backtrackLevel() && mode >= levels_.mode) {
		levels_.flip = std::max(rootLevel(), level);
	}
	level = undoUntilImpl(level, (mode & undo_save_phases) != 0);
	if (impliedLits_.active(level)) {
		impliedLits_.assign(*this);
	}
	return level;
}
uint32 Solver::estimateBCP(const Literal& p, int rd) const {
	if (value(p.var()) != value_free) return 0;
	LitVec::size_type first = assign_.assigned();
	LitVec::size_type i     = first;
	Solver& self            = const_cast(*this);
	self.assign_.setValue(p.var(), trueValue(p));
	self.assign_.trail.push_back(p);
	const ShortImplicationsGraph& btig = shared_->shortImplications();
	const uint32 maxIdx = btig.size();
	do {
		Literal x = assign_.trail[i++];
		if (x.id() < maxIdx && !btig.propagateBin(self.assign_, x, 0)) {
			break;
		}
	} while (i < assign_.assigned() && rd-- != 0);
	i = assign_.assigned()-first;
	while (self.assign_.assigned() != first) {
		self.assign_.undoLast();
	}
	return (uint32)i;
}

uint32 Solver::inDegree(WeightLitVec& out) {
	if (decisionLevel() == 0) { return 1; }
	assert(!hasConflict());
	out.reserve((numAssignedVars()-levelStart(1))/10);
	uint32 maxIn = 1;
	uint32 i = sizeVec(assign_.trail), stop = levelStart(1);
	for (LitVec temp; i-- != stop; ) {
		Literal x    = assign_.trail[i];
		uint32  xLev = assign_.level(x.var());
		uint32  xIn  = 0;
		Antecedent xAnte = assign_.reason(x.var());
		if (!xAnte.isNull() && xAnte.type() != Antecedent::Binary) {
			xAnte.reason(*this, x, temp);
			for (LitVec::const_iterator it = temp.begin(); it != temp.end(); ++it) {
				xIn += level(it->var()) != xLev;
			}
			if (xIn) {
				out.push_back(WeightLiteral(x, xIn));
				maxIn = std::max(xIn, maxIn);
			}
			temp.clear();
		}
	}
	return maxIn;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Solver: Private helper functions
////////////////////////////////////////////////////////////////////////////////////////
Solver::ConstraintDB* Solver::allocUndo(Constraint* c) {
	if (undoHead_ == 0) {
		return new ConstraintDB(1, c);
	}
	assert(undoHead_->size() == 1);
	ConstraintDB* r = undoHead_;
	undoHead_ = (ConstraintDB*)undoHead_->front();
	r->clear();
	r->push_back(c);
	return r;
}
void Solver::undoFree(ConstraintDB* x) {
	// maintain a single-linked list of undo lists
	x->clear();
	x->push_back((Constraint*)undoHead_);
	undoHead_ = x;
}
// removes the current decision level
void Solver::undoLevel(bool sp) {
	assert(decisionLevel() != 0 && levels_.back().trailPos != assign_.trail.size() && "Decision Level must not be empty");
	assign_.undoTrail(levels_.back().trailPos, sp);
	if (levels_.back().undo) {
		const ConstraintDB& undoList = *levels_.back().undo;
		for (ConstraintDB::size_type i = 0, end = undoList.size(); i != end; ++i) {
			undoList[i]->undoLevel(*this);
		}
		undoFree(levels_.back().undo);
	}
	levels_.pop_back();
}

inline ClauseHead* clause(const Antecedent& ante) {
	return ante.isNull() || ante.type() != Antecedent::Generic ? 0 : ante.constraint()->clause();
}

bool Solver::resolveToFlagged(const LitVec& in, uint8 vf, LitVec& out, uint32& outLbd) const {
	return const_cast(*this).resolveToFlagged(in, vf, out, outLbd);
}
bool Solver::resolveToFlagged(const LitVec& in, const uint8 vf, LitVec& out, uint32& outLbd) {
	const LitVec& trail = assign_.trail;
	const LitVec* rhs   = ∈
	LitVec temp; out.clear();
	bool ok = true, first = true;
	for (LitVec::size_type tp = trail.size(), resolve = 0;; first = false) {
		Literal p; Var v;
		for (LitVec::const_iterator it = rhs->begin(), end = rhs->end(); it != end; ++it) {
			p = *it ^ first; v = p.var();
			if (!seen(v)) {
				markSeen(v);
				if      (varInfo(v).hasAll(vf)) { markLevel(level(v)); out.push_back(~p); }
				else if (!reason(p).isNull())   { ++resolve; }
				else                            { clearSeen(v); ok = false; break; }
			}
		}
		if (resolve-- == 0) { break; }
		// find next literal to resolve
		while (!seen(trail[--tp]) || varInfo(trail[tp].var()).hasAll(vf)) { ; }
		clearSeen((p = trail[tp]).var());
		reason(p, temp);
		rhs = &temp;
	}
	LitVec::size_type outSize = out.size();
	if (ok && !first) {
		uint32 old = strategy_.ccMinKeepAct;
		strategy_.ccMinKeepAct = 1;
		uint32 antes = SolverStrategies::all_antes;
		if (ccMin_) { ccMinRecurseInit(*ccMin_); }
		for (LitVec::size_type i = 0; i != outSize;) {
			if (!ccRemovable(~out[i], antes-1, ccMin_)) { ++i; }
			else {
				std::swap(out[i], out[--outSize]);
			}
		}
		strategy_.ccMinKeepAct = old;
	}
	CLASP_FAIL_IF(ok && outSize == 0, "Invalid empty clause - was %u!\n", out.size());
	outLbd = 0;
	for (uint32 i = 0, dl, root = 0; i != outSize; ++i) {
		Var v = out[i].var();
		dl    = level(v);
		clearSeen(v);
		if (dl && hasLevel(dl)) {
			unmarkLevel(dl);
			outLbd += (dl > rootLevel()) || (++root == 1);
		}
	}
	for (Var v; outSize != out.size(); out.pop_back()) {
		clearSeen(v = out.back().var());
		unmarkLevel(level(v));
	}
	return ok;
}
void Solver::resolveToCore(LitVec& out) {
	CLASP_ASSERT_CONTRACT_MSG(hasConflict() && !hasStopConflict(), "Function requires valid conflict");
	cc_.clear();
	std::swap(cc_, conflict_);
	if (searchMode() == SolverStrategies::no_learning) {
		for (uint32 i = 1, end = decisionLevel() + 1; i != end; ++i) { cc_.push_back(decision(i)); }
	}
	const LitVec& trail = assign_.trail;
	const LitVec* r = &cc_;
	// resolve all-last uip
	for (uint32 marked = 0, tPos = (uint32)trail.size();; r = &conflict_) {
		for (LitVec::const_iterator it = r->begin(), end = r->end(); it != end; ++it) {
			if (!seen(it->var())) {
				assert(level(it->var()) <= decisionLevel());
				markSeen(it->var());
				++marked;
			}
		}
		if (marked-- == 0) { break; }
		// search for the last marked literal
		while (!seen(trail[--tPos].var())) { ; }
		Literal p = trail[tPos];
		uint32 dl = level(p.var());
		assert(dl);
		clearSeen(p.var());
		conflict_.clear();
		if      (!reason(p).isNull()) { reason(p).reason(*this, p, conflict_); }
		else if (p == decision(dl))   { out.push_back(p); }
	}
	// restore original conflict
	std::swap(cc_, conflict_);
}

// computes the First-UIP clause and stores it in cc_, where cc_[0] is the asserting literal (inverted UIP)
// and cc_[1] is a literal from the asserting level (if > 0)
// RETURN: asserting level of the derived conflict clause
uint32 Solver::analyzeConflict() {
	// must be called here, because we unassign vars during analyzeConflict
	heuristic_->undoUntil( *this, levels_.back().trailPos );
	uint32 onLevel  = 0;        // number of literals from the current DL in resolvent
	uint32 resSize  = 0;        // size of current resolvent
	Literal p;                  // literal to be resolved out next
	cc_.assign(1, p);           // will later be replaced with asserting literal
	Antecedent lhs, rhs, last;  // resolve operands
	const bool doOtfs = strategy_.otfs > 0;
	for (bumpAct_.clear();;) {
		uint32 lhsSize = resSize;
		uint32 rhsSize = 0;
		heuristic_->updateReason(*this, conflict_, p);
		for (LitVec::size_type i = 0; i != conflict_.size(); ++i) {
			Literal& q = conflict_[i];
			uint32 cl  = level(q.var());
			rhsSize   += (cl != 0);
			if (!seen(q.var())) {
				++resSize;
				assert(isTrue(q) && "Invalid literal in reason set!");
				assert(cl > 0 && "Top-Level implication not marked!");
				markSeen(q.var());
				if (cl == decisionLevel()) {
					++onLevel;
				}
				else {
					cc_.push_back(~q);
					markLevel(cl);
				}
			}
		}
		if (resSize != lhsSize) { lhs = 0; }
		if (rhsSize != resSize) { rhs = 0; }
		if (doOtfs && (!rhs.isNull() || !lhs.isNull())) {
			// resolvent subsumes rhs and possibly also lhs
			otfs(lhs, rhs, p, onLevel == 1);
		}
		assert(onLevel > 0 && "CONFLICT MUST BE ANALYZED ON CONFLICT LEVEL!");
		// search for the last assigned literal that needs to be analyzed...
		while (!seen(assign_.last().var())) {
			assign_.undoLast();
		}
		p   = assign_.last();
		rhs = reason(p);
		clearSeen(p.var());
		if (--onLevel == 0) {
			break;
		}
		--resSize; // p will be resolved out next
		last = rhs;
		reason(p, conflict_);
	}
	cc_[0] = ~p; // store the 1-UIP
	assert(decisionLevel() == level(cc_[0].var()));
	ClauseHead* lastRes = 0;
	if (strategy_.otfs > 1 || !lhs.isNull()) {
		if (!lhs.isNull()) {
			lastRes = clause(lhs);
		}
		else if (cc_.size() <= (conflict_.size()+1)) {
			lastRes = clause(last);
		}
	}
	if (strategy_.bumpVarAct && reason(p).learnt()) {
		bumpAct_.push_back(WeightLiteral(p, reason(p).constraint()->activity().lbd()));
	}
	return simplifyConflictClause(cc_, ccInfo_, lastRes);
}

void Solver::otfs(Antecedent& lhs, const Antecedent& rhs, Literal p, bool final) {
	ClauseHead* cLhs = clause(lhs), *cRhs = clause(rhs);
	ClauseHead::BoolPair x;
	if (cLhs) {
		x = cLhs->strengthen(*this, ~p, !final);
		if (!x.first || x.second) {
			cLhs = !x.first ? 0 : otfsRemove(cLhs, 0);
		}
	}
	lhs = cLhs;
	if (cRhs) {
		x = cRhs->strengthen(*this, p, !final);
		if (!x.first || (x.second && otfsRemove(cRhs, 0) == 0)) {
			if (x.first && reason(p) == cRhs) { setReason(p, 0); }
			cRhs = 0;
		}
		if (cLhs && cRhs) {
			// lhs and rhs are now equal - only one of them is needed
			if (!cLhs->learnt()) {
				std::swap(cLhs, cRhs);
			}
			otfsRemove(cLhs, 0);
		}
		lhs = cRhs;
	}
}

ClauseHead* Solver::otfsRemove(ClauseHead* c, const LitVec* newC) {
	bool remStatic = !newC || (newC->size() <= 3 && shared_->allowImplicit(Constraint_t::Conflict));
	if (c->learnt() || remStatic) {
		ConstraintDB& db = (c->learnt() ? learnts_ : constraints_);
		ConstraintDB::iterator it;
		if ((it = std::find(db.begin(), db.end(), c)) != db.end()) {
			if (isMaster() && &db == &constraints_) {
				shared_->removeConstraint(static_cast(it - db.begin()), true);
			}
			else {
				db.erase(it);
				c->destroy(this, true);
			}
			c = 0;
		}
	}
	return c;
}

// minimizes the conflict clause in cc w.r.t selected strategies.
// PRE:
//  - cc is a valid conflict clause and cc[0] is the UIP-literal
//  - all literals in cc except cc[0] are marked
//  - all decision levels of literals in cc are marked
//  - rhs is 0 or a clause that might be subsumed by cc
// RETURN: finalizeConflictClause(cc, info)
uint32 Solver::simplifyConflictClause(LitVec& cc, ConstraintInfo& info, ClauseHead* rhs) {
	// 1. remove redundant literals from conflict clause
	temp_.clear();
	uint32 onAssert = ccMinimize(cc, temp_, strategy_.ccMinAntes, ccMin_);
	uint32 jl       = cc.size() > 1 ? level(cc[1].var()) : 0;
	// clear seen flags of removed literals - keep levels marked
	for (LitVec::size_type x = 0, stop = temp_.size(); x != stop; ++x) {
		clearSeen(temp_[x].var());
	}
	// 2. check for inverse arcs
	if (onAssert == 1 && strategy_.reverseArcs > 0) {
		uint32 maxN = (uint32)strategy_.reverseArcs;
		if      (maxN > 2) maxN = UINT32_MAX;
		else if (maxN > 1) maxN = static_cast(cc.size() / 2);
		markSeen(cc[0].var());
		Antecedent ante = ccHasReverseArc(cc[1], jl, maxN);
		if (!ante.isNull()) {
			// resolve with inverse arc
			conflict_.clear();
			ante.reason(*this, ~cc[1], conflict_);
			ccResolve(cc, 1, conflict_);
		}
		clearSeen(cc[0].var());
	}
	// 3. check if final clause subsumes rhs
	if (rhs) {
		conflict_.clear();
		rhs->toLits(conflict_);
		uint32 open   = (uint32)cc.size();
		markSeen(cc[0].var());
		for (LitVec::const_iterator it = conflict_.begin(), end = conflict_.end(); it != end && open; ++it) {
			// NOTE: at this point the DB might not be fully simplified,
			//       e.g. because of mt or lookahead, hence we must explicitly
			//       check for literals assigned on DL 0
			open -= level(it->var()) > 0 && seen(it->var());
		}
		rhs = open ? 0 : otfsRemove(rhs, &cc);
		if (rhs) { // rhs is subsumed by cc but could not be removed.
			// TODO: we could reuse rhs instead of learning cc
			//       but this would complicate the calling code.
			ClauseHead::BoolPair r(true, false);
			if (cc_.size() < conflict_.size()) {
				//     For now, we only try to strengthen rhs.
				for (LitVec::const_iterator it = conflict_.begin(), end = conflict_.end(); it != end && r.first; ++it) {
					if (!seen(it->var()) || level(it->var()) == 0) {
						r = rhs->strengthen(*this, *it, false);
					}
				}
				if (!r.first) { rhs = 0; }
			}
		}
		clearSeen(cc[0].var());
	}
	// 4. finalize
	uint32 repMode = cc.size() < std::max(strategy_.compress, decisionLevel()+1) ? 0 : strategy_.ccRepMode;
	jl = finalizeConflictClause(cc, info, repMode);
	// 5. bump vars implied by learnt constraints with small lbd
	if (!bumpAct_.empty()) {
		WeightLitVec::iterator j = bumpAct_.begin();
		weight_t newLbd = info.lbd();
		for (WeightLitVec::iterator it = bumpAct_.begin(), end = bumpAct_.end(); it != end; ++it) {
			if (it->second < newLbd) {
				it->second = 1 + (it->second <= 2);
				*j++ = *it;
			}
		}
		bumpAct_.erase(j, bumpAct_.end());
		heuristic_->bump(*this, bumpAct_, 1.0);
	}
	bumpAct_.clear();
	// 6. clear level flags of redundant literals
	for (LitVec::size_type x = 0, stop = temp_.size(); x != stop; ++x) {
		unmarkLevel(level(temp_[x].var()));
	}
	temp_.clear();
	return jl;
}

// conflict clause minimization
// PRE:
//  - cc is an asserting clause and cc[0] is the asserting literal
//  - all literals in cc are marked as seen
//  -  if ccMin != 0, all decision levels of literals in cc are marked
// POST:
//  - redundant literals were added to removed
//  - if (cc.size() > 1): cc[1] is a literal from the asserting level
// RETURN
//  - the number of literals from the asserting level
uint32 Solver::ccMinimize(LitVec& cc, LitVec& removed, uint32 antes, CCMinRecursive* ccMin) {
	if (ccMin) { ccMinRecurseInit(*ccMin); }
	// skip the asserting literal
	LitVec::size_type j = 1;
	uint32 assertLevel  = 0;
	uint32 assertPos    = 1;
	uint32 onAssert     = 0;
	uint32 varLevel     = 0;
	for (LitVec::size_type i = 1; i != cc.size(); ++i) {
		if (antes == 0 || !ccRemovable(~cc[i], antes-1, ccMin)) {
			if ( (varLevel = level(cc[i].var())) > assertLevel ) {
				assertLevel = varLevel;
				assertPos   = static_cast(j);
				onAssert    = 0;
			}
			onAssert += (varLevel == assertLevel);
			cc[j++] = cc[i];
		}
		else {
			removed.push_back(cc[i]);
		}
	}
	cc.erase(cc.begin()+j, cc.end());
	if (assertPos != 1) {
		std::swap(cc[1], cc[assertPos]);
	}
	return onAssert;
}
void Solver::ccMinRecurseInit(CCMinRecursive& ccMin) {
	ccMin.open = incEpoch(numVars() + 1, 2) - 2;
}
bool Solver::ccMinRecurse(CCMinRecursive& ccMin, Literal p) const {
	CCMinRecursive::State st = ccMin.decodeState(epoch_[p.var()]);
	if (st == CCMinRecursive::state_poison) { return false; }
	if (st == CCMinRecursive::state_open)   { ccMin.push(p.unflag()); }
	return true;
}

// returns true if p is redundant in current conflict clause
bool Solver::ccRemovable(Literal p, uint32 antes, CCMinRecursive* ccMin) {
	const Antecedent& ante = reason(p);
	if (ante.isNull() || !(antes <= (uint32)ante.type())) {
		return false;
	}
	if (!ccMin) { return ante.minimize(*this, p, 0); }
	// recursive minimization
	assert(ccMin->todo.empty());
	CCMinRecursive::State dfsState = CCMinRecursive::state_removable;
	ccMin->push(p.unflag());
	for (Literal x;; ) {
		x = ccMin->pop();
		assert(!seen(x.var()) || x == p);
		if (x.flagged()) {
			if (x == p) return dfsState == CCMinRecursive::state_removable;
			epoch_[x.var()] = ccMin->encodeState(dfsState);
		}
		else if (dfsState != CCMinRecursive::state_poison) {
			CCMinRecursive::State temp = ccMin->decodeState(epoch_[x.var()]);
			if (temp == CCMinRecursive::state_open) {
				assert(value(x.var()) != value_free && hasLevel(level(x.var())));
				ccMin->push(x.flag());
				const Antecedent& next = reason(x);
				if (next.isNull() || !(antes <= (uint32)next.type()) || !next.minimize(*this, x, ccMin)) {
					dfsState = CCMinRecursive::state_poison;
				}
			}
			else if (temp == CCMinRecursive::state_poison) {
				dfsState = temp;
			}
		}
	}
}

// checks whether there is a valid "inverse arc" for the given literal p that can be used
// to resolve p out of the current conflict clause
// PRE:
//  - all literals in the current conflict clause are marked
//  - p is a literal of the current conflict clause and level(p) == maxLevel
// RETURN
//  - An antecedent that is an "inverse arc" for p or null if no such antecedent exists.
Antecedent Solver::ccHasReverseArc(Literal p, uint32 maxLevel, uint32 maxNew) {
	assert(seen(p.var()) && isFalse(p) && level(p.var()) == maxLevel);
	const ShortImplicationsGraph& btig = shared_->shortImplications();
	Antecedent ante;
	if (p.id() < btig.size() && btig.reverseArc(*this, p, maxLevel, ante)) { return ante; }
	WatchList& wl = watches_[p.id()];
	for (WatchList::left_iterator it = wl.left_begin(), end = wl.left_end();  it != end;  ++it) {
		if (it->head->isReverseReason(*this, ~p, maxLevel, maxNew)) {
			return it->head;
		}
	}
	return ante;
}

// removes cc[pos] by resolving cc with reason
void Solver::ccResolve(LitVec& cc, uint32 pos, const LitVec& reason) {
	heuristic_->updateReason(*this, reason, cc[pos]);
	Literal x;
	for (LitVec::size_type i = 0; i != reason.size(); ++i) {
		x = reason[i];
		assert(isTrue(x));
		if (!seen(x.var())) {
			markLevel(level(x.var()));
			cc.push_back(~x);
		}
	}
	clearSeen(cc[pos].var());
	unmarkLevel(level(cc[pos].var()));
	cc[pos] = cc.back();
	cc.pop_back();
}

// computes asserting level and lbd of cc and clears flags.
// POST:
//  - literals and decision levels in cc are no longer marked
//  - if cc.size() > 1: cc[1] is a literal from the asserting level
// RETURN: asserting level of conflict clause.
uint32 Solver::finalizeConflictClause(LitVec& cc, ConstraintInfo& info, uint32 ccRepMode) {
	// 2. clear flags and compute lbd
	uint32  lbd         = 1;
	uint32  onRoot      = 0;
	uint32  varLevel    = 0;
	uint32  assertLevel = 0;
	uint32  assertPos   = 1;
	uint32  maxVar      = cc[0].var();
	Literal tagLit      = ~tagLiteral();
	bool    tagged      = false;
	for (LitVec::size_type i = 1; i != cc.size(); ++i) {
		Var v = cc[i].var();
		clearSeen(v);
		if (cc[i] == tagLit) { tagged = true; }
		if (v > maxVar)      { maxVar = v;    }
		if ( (varLevel = level(v)) > assertLevel ) {
			assertLevel = varLevel;
			assertPos   = static_cast(i);
		}
		if (hasLevel(varLevel)) {
			unmarkLevel(varLevel);
			lbd += (varLevel > rootLevel()) || (++onRoot == 1);
		}
	}
	if (assertPos != 1) { std::swap(cc[1], cc[assertPos]); }
	if (ccRepMode == SolverStrategies::cc_rep_dynamic) {
		ccRepMode = double(lbd)/double(decisionLevel()) > .66 ? SolverStrategies::cc_rep_decision : SolverStrategies::cc_rep_uip;
	}
	if (ccRepMode) {
		maxVar = cc[0].var(), tagged = false, lbd = 1;
		if (ccRepMode == SolverStrategies::cc_rep_decision) {
			// replace cc with decision sequence
			cc.resize(assertLevel+1);
			for (uint32 i = assertLevel; i;){
				Literal x = ~decision(i--);
				cc[lbd++] = x;
				if (x == tagLit)     { tagged = true; }
				if (x.var() > maxVar){ maxVar = x.var(); }
			}
		}
		else {
			// replace cc with all uip clause
			uint32 marked = sizeVec(cc) - 1;
			while (cc.size() > 1) { markSeen(~cc.back()); cc.pop_back(); }
			for (LitVec::const_iterator tr = assign_.trail.end(), next, stop; marked;) {
				while (!seen(*--tr)) { ; }
				bool n = --marked != 0 && !reason(*tr).isNull();
				clearSeen(tr->var());
				if (n) { for (next = tr, stop = assign_.trail.begin() + levelStart(level(tr->var())); next-- != stop && !seen(*next);) { ; } }
				if (!n || level(next->var()) != level(tr->var())) {
					cc.push_back(~*tr);
					if (tr->var() == tagLit.var()){ tagged = true; }
					if (tr->var() > maxVar)       { maxVar = tr->var(); }
				}
				else {
					for (reason(*tr, conflict_); !conflict_.empty(); conflict_.pop_back()) {
						if (!seen(conflict_.back())) { ++marked; markSeen(conflict_.back()); }
					}
				}
			}
			lbd = sizeVec(cc);
		}
	}
	info.setScore(makeScore(ccInfo_.activity(), lbd));
	info.setTagged(tagged);
	info.setAux(auxVar(maxVar));
	return assertLevel;
}

// (inefficient) default implementation
bool Constraint::minimize(Solver& s, Literal p, CCMinRecursive* rec) {
	LitVec temp;
	reason(s, p, temp);
	for (LitVec::size_type i = 0; i != temp.size(); ++i) {
		if (!s.ccMinimize(temp[i], rec)) {
			return false;
		}
	}
	return true;
}

// Selects next branching literal
bool Solver::decideNextBranch(double f) {
	if (f <= 0.0 || rng.drand() >= f || numFreeVars() == 0) {
		return heuristic_->select(*this);
	}
	// select randomly
	Literal choice;
	uint32 maxVar = numVars() + 1;
	for (uint32 v = rng.irand(maxVar);;) {
		if (value(v) == value_free) {
			choice    = heuristic_->selectLiteral(*this, v, 0);
			break;
		}
		if (++v == maxVar) { v = 1; }
	}
	return assume(choice);
}
void Solver::resetLearntActivities() {
	for (ConstraintDB::size_type i = 0, end = learnts_.size(); i != end; ++i) {
		learnts_[i]->resetActivity();
	}
}
// Removes up to remFrac% of the learnt nogoods but
// keeps those that are locked or are highly active.
Solver::DBInfo Solver::reduceLearnts(float remFrac, const ReduceStrategy& rs) {
	uint32 oldS = numLearntConstraints();
	uint32 remM = static_cast(oldS * std::max(0.0f, remFrac));
	DBInfo r    = {0,0,0};
	CmpScore cmp(learnts_, (ReduceStrategy::Score)rs.score, rs.glue, rs.protect);
	if (remM >= oldS || !remM || rs.algo == ReduceStrategy::reduce_sort) {
		r = reduceSortInPlace(remM, cmp, false);
	}
	else if (rs.algo == ReduceStrategy::reduce_stable) { r = reduceSort(remM, cmp);  }
	else if (rs.algo == ReduceStrategy::reduce_heap)   { r = reduceSortInPlace(remM, cmp, true);}
	else                                               { r = reduceLinear(remM, cmp); }
	stats.addDeleted(oldS - r.size);
	shrinkVecTo(learnts_, r.size);
	return r;
}
// Removes up to maxR of the learnt nogoods.
// Keeps those that are locked or have a high activity and
// does not reorder learnts_.
Solver::DBInfo Solver::reduceLinear(uint32 maxR, const CmpScore& sc) {
	// compute average activity
	uint64 scoreSum = 0;
	for (LitVec::size_type i = 0; i != learnts_.size(); ++i) {
		scoreSum += sc.score(learnts_[i]->activity());
	}
	double avgAct = (scoreSum / (double) numLearntConstraints());
	// constraints with socre > 1.5 times the average are "active"
	double scoreThresh = avgAct * 1.5;
	double scoreMax    = (double)sc.score(makeScore(Clasp::ACT_MAX, 1));
	if (scoreThresh > scoreMax) {
		scoreThresh = (scoreMax + (scoreSum / (double) numLearntConstraints())) / 2.0;
	}
	// remove up to maxR constraints but keep "active" and locked once
	DBInfo res = {0,0,0};
	typedef ConstraintScore ScoreType;
	for (LitVec::size_type i = 0; i != learnts_.size(); ++i) {
		Constraint* c = learnts_[i];
		ScoreType a   = c->activity();
		bool isLocked = c->locked(*this);
		bool isGlue   = sc.score(a) > scoreThresh || sc.isGlue(a);
		if (maxR == 0 || isLocked || isGlue || sc.isFrozen(a)) {
			res.pinned += isGlue;
			res.locked += isLocked;
			learnts_[res.size++] = c;
			c->decreaseActivity();
		}
		else {
			--maxR;
			c->destroy(this, true);
		}
	}
	return res;
}

// Sorts learnt constraints by score and removes the
// maxR constraints with the lowest score without
// reordering learnts_.
Solver::DBInfo Solver::reduceSort(uint32 maxR, const CmpScore& sc) {
	typedef PodVector::type HeapType;
	DBInfo   res  = {0,0,0};
	HeapType heap;
	heap.reserve(maxR = std::min(maxR, (uint32)learnts_.size()));
	bool isGlue, isLocked;
	for (LitVec::size_type i = 0; i != learnts_.size(); ++i) {
		Constraint* c = learnts_[i];
		CmpScore::ViewPair vp(toU32(i), c->activity());
		res.pinned += (isGlue   = sc.isGlue(vp.second));
		res.locked += (isLocked = c->locked(*this));
		if (!isLocked && !isGlue && !sc.isFrozen(vp.second)) {
			if (maxR) { // populate heap with first maxR constraints
				heap.push_back(vp);
				if (--maxR == 0) { std::make_heap(heap.begin(), heap.end(), sc); }
			}
			else if (sc(vp, heap[0])) { // replace max element in heap
				std::pop_heap(heap.begin(), heap.end(), sc);
				heap.back() = vp;
				std::push_heap(heap.begin(), heap.end(), sc);
			}
		}
	}
	// Remove all constraints in heap - those are "inactive".
	for (HeapType::const_iterator it = heap.begin(), end = heap.end(); it != end; ++it) {
		learnts_[it->first]->destroy(this, true);
		learnts_[it->first] = 0;
	}
	// Cleanup db and decrease activity of remaining constraints.
	uint32 j = 0;
	for (LitVec::size_type i = 0; i != learnts_.size(); ++i) {
		if (Constraint* c = learnts_[i]) {
			c->decreaseActivity();
			learnts_[j++] = c;
		}
	}
	res.size = j;
	return res;
}

// Sorts the learnt db by score and removes the first
// maxR constraints (those with the lowest score).
Solver::DBInfo Solver::reduceSortInPlace(uint32 maxR, const CmpScore& sc, bool partial) {
	DBInfo res = {0,0,0};
	ConstraintDB::iterator nEnd = learnts_.begin();
	maxR = std::min(maxR, (uint32)learnts_.size());
	bool isGlue, isLocked;
	typedef ConstraintScore ScoreType;
	if (!partial) {
		// sort whole db and remove first maxR constraints
		if (maxR && maxR != learnts_.size()) std::stable_sort(learnts_.begin(), learnts_.end(), sc);
		for (ConstraintDB::iterator it = learnts_.begin(), end = learnts_.end(); it != end; ++it) {
			Constraint* c = *it;
			ScoreType a = c->activity();
			res.pinned += (isGlue = sc.isGlue(a));
			res.locked += (isLocked = c->locked(*this));
			if (!maxR || isLocked || isGlue || sc.isFrozen(a)) {
				c->decreaseActivity();
				*nEnd++ = c;
			}
			else {
				c->destroy(this, true);
				--maxR;
			}
		}
	}
	else {
		ConstraintDB::iterator hBeg = learnts_.begin();
		ConstraintDB::iterator hEnd = learnts_.begin();
		for (ConstraintDB::iterator it = learnts_.begin(), end = learnts_.end(); it != end; ++it) {
			Constraint* c = *it;
			ScoreType a = c->activity();
			res.pinned += (isGlue = sc.isGlue(a));
			res.locked += (isLocked = c->locked(*this));
			if      (isLocked || isGlue || sc.isFrozen(a)) { continue; }
			else if (maxR) {
				*it     = *hEnd;
				*hEnd++ = c;
				if (--maxR == 0) { std::make_heap(hBeg, hEnd, sc); }
			}
			else if (sc(c, learnts_[0])) {
				std::pop_heap(hBeg, hEnd, sc);
				*it      = *(hEnd-1);
				*(hEnd-1)= c;
				std::push_heap(hBeg, hEnd, sc);
			}
		}
		// remove all constraints in heap
		for (ConstraintDB::iterator it = hBeg; it != hEnd; ++it) {
			(*it)->destroy(this, true);
		}
		// copy remaining constraints down
		for (ConstraintDB::iterator it = hEnd, end = learnts_.end(); it != end; ++it) {
			Constraint* c = *it;
			c->decreaseActivity();
			*nEnd++ = c;
		}
	}
	res.size = static_cast(std::distance(learnts_.begin(), nEnd));
	return res;
}
uint32 Solver::incEpoch(uint32 size, uint32 n) {
	if (size > epoch_.size())         { epoch_.resize(size, 0u); }
	if ((UINT32_MAX - epoch_[0]) < n) { epoch_.assign(epoch_.size(), 0u); }
	return epoch_[0] += n;
}
uint32 Solver::countLevels(const Literal* first, const Literal* last, uint32 maxLevel) {
	if (maxLevel < 2) { return uint32(maxLevel && first != last); }
	CLASP_FAIL_IF(ccMin_ && !ccMin_->todo.empty(), "Must not be called during minimization!");
	uint32 n = 0;
	for (uint32 epoch = incEpoch(sizeVec(levels_) + 1); first != last; ++first) {
		assert(value(first->var()) != value_free);
		uint32& levEpoch = epoch_[level(first->var())];
		if (levEpoch != epoch) {
			levEpoch = epoch;
			if (++n == maxLevel) { break; }
		}
	}
	return n;
}

void Solver::updateBranch(uint32 n) {
	int32 dl = (int32)decisionLevel(), xl = static_cast(cflStamp_.size())-1;
	if      (xl > dl) { do { n += cflStamp_.back(); cflStamp_.pop_back(); } while (--xl != dl); }
	else if (dl > xl) { cflStamp_.insert(cflStamp_.end(), dl - xl, 0); }
	cflStamp_.back() += n;
}
bool Solver::reduceReached(const SearchLimits& limits) const {
	return numLearntConstraints() > limits.learnts || memUse_ > limits.memory;
}
bool Solver::restartReached(const SearchLimits& limits) const {
	uint64 n = !limits.restart.local || cflStamp_.empty() ? limits.used : cflStamp_.back();
	return n >= limits.restart.conflicts || (limits.restart.dynamic && limits.restart.dynamic->reached());
}
/////////////////////////////////////////////////////////////////////////////////////////
// The basic DPLL-like search-function
/////////////////////////////////////////////////////////////////////////////////////////
ValueRep Solver::search(SearchLimits& limit, double rf) {
	assert(!isFalse(tagLiteral()));
	SearchLimits::BlockPtr block = limit.restart.block;
	rf = std::max(0.0, std::min(1.0, rf));
	lower.reset();
	if (limit.restart.local && decisionLevel() == rootLevel()) { cflStamp_.assign(decisionLevel()+1, 0); }
	do {
		for (bool conflict = hasConflict() || !propagate() || !simplify(), local = limit.restart.local;;) {
			if (conflict) {
				uint32 n = 1, ts;
				do {
					if (block && block->push(ts = numAssignedVars()) && ts > block->scaled()) {
						if (limit.restart.dynamic) { limit.restart.dynamic->resetRun(); }
						else                       { limit.restart.conflicts += block->inc; }
						block->next = block->n + block->inc;
					}
				} while (resolveConflict() && !propagate() && (++n, true));
				limit.used += n;
				if (local) { updateBranch(n); }
				if (hasConflict() || (decisionLevel() == 0 && !simplify())) { return value_false; }
				if (numFreeVars()) {
					if (limit.used >= limit.conflicts) { return value_free; }
					if (restartReached(limit))         { return value_free; }
					if (reduceReached(limit))          { return value_free; }
				}
			}
			if (decideNextBranch(rf)) { conflict = !propagate(); }
			else                      { break; }
		}
	} while (!isModel());
	temp_.clear();
	model.clear(); model.reserve(numVars()+1);
	for (Var v = 0; v <= numVars(); ++v) { model.push_back(value(v)); }
	if (satPrepro()) { satPrepro()->extendModel(model, temp_); }
	return value_true;
}
ValueRep Solver::search(uint64 maxC, uint32 maxL, bool local, double rp) {
	SearchLimits limit;
	limit.restart.conflicts = maxC;
	limit.restart.local     = local;
	limit.learnts = maxL;
	return search(limit, rp);
}
bool Solver::isModel() {
	if (hasConflict()) { return false; }
	FOR_EACH_POST(x, post_.head()) {
		if (!x->isModel(*this)) { return false; }
	}
	return !enumerationConstraint() || enumerationConstraint()->valid(*this);
}
/////////////////////////////////////////////////////////////////////////////////////////
// Free functions
/////////////////////////////////////////////////////////////////////////////////////////
void destroyDB(Solver::ConstraintDB& db, Solver* s, bool detach) {
	if (s && detach) {
		s->destroyDB(db);
		return;
	}
	while (!db.empty()) {
		db.back()->destroy(s, detach);
		db.pop_back();
	}
}
}
clasp-3.2.2/libclasp/src/solver_strategies.cpp000066400000000000000000000267541304134206100214600ustar00rootroot00000000000000//
// Copyright (c) Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// SolverStrategies / SolverParams
/////////////////////////////////////////////////////////////////////////////////////////
SolverStrategies::SolverStrategies() {
	struct X { uint32 z[2]; };
	static_assert(sizeof(SolverStrategies) == sizeof(X), "Unsupported Padding");
	std::memset(this, 0, sizeof(SolverStrategies));
	ccMinAntes = all_antes;
	initWatches= SolverStrategies::watch_rand;
	search     = use_learning;
}
void SolverStrategies::prepare() {
	if (search == SolverStrategies::no_learning) {
		compress    = 0;
		saveProgress= 0;
		reverseArcs = 0;
		otfs        = 0;
		updateLbd   = 0;
		ccMinAntes  = SolverStrategies::no_antes;
		bumpVarAct  = 0;
	}
}
HeuParams::HeuParams() {
	std::memset(this, 0, sizeof(HeuParams));
	other = other_auto;
	moms  = 1;
}
SolverParams::SolverParams() {
	struct X { uint32 strat[2]; uint32 self[4]; };
	static_assert(sizeof(SolverParams) == sizeof(X), "Unsupported Padding");
	std::memset(&seed, 0, sizeof(uint32)*2);
	seed = RNG().seed();
}
uint32 SolverParams::prepare() {
	uint32 res = 0;
	if (search == SolverStrategies::no_learning && Heuristic_t::isLookback(heuId)) {
		heuId = Heuristic_t::None;
		res  |= 1;
	}
	if (heuId == Heuristic_t::Unit) {
		if (!Lookahead::isType(lookType)) { res |= 2; lookType = Var_t::Atom; }
		lookOps = 0;
	}
	if (heuId != Heuristic_t::Domain && (heuristic.domPref || heuristic.domMod)) {
		res |= 4;
		heuristic.domPref= 0;
		heuristic.domMod = 0;
	}
	SolverStrategies::prepare();
	return res;
}
/////////////////////////////////////////////////////////////////////////////////////////
// ScheduleStrategy
/////////////////////////////////////////////////////////////////////////////////////////
double growR(uint32 idx, double g) { return pow(g, (double)idx); }
double addR(uint32 idx, double a)  { return a * idx; }
uint32 lubyR(uint32 idx)           {
	uint32 i = idx + 1;
	while ((i & (i+1)) != 0) {
		i    -= ((1u << log2(i)) - 1);
	}
	return (i+1)>>1;
}
ScheduleStrategy::ScheduleStrategy(Type t, uint32 b, double up, uint32 lim)
	: base(b), type(t), idx(0), len(lim), grow(0.0)  {
	if      (t == Geometric)  { grow = static_cast(std::max(1.0, up)); }
	else if (t == Arithmetic) { grow = static_cast(std::max(0.0, up)); }
	else if (t == User)       { grow = static_cast(std::max(0.0, up)); }
	else if (t == Luby && lim){ len  = std::max(uint32(2), (static_cast(std::pow(2.0, std::ceil(log(double(lim))/log(2.0)))) - 1)*2); }
}

uint64 ScheduleStrategy::current() const {
	enum { t_add = ScheduleStrategy::Arithmetic, t_luby = ScheduleStrategy::Luby };
	if      (base == 0)     return UINT64_MAX;
	else if (type == t_add) return static_cast(addR(idx, grow)  + base);
	else if (type == t_luby)return static_cast(lubyR(idx)) * base;
	uint64 x = static_cast(growR(idx, grow) * base);
	return x + !x;
}
uint64 ScheduleStrategy::next() {
	if (++idx != len) { return current(); }
	// length reached or overflow
	len = (len + !!idx) << uint32(type == Luby);
	idx = 0;
	return current();
}
void ScheduleStrategy::advanceTo(uint32 n) {
	if (!len || n < len)       {
		idx = n;
		return;
	}
	if (type != Luby) {
		double dLen = len;
		uint32 x    = uint32(sqrt(dLen * (4.0 * dLen - 4.0) + 8.0 * double(n+1))-2*dLen+1)/2;
    idx         = n - uint32(x*dLen+double(x-1.0)*x/2.0);
    len        += x;
		return;
	}
	while (n >= len) {
		n   -= len++;
		len *= 2;
	}
	idx = n;
}
/////////////////////////////////////////////////////////////////////////////////////////
// RestartParams
/////////////////////////////////////////////////////////////////////////////////////////
RestartParams::RestartParams()
	: sched()
	, blockScale(1.4f), blockWindow(0), blockFirst(0)
	, counterRestart(0), counterBump(9973)
	, shuffle(0), shuffleNext(0)
	, upRestart(0), cntLocal(0), dynRestart(0) {
	static_assert(sizeof(RestartParams) == sizeof(ScheduleStrategy) + (3 * sizeof(uint32)) + sizeof(float), "Invalid structure alignment");
}
void RestartParams::disable() {
	std::memset(this, 0, sizeof(RestartParams));
	sched = ScheduleStrategy::none();
}
uint32 RestartParams::prepare(bool withLookback) {
	if (!withLookback || sched.disabled()) {
		disable();
	}
	return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// ReduceParams
/////////////////////////////////////////////////////////////////////////////////////////
uint32 ReduceParams::getLimit(uint32 base, double f, const Range32& r) {
	base = (f != 0.0 ? (uint32)std::min(base*f, double(UINT32_MAX)) : UINT32_MAX);
	return r.clamp( base );
}
uint32 ReduceParams::getBase(const SharedContext& ctx) const {
	uint32 st = strategy.estimate != ReduceStrategy::est_dynamic || ctx.isExtended() ? strategy.estimate : (uint32)ReduceStrategy::est_num_constraints;
	switch(st) {
		default:
		case ReduceStrategy::est_dynamic        : {
			uint32 m = std::min(ctx.stats().vars.num, ctx.stats().numConstraints());
			uint32 M = std::max(ctx.stats().vars.num, ctx.stats().numConstraints());
			return M > (m * 10) ? M : m;
		}
		case ReduceStrategy::est_con_complexity : return ctx.stats().complexity;
		case ReduceStrategy::est_num_constraints: return ctx.stats().numConstraints();
		case ReduceStrategy::est_num_vars       : return ctx.stats().vars.num;
	}
}
void ReduceParams::disable() {
	cflSched  = ScheduleStrategy::none();
	growSched = ScheduleStrategy::none();
	strategy.fReduce = 0;
	fGrow     = 0.0f; fInit = 0.0f; fMax = 0.0f;
	initRange = Range(UINT32_MAX, UINT32_MAX);
	maxRange  = UINT32_MAX;
	memMax    = 0;
}
Range32 ReduceParams::sizeInit(const SharedContext& ctx) const {
	if (!growSched.disabled() || growSched.defaulted()) {
		uint32 base = getBase(ctx);
		uint32 lo   = std::min(getLimit(base, fInit, initRange), maxRange);
		uint32 hi   = getLimit(base, fMax, Range32(lo, maxRange));
		return Range32(lo, hi);
	}
	return Range32(maxRange, maxRange);
}
uint32 ReduceParams::cflInit(const SharedContext& ctx) const {
	return cflSched.disabled() ? 0 : getLimit(getBase(ctx), fInit, initRange);
}
uint32 ReduceParams::prepare(bool withLookback) {
	if (!withLookback || fReduce() == 0.0f) {
		disable();
		return 0;
	}
	if (cflSched.defaulted() && growSched.disabled() && !growSched.defaulted()) {
		cflSched = ScheduleStrategy::arith(4000, 600);
	}
	if (fMax != 0.0f) { fMax = std::max(fMax, fInit); }
	return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// SolveParams
/////////////////////////////////////////////////////////////////////////////////////////
SolveParams::SolveParams()
	: randRuns(0u), randConf(0u)
	, randProb(0.0f) {
}
uint32 SolveParams::prepare(bool withLookback) {
	return restart.prepare(withLookback) | reduce.prepare(withLookback);
}
bool SolveParams::randomize(Solver& s) const {
	for (uint32 r = 0, c = randConf; r != randRuns && c; ++r) {
		if (s.search(c, UINT32_MAX, false, 1.0) != value_free) { return !s.hasConflict(); }
		s.undoUntil(0);
	}
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Configurations
/////////////////////////////////////////////////////////////////////////////////////////
Configuration::~Configuration() {}
Configuration* Configuration::config(const char* n) {
	return !n || !*n || ((*n == '.' || *n == '/') && !n[1]) ? this : 0;
}
bool UserConfiguration::addPost(Solver& s) const {
	const SolverOpts& x = solver(s.id());
	bool  ok            = true;
	if (Lookahead::isType(x.lookType)) {
		PostPropagator* pp = s.getPost(PostPropagator::priority_reserved_look);
		if (pp) { pp->destroy(&s, true); }
		Lookahead::Params p(static_cast(x.lookType));
		p.nant(x.heuristic.nant != 0);
		p.limit(x.lookOps);
		ok = s.addPost(new Lookahead(p));
	}
	return ok;
}
BasicSatConfig::BasicSatConfig() {
	solver_.push_back(SolverParams());
	search_.push_back(SolveParams());
	heu_ = 0;
}
void BasicSatConfig::prepare(SharedContext& ctx) {
	uint32 warn = 0;
	for (uint32 i = 0, end = solver_.size(), mod = search_.size(); i != end; ++i) {
		warn |= solver_[i].prepare();
		warn |= search_[i%mod].prepare(solver_[i].search != SolverStrategies::no_learning);
		if (solver_[i].updateLbd == 0 && search_[i%mod].reduce.strategy.protect) { warn |= 8; }
	}
	if ((warn & 1) != 0) { ctx.warn("Selected heuristic requires lookback strategy!"); }
	if ((warn & 2) != 0) { ctx.warn("Heuristic 'Unit' implies lookahead. Using 'atom'."); }
	if ((warn & 4) != 0) { ctx.warn("Domain options require heuristic 'Domain'!"); }
	if ((warn & 8) != 0) { ctx.warn("Deletion protection requires LBD updates, which are off!"); }
}
DecisionHeuristic* BasicSatConfig::heuristic(uint32 i)  const {
	const SolverParams& p = BasicSatConfig::solver(i);
	Heuristic_t::Type hId = static_cast(p.heuId);
	if (hId == Heuristic_t::Default && p.search == SolverStrategies::use_learning) hId = Heuristic_t::Berkmin;
	CLASP_FAIL_IF(p.search != SolverStrategies::use_learning && Heuristic_t::isLookback(hId), "Selected heuristic requires lookback!");
	DecisionHeuristic* h = 0;
	if (heu_) { h = heu_(hId, p.heuristic); }
	if (!h)   { h = Heuristic_t::create(hId, p.heuristic); }
	if (Lookahead::isType(p.lookType) && p.lookOps > 0 && hId != Heuristic_t::Unit) {
		h = UnitHeuristic::restricted(h);
	}
	return h;
}
SolverParams& BasicSatConfig::addSolver(uint32 i) {
	while (i >= solver_.size()) {
		solver_.push_back(SolverParams().setId(static_cast(solver_.size())));
	}
	return solver_[i];
}
SolveParams& BasicSatConfig::addSearch(uint32 i) {
	if (i >= search_.size()) { search_.resize(i+1); }
	return search_[i];
}

void BasicSatConfig::reset() {
	static_cast(*this) = ContextParams();
	BasicSatConfig::resize(1, 1);
	solver_[0] = SolverParams();
	search_[0] = SolveParams();
}
void BasicSatConfig::resize(uint32 solver, uint32 search) {
	solver_.resize(solver);
	search_.resize(search);
}
void BasicSatConfig::setHeuristicCreator(HeuristicCreator hc) {
	heu_ = hc;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Heuristics
/////////////////////////////////////////////////////////////////////////////////////////
DecisionHeuristic* Heuristic_t::create(Type id, const HeuParams& p) {
	if (id == Berkmin) { return new ClaspBerkmin(p); }
	if (id == Vmtf)    { return new ClaspVmtf(p); }
	if (id == Unit)    { return new UnitHeuristic(); }
	if (id == Vsids)   { return new ClaspVsids(p); }
	if (id == Domain)  { return new DomainHeuristic(p); }
	CLASP_FAIL_IF(id != Default && id != None, "Unknown heuristic id!");
	return new SelectFirst();
}

ModelHandler::~ModelHandler() {}
bool ModelHandler::onUnsat(const Solver&, const Model&) { return true; }
}
clasp-3.2.2/libclasp/src/solver_types.cpp000066400000000000000000000254511304134206100204430ustar00rootroot00000000000000//
// Copyright (c) 2006-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
///////////////////////////////////////////////////////////////////////////////
// SearchLimits
///////////////////////////////////////////////////////////////////////////////
SearchLimits::SearchLimits() {
	std::memset(this, 0, sizeof(SearchLimits));
	restart.conflicts = UINT64_MAX;
	conflicts = UINT64_MAX;
	memory = UINT64_MAX;
	learnts = UINT32_MAX;
}
/////////////////////////////////////////////////////////////////////////////////////////
// DynamicLimit
/////////////////////////////////////////////////////////////////////////////////////////
DynamicLimit* DynamicLimit::create(uint32 size) {
	CLASP_FAIL_IF(size == 0, "size must be > 0");
	void* m = ::operator new(sizeof(DynamicLimit) + (size*sizeof(uint32)));
	return new (m)DynamicLimit(size);
}
DynamicLimit::DynamicLimit(uint32 sz) : cap_(sz), pos_(0), num_(0) {
	std::memset(&global, 0, sizeof(global));
	init(0.7f, lbd_limit);
}
void DynamicLimit::init(float k, Type t, uint32 uLimit) {
	resetRun();
	std::memset(&adjust, 0, sizeof(adjust));
	adjust.limit = uLimit;
	adjust.rk = k;
	adjust.type = t;
}
void DynamicLimit::destroy() {
	this->~DynamicLimit();
	::operator delete(this);
}
void DynamicLimit::resetRun() {
	sum_[0] = sum_[1] = pos_ = num_ = 0;
}
void DynamicLimit::reset() {
	std::memset(&global, 0, sizeof(global));
	resetRun();
}
void DynamicLimit::update(uint32 dl, uint32 lbd) {
	// update global avg
	++adjust.samples;
	++global.samples;
	global.sum[lbd_limit] += lbd;
	global.sum[level_limit] += dl;
	// update moving avg
	sum_[lbd_limit] += lbd;
	sum_[level_limit] += dl;
	if (++num_ > cap_) {
		sum_[lbd_limit] -= (buffer_[pos_] & 127u);
		sum_[level_limit] -= (buffer_[pos_] >> 7u);
	}
	buffer_[pos_++] = ((dl << 7) + lbd);
	if (pos_ == cap_) { pos_ = 0; }
}
uint32 DynamicLimit::restart(uint32 maxLBD, float k) {
	++adjust.restarts;
	if (adjust.samples >= adjust.limit) {
		Type nt = global.avg(lbd_limit) > maxLBD ? level_limit : lbd_limit;
		if (nt == adjust.type) {
			double rLen = adjust.avgRestart();
			bool   sx = num_ >= adjust.limit;
			float  rk = adjust.rk;
			uint32 uLim = adjust.limit;
			if      (rLen >= 16000.0) { rk += 0.1f;  uLim = 16000; }
			else if (sx)              { rk += 0.05f; uLim = std::max(uint32(16000), uLim-10000); }
			else if (rLen >= 4000.0)  { rk += 0.05f; }
			else if (rLen >= 1000.0)  { uLim += 10000u; }
			else if (rk > k)          { rk -= 0.05f; }
			init(rk, nt, uLim);
		}
		else { init(k, nt); }
	}
	else { resetRun(); }
	return adjust.limit;
}
BlockLimit::BlockLimit(uint32 windowSize, double R)
	: ema(0.0), alpha(2.0/(windowSize+1))
	, next(windowSize), inc(50), n(0)
	, span(windowSize)
	, r(static_cast(R)) {}

/////////////////////////////////////////////////////////////////////////////////////////
// Statistics
/////////////////////////////////////////////////////////////////////////////////////////
#define NO_ARG
#define CLASP_STAT_ACCU(m, k, a, accu) accu;
#define CLASP_STAT_KEY(m, k, a, accu)  k,
#define CLASP_STAT_GET(m, k, a, accu) if (std::strcmp(key, k) == 0) { return a; }
#define CLASP_DEFINE_ISTATS_COMMON(T, STATS, name) \
	static const char* const T ## _s[] = { STATS(CLASP_STAT_KEY, NO_ARG, NO_ARG) name };\
	uint32 T::size()                     { return (sizeof(T ## _s)/sizeof(T ## _s[0]))-1; } \
	const char* T::key(uint32 i)         { return i < size() ? T ## _s[i] : throw std::out_of_range(#T "::key"); } \
	void T::accu(const T& o)             { STATS(CLASP_STAT_ACCU, (*this), o);}
/////////////////////////////////////////////////////////////////////////////////////////
// CoreStats
/////////////////////////////////////////////////////////////////////////////////////////
CLASP_DEFINE_ISTATS_COMMON(CoreStats, CLASP_CORE_STATS, "core")
StatisticObject CoreStats::at(const char* key) const {
#define VALUE(X) StatisticObject::value(&X)
	CLASP_CORE_STATS(CLASP_STAT_GET, NO_ARG, NO_ARG);
#undef VALUE
	throw std::out_of_range("CoreStats::at");
}
void CoreStats::reset() { std::memset(this, 0, sizeof(*this)); }
/////////////////////////////////////////////////////////////////////////////////////////
// JumpStats
/////////////////////////////////////////////////////////////////////////////////////////
#define MAX_MEM(X, Y) X = std::max((X), (Y))
CLASP_DEFINE_ISTATS_COMMON(JumpStats, CLASP_JUMP_STATS, "jumps")
#undef MAX_MEM
StatisticObject JumpStats::at(const char* key) const {
#define VALUE(X) StatisticObject::value(&X)
	CLASP_JUMP_STATS(CLASP_STAT_GET, NO_ARG, NO_ARG);
#undef VALUE
	throw std::out_of_range("JumpStats::at");
}
void JumpStats::reset() { std::memset(this, 0, sizeof(*this)); }
/////////////////////////////////////////////////////////////////////////////////////////
// ExtendedStats
/////////////////////////////////////////////////////////////////////////////////////////
CLASP_DEFINE_ISTATS_COMMON(ExtendedStats, CLASP_EXTENDED_STATS, "extra")
namespace {
double _lemmas(const ExtendedStats* self)     { return static_cast(self->lemmas()); }
double _learntLits(const ExtendedStats* self) { return static_cast(self->learntLits()); }
}
StatisticObject ExtendedStats::at(const char* key) const {
#define VALUE(X) StatisticObject::value(&X)
#define MEM_FUN(X) StatisticObject::value(this)
#define MAP(X) StatisticObject::map(&X)
	CLASP_EXTENDED_STATS(CLASP_STAT_GET, NO_ARG, NO_ARG);
#undef VALUE
#undef MEM_FUN
#undef MAP
	throw std::out_of_range("ExtendedStats::at");
}
void ExtendedStats::reset() {
	std::memset(this, 0, sizeof(ExtendedStats) - sizeof(JumpStats));
	jumps.reset();
}
/////////////////////////////////////////////////////////////////////////////////////////
// SolverStats
/////////////////////////////////////////////////////////////////////////////////////////
SolverStats::SolverStats() : limit(0), extra(0), multi(0) {}
SolverStats::SolverStats(const SolverStats& o) : CoreStats(o), limit(0), extra(0), multi(0) {
	if (o.extra && enableExtended()) { extra->accu(*o.extra); }
}
SolverStats::~SolverStats() {
	delete extra;
	if (limit) limit->destroy();
}
bool SolverStats::enableExtended() {
	return extra != 0 || (extra = new (std::nothrow) ExtendedStats()) != 0;
}
void SolverStats::enableLimit(uint32 size) {
	if (limit && limit->window() != size) { limit->destroy(); limit = 0; }
	if (!limit)                           { limit = DynamicLimit::create(size); }
}
void SolverStats::reset() {
	CoreStats::reset();
	if (limit) limit->reset();
	if (extra) extra->reset();
}
void SolverStats::accu(const SolverStats& o) {
	CoreStats::accu(o);
	if (extra && o.extra) extra->accu(*o.extra);
}
void SolverStats::accu(const SolverStats& o, bool enableRhs) {
	if (enableRhs) { enable(o); }
	accu(o);
}
void SolverStats::flush() const {
	if (multi) {
		multi->enable(*this);
		multi->accu(*this);
		multi->flush();
	}
}
void SolverStats::swapStats(SolverStats& o) {
	std::swap(static_cast(*this), static_cast(o));
	std::swap(extra, o.extra);
}
uint32 SolverStats::size() const {
	return CoreStats::size() + (extra != 0);
}
const char* SolverStats::key(uint32 i) const {
	if (i >= size()) { throw std::out_of_range("SolverStats::key"); }
	return i < CoreStats::size() ? CoreStats::key(i) : "extra";
}
template 
static bool matchPath(const char*& path, const char (&key)[n]) {
	std::size_t kLen = n-1;
	return std::strncmp(path, key, kLen) == 0 && (!path[kLen] || path[kLen++] == '.') && (path += kLen) != 0;
}
StatisticObject SolverStats::at(const char* k) const {
	if (extra && matchPath(k, "extra")) {
		return !*k ? StatisticObject::map(extra) : extra->at(k);
	}
	else {
		return CoreStats::at(k);
	}
}
void SolverStats::addTo(const char* key, StatsMap& solving, StatsMap* accu) const {
	solving.add(key, StatisticObject::map(this));
	if (accu && this->multi) { multi->addTo(key, *accu, 0); }
}
#undef NO_ARG
#undef CLASP_STAT_ACCU
#undef CLASP_STAT_KEY
#undef CLASP_STAT_GET
#undef CLASP_DEFINE_ISTATS_COMMON
/////////////////////////////////////////////////////////////////////////////////////////
// ClauseHead
/////////////////////////////////////////////////////////////////////////////////////////
ClauseHead::ClauseHead(const InfoType& init) : info_(init){
	static_assert(sizeof(ClauseHead)<=32, "Unsupported Alignment");
	head_[2] = lit_false();
}
void ClauseHead::resetScore(ScoreType sc) {
	info_.setScore(sc);
}
void ClauseHead::attach(Solver& s) {
	assert(head_[0] != head_[1] && head_[1] != head_[2]);
	s.addWatch(~head_[0], ClauseWatch(this));
	s.addWatch(~head_[1], ClauseWatch(this));
}

void ClauseHead::detach(Solver& s) {
	s.removeWatch(~head_[0], this);
	s.removeWatch(~head_[1], this);
}

bool ClauseHead::locked(const Solver& s) const {
	return (s.isTrue(head_[0]) && s.reason(head_[0]) == this)
	  ||   (s.isTrue(head_[1]) && s.reason(head_[1]) == this);
}

bool ClauseHead::satisfied(const Solver& s) const {
	return s.isTrue(head_[0]) || s.isTrue(head_[1]) || s.isTrue(head_[2]);
}

bool ClauseHead::toImplication(Solver& s) {
	uint32 sz     = isSentinel(head_[1]) ? 1 : 2 + (!s.isFalse(head_[2]) || s.level(head_[2].var()) > 0);
	ClauseRep rep = ClauseRep::create(head_, sz, InfoType(ClauseHead::type()).setLbd(2).setTagged(tagged()));
	bool implicit = s.allowImplicit(rep);
	bool locked   = ClauseHead::locked(s) && s.decisionLevel() > 0;
	rep.prep      = 1;
	if ((locked || !implicit) && sz > 1) { return false; }
	s.add(rep, false);
	detach(s);
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// SmallClauseAlloc
/////////////////////////////////////////////////////////////////////////////////////////
SmallClauseAlloc::SmallClauseAlloc() : blocks_(0), freeList_(0) { }
SmallClauseAlloc::~SmallClauseAlloc() {
	Block* r = blocks_;
	while (r) {
		Block* t = r;
		r = r->next;
		::operator delete(t);
	}
}

void SmallClauseAlloc::allocBlock() {
	Block* r = (Block*)::operator new(sizeof(Block));
	for (uint32 i = 0; i < Block::num_chunks-1; ++i) {
		r->chunk[i].next = &r->chunk[i+1];
	}
	r->chunk[Block::num_chunks-1].next = freeList_;
	freeList_ = r->chunk;
	r->next   = blocks_;
	blocks_   = r;
}

}
clasp-3.2.2/libclasp/src/statistics.cpp000066400000000000000000000217001304134206100200700ustar00rootroot00000000000000//
// Copyright (c) 2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// StatisticObject
/////////////////////////////////////////////////////////////////////////////////////////
StatisticObject::RegVec StatisticObject::types_;
StatisticObject::StatisticObject() : handle_(0) {}
StatisticObject::StatisticObject(const void* obj, uint32 type) {
	handle_  = static_cast(type) << 48;
	handle_ |= static_cast(reinterpret_cast(obj));
}
const void* StatisticObject::self() const {
	static const uint64 ptrMask = bit_mask(48) - 1;
	return reinterpret_cast(static_cast(handle_ & ptrMask));
}
const StatisticObject::I* StatisticObject::tid() const {
	return types_.at(static_cast(handle_ >> 48));
}
StatisticObject::Type StatisticObject::type() const {
	return !empty() ? tid()->type : Potassco::Statistics_t::Empty;
}
bool StatisticObject::empty() const {
	return handle_ == 0;
}
uint32 StatisticObject::size() const {
	switch (type()) {
		default: throw std::logic_error("invalid object");
		case Potassco::Statistics_t::Value: return 0;
		case Potassco::Statistics_t::Map:   return static_cast(tid())->size(self());
		case Potassco::Statistics_t::Array: return static_cast(tid())->size(self());
	}
}
const char* StatisticObject::key(uint32 i) const {
	CLASP_FAIL_IF(type() != Potassco::Statistics_t::Map, "type error");
	return static_cast(tid())->key(self(), i);
}
static inline StatisticObject check(StatisticObject o) {
	if (!o.empty()) { return o; }
	throw std::out_of_range("StatisticObject");
}
StatisticObject StatisticObject::at(const char* k) const {
	CLASP_FAIL_IF(type() != Potassco::Statistics_t::Map, "type error");
	return check(static_cast(tid())->at(self(), k));
}
StatisticObject StatisticObject::operator[](uint32 i) const {
	CLASP_FAIL_IF(type() != Potassco::Statistics_t::Array, "type error");
	return check(static_cast(tid())->at(self(), i));
}
double StatisticObject::value() const {
	CLASP_FAIL_IF(type() != Potassco::Statistics_t::Value, "type error");
	return static_cast(tid())->value(self());
}
std::size_t StatisticObject::hash() const {
	typedef Clasp::HashSet_t::set_type::hasher Hasher;
	return Hasher()(toRep());
}
uint64 StatisticObject::toRep() const {
	return handle_;
}
StatisticObject StatisticObject::fromRep(uint64 x) {
	if (!x) { return StatisticObject(0, 0); }
	StatisticObject r;
	r.handle_ = x;
	CLASP_FAIL_IF(r.tid() == 0 || (reinterpret_cast(r.self()) & 3u) != 0, "invalid key");
	return r;
}
/////////////////////////////////////////////////////////////////////////////////////////
// ClaspStatistics
/////////////////////////////////////////////////////////////////////////////////////////
struct ClaspStatistics::Impl {
	typedef Clasp::HashMap_t::map_type RegMap;
	Impl() : gc_(0), rem_(0) {}
	Key_t add(const StatisticObject& o) {
		uint64 k = o.toRep();
		map_[k] = gc_;
		return k;
	}
	bool remove(const StatisticObject& o) {
		std::size_t rem = map_.erase(o.toRep());
		return rem != 0;
	}
	StatisticObject get(Key_t k) const {
		RegMap::const_iterator it = map_.find(k);
		if (it != map_.end() && it->second == gc_) {
			return StatisticObject::fromRep(k);
		}
		throw std::logic_error("invalid key");
	}
	void update(const StatisticObject& root) {
		++gc_;
		rem_ += (sizeVec(map_) - visit(root));
		if (rem_ > (map_.size() >> 1)) {
			for (RegMap::iterator it = map_.begin(), end = map_.end(); it != end;) {
				if (it->second == gc_) { ++it; }
				else { it = map_.erase(it); }
			}
			rem_ = 0;
		}
	}
	uint32 visit(const StatisticObject& obj) {
		uint32 count = 0;
		RegMap::iterator it = map_.find(obj.toRep());
		if (obj.empty() || it == map_.end()) { return count; }
		it->second = gc_;
		++count;
		switch (obj.type()) {
			case Potassco::Statistics_t::Map:
				for (uint32 i = 0, end = obj.size(); i != end; ++i) { count += visit(obj.at(obj.key(i))); }
				break;
			case Potassco::Statistics_t::Array:
				for (uint32 i = 0, end = obj.size(); i != end; ++i) { count += visit(obj[i]); }
				break;
			default: break;
		}
		return count;
	}
	RegMap map_;
	uint32 gc_;
	uint32 rem_;
};

ClaspStatistics::ClaspStatistics() : root_(0), impl_(new Impl()) {}
ClaspStatistics::~ClaspStatistics() {
	delete impl_;
}
StatisticObject ClaspStatistics::getObject(Key_t k) const {
	return impl_->get(k);
}
ClaspStatistics::Key_t ClaspStatistics::root() const {
	return root_;
}
Potassco::Statistics_t ClaspStatistics::type(Key_t key) const {
	return getObject(key).type();
}
size_t ClaspStatistics::size(Key_t key) const {
	return getObject(key).size();
}
ClaspStatistics::Key_t ClaspStatistics::at(Key_t arrK, size_t index) const {
	return impl_->add(getObject(arrK)[toU32(index)]);
}
const char* ClaspStatistics::key(Key_t mapK, size_t i) const {
	return getObject(mapK).key(toU32(i));
}
ClaspStatistics::Key_t ClaspStatistics::get(Key_t key, const char* path) const {
	return impl_->add(!std::strchr(path, '.')
		? getObject(key).at(path)
		: findObject(key, path));
}
double ClaspStatistics::value(Key_t key) const {
	return getObject(key).value();
}
ClaspStatistics::Key_t ClaspStatistics::setRoot(const StatisticObject& obj) {
	return root_ = impl_->add(obj);
}
bool ClaspStatistics::removeStat(const StatisticObject& obj, bool recurse) {
	bool ret = impl_->remove(obj);
	if (ret && recurse) {
		if (obj.type() == Potassco::Statistics_t::Map) {
			for (uint32 i = 0, end = obj.size(); i != end; ++i) {
				removeStat(obj.at(obj.key(i)), true);
			}
		}
		else if (obj.type() == Potassco::Statistics_t::Array) {
			for (uint32 i = 0, end = obj.size(); i != end; ++i) {
				removeStat(obj[i], true);
			}
		}
	}
	return ret;
}
bool ClaspStatistics::removeStat(Key_t k, bool recurse) {
	try { return removeStat(impl_->get(k), recurse); }
	catch (const std::logic_error&) { return false; }
}
void ClaspStatistics::update() {
	if (root_) { impl_->update(getObject(root_)); }
}
StatisticObject ClaspStatistics::findObject(Key_t root, const char* path, Key_t* res) const {
	StatisticObject o = getObject(root);
	StatisticObject::Type t = o.type();
	char temp[1024]; const char* top, *parent = path;
	for (int pos; path && *path;) {
		top = path;
		if ((path = std::strchr(path, '.')) != 0) {
			std::size_t len = static_cast(path++ - top);
			CLASP_FAIL_IF(len >= 1024, "invalid key");
			top = (const char*)std::memcpy(temp, top, len);
			temp[len] = 0;
		}
		if      (t == Potassco::Statistics_t::Map) { o = o.at(top); }
		else if (t == Potassco::Statistics_t::Array && Potassco::match(top, pos) && pos >= 0) {
			o = o[uint32(pos)];
		}
		else {
			throw std::out_of_range(ClaspStringBuffer().appendFormat("invalid path: '%s' at key '%s'", parent, top).c_str());
		}
		t = o.type();
	}
	if (res) { *res = impl_->add(o); }
	return o;
}

StatisticObject StatsMap::at(const char* k) const {
	if (const StatisticObject* o = find(k)) { return *o; }
	throw std::out_of_range(ClaspStringBuffer().appendFormat("StatsMap::at with key '%s'", k).c_str());
}
const StatisticObject* StatsMap::find(const char* k) const {
	for (MapType::const_iterator it = keys_.begin(), end = keys_.end(); it != end; ++it) {
		if (std::strcmp(it->first, k) == 0) { return &it->second; }
	}
	return 0;
}
bool StatsMap::add(const char* k, const StatisticObject& o) {
	return !find(k) && (keys_.push_back(MapType::value_type(k, o)), true);
}
/////////////////////////////////////////////////////////////////////////////////////////
// StatsVisitor
/////////////////////////////////////////////////////////////////////////////////////////
StatsVisitor::~StatsVisitor() {}
bool StatsVisitor::visitGenerator(Operation) {
	return true;
}
bool StatsVisitor::visitThreads(Operation) {
	return true;
}
bool StatsVisitor::visitTester(Operation) {
	return true;
}
bool StatsVisitor::visitHccs(Operation) {
	return true;
}
void StatsVisitor::visitHcc(uint32, const ProblemStats& p, const SolverStats& s) {
	visitProblemStats(p);
	visitSolverStats(s);
}
void StatsVisitor::visitThread(uint32, const SolverStats& stats) {
	visitSolverStats(stats);
}

}

clasp-3.2.2/libclasp/src/timer.cpp000066400000000000000000000065661304134206100170330ustar00rootroot00000000000000//
// Copyright (c) 2006-2012, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN // exclude APIs such as Cryptography, DDE, RPC, Shell, and Windows Sockets.
#define NOMINMAX            // do not let windows.h define macros min and max
#include         // GetProcessTimes, GetCurrentProcess, FILETIME
#define TICKS_PER_SEC 10000000

namespace Clasp {

double RealTime::getTime() {
	union Convert {
		FILETIME time;
		__int64  asUint;
	} now;
	GetSystemTimeAsFileTime(&now.time);
	return static_cast(now.asUint/static_cast(TICKS_PER_SEC));
}

double ProcessTime::getTime() {
	FILETIME ignoreStart, ignoreExit;
	union Convert {
		FILETIME time;
		__int64  asUint;
	} user, system;
	GetProcessTimes(GetCurrentProcess(), &ignoreStart, &ignoreExit, &user.time, &system.time);
	return (user.asUint + system.asUint) / double(TICKS_PER_SEC);
}

double ThreadTime::getTime() {
	FILETIME ignoreStart, ignoreExit;
	union Convert {
		FILETIME time;
		__int64  asUint;
	} user, system;
	GetThreadTimes(GetCurrentThread(), &ignoreStart, &ignoreExit, &user.time, &system.time);
	return (user.asUint + system.asUint) / double(TICKS_PER_SEC);
}

}
#else
#include    // times()
#include     // gettimeofday()
#include       // sysconf()
#include // getrusage
#include 
#ifdef __APPLE__
#include 
#include 
#endif
namespace Clasp {

double RealTime::getTime() {
	struct timeval now;
	gettimeofday(&now, NULL);
	return static_cast(now.tv_sec) + static_cast(now.tv_usec / 1000000.0);
}

double ProcessTime::getTime() {
	struct tms nowTimes;
	times(&nowTimes);
	return (nowTimes.tms_utime + nowTimes.tms_stime) / double(sysconf(_SC_CLK_TCK));
}
double ThreadTime::getTime() {
	double res = std::numeric_limits::quiet_NaN();
#if defined(RUSAGE_THREAD)
	int who = RUSAGE_THREAD;
	struct rusage usage;
	getrusage(who, &usage);
	res = (static_cast(usage.ru_utime.tv_sec) + static_cast(usage.ru_utime.tv_usec / 1000000.0))
	    + (static_cast(usage.ru_stime.tv_sec) + static_cast(usage.ru_stime.tv_usec / 1000000.0));
#elif __APPLE__
	struct thread_basic_info t_info;
	mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
	if (thread_info(mach_thread_self(), THREAD_BASIC_INFO, (thread_info_t)&t_info, &t_info_count) == KERN_SUCCESS) {
		time_value_add(&t_info.user_time, &t_info.system_time);
		res = static_cast(t_info.user_time.seconds) + static_cast(t_info.user_time.microseconds / static_cast(TIME_MICROS_MAX));
	}
#endif
	return res;
}

}
#endif

clasp-3.2.2/libclasp/src/unfounded_check.cpp000066400000000000000000000731321304134206100210300ustar00rootroot00000000000000//
// Copyright (c) 2010-2016, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include 
#include 
#include 
#include 
namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// DefaultUnfoundedCheck - Construction/Destruction
/////////////////////////////////////////////////////////////////////////////////////////
// Choice rules are handled like normal rules with one exception:
//  Since BFA does not apply to choice rules, we manually trigger the removal of source pointers
//  whenever an atom sourced by a choice rule becomes false.
//
// The major problems with card/weight-rules are:
//  1. subgoals can circularly depend on the body
//  2. subgoal false -> body false, does not hold
//
// Regarding the first point, consider: {b}. a:- 1{a,b}.
// Since b is external to 1{a,b}, the body is a valid source for a. Therefore, 1{a,b} can source a.
// After a's source pointer is set to 1{a,b}, both subgoals of 1{a,b} have a source. Nevertheless,
// we must not count a because it (circularly) depends on the body. I.e. as soon as b
// becomes false, a is unfounded, because the loop {a} no longer has external bodies.
//
// The second point means that we have to watch *all* subgoals because we
// may need to trigger source pointer removal whenever one of the subgoals becomes false.
// Consider: {a,b,c}. t :- 2 {b,t,x}. x :- t,c. x :- a.
// Now assume {t,c} is true and a becomes false. In this case, both x and t lose their
// source pointer and we get the (conflicting) unfounded set {x, t}.
// Further assume that after some backtracking we have that both {t,c} and a
// become false. Therefore x is false, too. Since we do not update source pointers on
// conflicts, x and t still have no source. Thus no removal of source pointers is triggered.
// If we would not watch x in 2 {b,t,x}, we could not add t to the todo queue and
// we would therefore miss the unfounded set {t}.
//
// The implementation for extended bodies works as follows:
// - It distinguishes between internal literals, those that are in the same SCC as B
//   and external literals, those that are not.
// - Let W(l) be the weight of literal l in B and W(WS) be the sum of W(l) for each l in a set WS.
// - The goal is to maintain a set WS of literals l, s.th l in Body and hasSource(l) AND W(WS) >= bound.
// - Initially WS contains all non-false external literals of B.
// - Whenever one of the internal literals of B becomes sourced, it is added to WS
//   *only if* W(WS) < bound. In that case, it is guaranteed that the literal
//   currently does not circularly depend on the body.
// - As soon as W(WS) >= bound, we declare the body as valid source for its heads.
// - Whenever one of the literals l in WS loses its source, it is removed from WS.
//   If l is an external literal, new valid external literals are searched and added to WS
//   until the source condition holds again.
// - If the condition cannot be restored, the body is marked as invalid source.

DefaultUnfoundedCheck::DefaultUnfoundedCheck(DependencyGraph& g, ReasonStrategy st)
	: solver_(0)
	, graph_(&g)
	, mini_(0)
	, reasons_(0)
	, strategy_(st) {
	mini_.release();
}
DefaultUnfoundedCheck::~DefaultUnfoundedCheck() {
	for (ExtVec::size_type i = 0; i != extended_.size(); ++i) {
		::operator delete(extended_[i]);
	}
	delete [] reasons_;
}
/////////////////////////////////////////////////////////////////////////////////////////
// DefaultUnfoundedCheck - Initialization
/////////////////////////////////////////////////////////////////////////////////////////
void DefaultUnfoundedCheck::addWatch(Literal p, uint32 data, WatchType type) {
	assert(data < varMax);
	solver_->addWatch(p, this, static_cast((data << 2) | type));
}

void DefaultUnfoundedCheck::setReasonStrategy(ReasonStrategy rs) {
	strategy_ = rs;
	if (strategy_ == only_reason && solver_ && !reasons_) {
		reasons_ = new LitVec[solver_->numVars()];
	}
}
// inits unfounded set checker with graph, i.e.
// - creates data objects for bodies and atoms
// - adds necessary watches to the solver
// - initializes source pointers
bool DefaultUnfoundedCheck::init(Solver& s) {
	assert(!solver_ || solver_ == &s);
	delete[] reasons_;
	reasons_ = 0;
	solver_  = &s;
	setReasonStrategy(s.searchMode() != SolverStrategies::no_learning ? strategy_ : no_reason);
	// process any leftovers from previous steps
	while (findUfs(s, false) != ufs_none) {
		while (!ufs_.empty()) {
			if (!s.force(~graph_->getAtom(ufs_.front()).lit, 0)) { return false; }
			atoms_[ufs_.pop_ret()].ufs = 0;
		}
	}
	AtomVec::size_type startAtom = atoms_.size();
	// set up new atoms
	atoms_.resize(graph_->numAtoms());
	AtomData& sentinel = atoms_[DependencyGraph::sentinel_atom];
	sentinel.resurrectSource();
	sentinel.todo = 1;
	sentinel.ufs  = 1;
	// set up new bodies
	for (uint32 i = (uint32)bodies_.size(); i != graph_->numBodies(); ++i) {
		bodies_.push_back(BodyData());
		BodyPtr n(getBody(i));
		if (!n.node->extended()) {
			initBody(n);
		}
		else {
			initExtBody(n);
		}
		// when a body becomes false, it can no longer be used as source
		addWatch(~n.node->lit, n.id, watch_source_false);
	}
	// check for initially unfounded atoms
	propagateSource();
	for (AtomVec::size_type i = startAtom, end = atoms_.size(); i != end; ++i) {
		const AtomNode& a = graph_->getAtom(NodeId(i));
		if (!atoms_[i].hasSource() && !solver_->force(~a.lit, 0)) {
			return false;
		}
		if (a.inChoice()) {
			addWatch(~a.lit, NodeId(i), watch_head_false);
		}
	}
	if (graph_->numNonHcfs() != 0) {
		mini_ = new MinimalityCheck(s.searchConfig().fwdCheck);
		if (const uint32 sd = mini_->fwd.signDef) {
			for (AtomVec::size_type i = startAtom, end = atoms_.size(); i != end; ++i) {
				const AtomNode& a = graph_->getAtom(NodeId(i));
				if (a.inDisjunctive() && solver_->value(a.lit.var()) == value_free) {
					ValueRep v = falseValue(a.lit);
					if (sd == SolverStrategies::sign_pos || (sd == SolverStrategies::sign_rnd && (i & 1) != 0)) {
						v ^= static_cast(3u);
					}
					solver_->setPref(a.lit.var(), ValueSet::def_value, v);
				}
			}
		}
	}
	return true;
}

// initializes a "normal" body, i.e. a body where lower(B) == size(B)
void DefaultUnfoundedCheck::initBody(const BodyPtr& n) {
	assert(n.id < bodies_.size());
	BodyData& data = bodies_[n.id];
	// initialize lower to the number of predecessors from same scc that currently
	// have no source. Once lower is 0, the body can source successors in its scc
	data.lower_or_ext  = n.node->num_preds();
	initSuccessors(n, data.lower_or_ext);
}

// initializes an "extended" body, i.e. a count/sum
// creates & populates WS and adds watches to all subgoals
void DefaultUnfoundedCheck::initExtBody(const BodyPtr& n) {
	assert(n.id < bodies_.size() && n.node->extended());
	BodyData& data = bodies_[n.id];
	uint32 preds   = n.node->num_preds();
	ExtData* extra = new (::operator new(sizeof(ExtData) + (ExtData::flagSize(preds)*sizeof(uint32)))) ExtData(n.node->ext_bound(), preds);

	InitExtWatches addWatches = { this, &n, extra };
	graph_->visitBodyLiterals(*n.node, addWatches);

	data.lower_or_ext = (uint32)extended_.size();
	extended_.push_back(extra);
	initSuccessors(n, extra->lower);
}

// set n as source for its heads if possible and necessary
void DefaultUnfoundedCheck::initSuccessors(const BodyPtr& n, weight_t lower) {
	if (!solver_->isFalse(n.node->lit)) {
		for (const NodeId* x = n.node->heads_begin(); x != n.node->heads_end(); ++x) {
			const AtomNode& a = graph_->getAtom(*x);
			if (a.scc != n.node->scc || lower <= 0) {
				setSource(*x, n);
			}
		}
	}
}

// watches needed to implement extended rules
void DefaultUnfoundedCheck::addExtWatch(Literal p, const BodyPtr& B, uint32 data) {
	addWatch(p, static_cast(watches_.size()), watch_subgoal_false);
	ExtWatch w = { B.id, data };
	watches_.push_back(w);
}
/////////////////////////////////////////////////////////////////////////////////////////
// DefaultUnfoundedCheck - Base interface
/////////////////////////////////////////////////////////////////////////////////////////
void DefaultUnfoundedCheck::reason(Solver&, Literal p, LitVec& r) {
	LitVec::const_iterator it, end;
	if (!activeClause_.empty() && activeClause_[0] == p) {
		it  = activeClause_.begin()+1;
		end = activeClause_.end();
	}
	else {
		assert(strategy_ == only_reason && reasons_);
		it  = reasons_[p.var()-1].begin();
		end = reasons_[p.var()-1].end();
	}
	for (; it != end; ++it) r.push_back( ~*it );
}

bool DefaultUnfoundedCheck::propagateFixpoint(Solver& s, PostPropagator* ctx) {
	bool checkMin = ctx == 0 && mini_.get() && mini_->partialCheck(s.decisionLevel());
	for (UfsType t; (t = findUfs(s, checkMin)) != ufs_none; ) {
		if (!falsifyUfs(t)) {
			resetTodo();
			return false;
		}
	}
	return true;
}

void DefaultUnfoundedCheck::reset() {
	assert(loopAtoms_.empty() && sourceQ_.empty() && ufs_.empty() && todo_.empty());
	// remember assignments from top-level -
	// the reset may come from a stop request and we might
	// want to continue later
	if (solver_->decisionLevel()) {
		invalidQ_.clear();
	}
}
bool DefaultUnfoundedCheck::valid(Solver& s) {
	if (!mini_.get() || findNonHcfUfs(s) == ufs_none) { return true; }
	falsifyUfs(ufs_non_poly);
	return false;
}
bool DefaultUnfoundedCheck::isModel(Solver& s) {
	return DefaultUnfoundedCheck::valid(s);
}
bool DefaultUnfoundedCheck::simplify(Solver& s, bool) {
	graph_->simplify(s);
	if (mini_.get()) { mini_->scc = 0; }
	return false;
}
void DefaultUnfoundedCheck::destroy(Solver* s, bool detach) {
	if (s && detach) {
		s->removePost(this);
		for (uint32 i = 0; i != (uint32)bodies_.size(); ++i) {
			BodyPtr n(getBody(i));
			s->removeWatch(~n.node->lit, this);
			if (n.node->extended()) {
				RemExtWatches remW = { static_cast(this), s };
				graph_->visitBodyLiterals(*n.node, remW);
			}
		}
		for (AtomVec::size_type i = 0, end = atoms_.size(); i != end; ++i) {
			const AtomNode& a = graph_->getAtom(NodeId(i));
			if (a.inChoice()) { s->removeWatch(~a.lit, this); }
		}
	}
	PostPropagator::destroy(s, detach);
}
/////////////////////////////////////////////////////////////////////////////////////////
// DefaultUnfoundedCheck - source pointer propagation
/////////////////////////////////////////////////////////////////////////////////////////
// propagates recently set source pointers within one strong component.
void DefaultUnfoundedCheck::propagateSource() {
	for (LitVec::size_type i = 0; i < sourceQ_.size(); ++i) {
		NodeId atom = sourceQ_[i];
		if (atoms_[atom].hasSource()) {
			// propagate a newly added source-pointer
			graph_->getAtom(atom).visitSuccessors(AddSource(this));
		}
		else {
			graph_->getAtom(atom).visitSuccessors(RemoveSource(this));
		}
	}
	sourceQ_.clear();
}

// replaces current source of atom with n
void DefaultUnfoundedCheck::updateSource(AtomData& atom, const BodyPtr& n) {
	if (atom.watch() != AtomData::nill_source) {
		--bodies_[atom.watch()].watches;
	}
	atom.setSource(n.id);
	++bodies_[n.id].watches;
}

// an atom in extended body n has a new source, check if n is now a valid source
void DefaultUnfoundedCheck::AddSource::operator()(NodeId bodyId, uint32 idx) const {
	BodyPtr n(self->getBody(bodyId));
	ExtData* ext = self->extended_[self->bodies_[bodyId].lower_or_ext];
	if (ext->lower > 0 || self->bodies_[n.id].watches == 0) {
		// currently not a source - safely add pred to our watch set
		ext->addToWs(idx, n.node->pred_weight(idx, false));
	}
	if (!self->solver_->isFalse(n.node->lit) && ext->lower <= 0) {
		// valid source - propagate to heads
		self->forwardSource(n);
	}
}
// an atom in extended body n has lost its source, check if n is no longer a valid source
void DefaultUnfoundedCheck::RemoveSource::operator()(NodeId bodyId, uint32 idx) const {
	BodyPtr n(self->getBody(bodyId));
	ExtData* ext = self->extended_[self->bodies_[bodyId].lower_or_ext];
	ext->removeFromWs(idx, n.node->pred_weight(idx, false));
	if (ext->lower > 0 && self->bodies_[n.id].watches > 0) {
		// extended bodies don't always become false if a predecessor becomes false
		// eagerly enqueue all successors watching this body
		self->forwardUnsource(n, true);
	}
}

// n is a valid source again, forward propagate this information to its heads
void DefaultUnfoundedCheck::forwardSource(const BodyPtr& n) {
	for (const NodeId* x = n.node->heads_begin(); x != n.node->heads_end(); ++x) {
		setSource(*x, n);
	}
}

// n is no longer a valid source, forward propagate this information to its heads
void DefaultUnfoundedCheck::forwardUnsource(const BodyPtr& n, bool add) {
	for (const NodeId* x = n.node->heads_begin(); x != n.node->heads_end() && graph_->getAtom(*x).scc == n.node->scc; ++x) {
		if (atoms_[*x].hasSource() && atoms_[*x].watch() == n.id) {
			atoms_[*x].markSourceInvalid();
			sourceQ_.push_back(*x);
		}
		if (add && atoms_[*x].watch() == n.id) {
			pushTodo(*x);
		}
	}
}

// sets body as source for head if necessary.
// PRE: value(body) != value_false
// POST: source(head) != 0
void DefaultUnfoundedCheck::setSource(NodeId head, const BodyPtr& body) {
	assert(!solver_->isFalse(body.node->lit));
	// For normal rules from not false B follows not false head, but
	// for choice rules this is not the case. Therefore, the
	// check for isFalse(head) is needed so that we do not inadvertantly
	// source a head that is currently false.
	if (!atoms_[head].hasSource() && !solver_->isFalse(graph_->getAtom(head).lit)) {
		updateSource(atoms_[head], body);
		sourceQ_.push_back(head);
	}
}

// This function is called for each body that became invalid during propagation.
// Heads having the body as source have their source invalidated and are added
// to the todo queue. Furthermore, source pointer removal is propagated forward
void DefaultUnfoundedCheck::removeSource(NodeId bodyId) {
	const BodyNode& body = graph_->getBody(bodyId);
	for (const NodeId* x = body.heads_begin(); x != body.heads_end(); ++x) {
		if (atoms_[*x].watch() == bodyId) {
			if (atoms_[*x].hasSource()) {
				atoms_[*x].markSourceInvalid();
				sourceQ_.push_back(*x);
			}
			pushTodo(*x);
		}
	}
	propagateSource();
}

/////////////////////////////////////////////////////////////////////////////////////////
// DefaultUnfoundedCheck - Finding & propagating unfounded sets
/////////////////////////////////////////////////////////////////////////////////////////
void DefaultUnfoundedCheck::updateAssignment(Solver& s) {
	assert(sourceQ_.empty() && ufs_.empty() && pickedExt_.empty());
	for (VarVec::const_iterator it = invalidQ_.begin(), end = invalidQ_.end(); it != end; ++it) {
		uint32 index = (*it) >> 2;
		uint32 type  = (*it) & 3u;
		if (type == watch_source_false) {
			// a body became false - update atoms having the body as source
			removeSource(index);
		}
		else if (type == watch_head_false) {
			// an atom in the head of a choice rule became false
			// normally head false -> body false and hence the head has its source autmatically removed
			// for choice rules we must force source removal explicity
			if (atoms_[index].hasSource() && !s.isFalse(graph_->getBody(atoms_[index].watch()).lit)) {
				atoms_[index].markSourceInvalid();
				graph_->getAtom(index).visitSuccessors(RemoveSource(this, true));
				propagateSource();
			}
		}
		else if (type == watch_head_true) {
			// TODO: approx. ufs for disjunctive lp
		}
		else if (type == watch_subgoal_false) { // a literal p relevant to an extended body became false
			assert(index < watches_.size());
			const ExtWatch& w    = watches_[index];
			const BodyNode& body = graph_->getBody(w.bodyId);
			ExtData*        ext  = extended_[bodies_[w.bodyId].lower_or_ext];
			ext->removeFromWs(w.data>>1, body.pred_weight(w.data>>1, test_bit(w.data, 0) != 0));
			if (ext->lower > 0 && bodies_[w.bodyId].watches && !bodies_[w.bodyId].picked && !s.isFalse(body.lit)) {
				// The body is not a valid source but at least one head atom
				// still depends on it: mark body as invalid source
				removeSource(w.bodyId);
				pickedExt_.push_back(w.bodyId);
				bodies_[w.bodyId].picked = 1;
			}
		}
	}
	for (VarVec::size_type i = 0, end = pickedExt_.size(); i != end; ++i) {
		bodies_[pickedExt_[i]].picked = 0;
	}
	pickedExt_.clear();
	invalidQ_.clear();
}

DefaultUnfoundedCheck::UfsType DefaultUnfoundedCheck::findUfs(Solver& s, bool checkMin) {
	// first: remove all sources that were recently falsified
	updateAssignment(s);
	// second: try to re-establish sources.
	while (!todo_.empty()) {
		NodeId head       = todo_.pop_ret();
		atoms_[head].todo = 0;
		if (!atoms_[head].hasSource() && !s.isFalse(graph_->getAtom(head).lit) && !findSource(head)) {
			return ufs_poly;  // found an unfounded set - contained in unfounded_
		}
		assert(sourceQ_.empty());
	}
	todo_.clear();
	return !checkMin ? ufs_none : findNonHcfUfs(s);
}

// searches a new source for the atom node head.
// If a new source is found the function returns true.
// Otherwise the function returns false and unfounded_ contains head
// as well as atoms with no source that circularly depend on head.
bool DefaultUnfoundedCheck::findSource(NodeId headId) {
	assert(ufs_.empty() && invalidQ_.empty());
	const NodeId* bodyIt, *bodyEnd;
	uint32 newSource = 0;
	pushUfs(headId); // unfounded, unless we find a new source
	while (!ufs_.empty()) {
		headId         = ufs_.pop_ret(); // still marked and in vector!
		AtomData& head = atoms_[headId];
		if (!head.hasSource()) {
			const AtomNode& headNode = graph_->getAtom(headId);
			for (bodyIt = headNode.bodies_begin(), bodyEnd = headNode.bodies_end(); bodyIt != bodyEnd; ++bodyIt) {
				BodyPtr bodyNode(getBody(*bodyIt));
				if (!solver_->isFalse(bodyNode.node->lit)) {
					if (bodyNode.node->scc != headNode.scc || isValidSource(bodyNode)) {
						head.ufs = 0;               // found a new source,
						setSource(headId, bodyNode);// set the new source
						propagateSource();          // and propagate it forward
						++newSource;
						break;
					}
					else { addUnsourced(bodyNode); }
				}
			}
			if (!head.hasSource()) { // still no source - check again once we are done
				invalidQ_.push_back(headId);
			}
		}
		else {  // head has a source and is thus not unfounded
			++newSource;
			head.ufs = 0;
		}
	} // while unfounded_.emtpy() == false
	ufs_.rewind();
	if (newSource != 0) {
		// some atoms in unfounded_ have a new source
		// clear queue and check possible candidates for atoms that are still unfounded
		uint32 visited = sizeVec(ufs_.vec);
		ufs_.clear();
		if (visited != newSource) {
			// add elements that are still unfounded
			for (VarVec::iterator it = invalidQ_.begin(), end = invalidQ_.end(); it != end; ++it) {
				if ( (atoms_[*it].ufs = (1u - atoms_[*it].validS)) == 1 ) { ufs_.push(*it); }
			}
		}
	}
	invalidQ_.clear();
	return ufs_.empty();
}

// checks whether the body can source its heads
bool DefaultUnfoundedCheck::isValidSource(const BodyPtr& n) {
	if (!n.node->extended()) {
		return bodies_[n.id].lower_or_ext == 0;
	}
	ExtData* ext = extended_[bodies_[n.id].lower_or_ext];
	if (ext->lower > 0) {
		// Since n is currently not a source,
		// we here know that no literal with a source can depend on this body.
		// Hence, we can safely add all those literals to WS.

		// We check all internal literals here because there may be atoms
		// that were sourced *after* we established the watch set.
		const uint32 inc = n.node->pred_inc();
		const NodeId* x  = n.node->preds();
		uint32       p   = 0;
		for (; *x != idMax; x += inc, ++p) {
			if (atoms_[*x].hasSource() && !ext->inWs(p) && !solver_->isFalse(graph_->getAtom(*x).lit)) {
				ext->addToWs(p, n.node->pred_weight(p, false));
			}
		}
		// We check all external literals here because we do not update
		// the body on backtracking. Therefore some external literals that were false
		// may now be true/free.
		for (++x; *x != idMax; x += inc, ++p) {
			if (!solver_->isFalse(Literal::fromRep(*x)) && !ext->inWs(p)) {
				ext->addToWs(p, n.node->pred_weight(p, true));
			}
		}
	}
	return ext->lower <= 0;
}

// enqueues all predecessors of this body that currently lack a source
// PRE: isValidSource(n) == false
void DefaultUnfoundedCheck::addUnsourced(const BodyPtr& n) {
	const uint32 inc = n.node->pred_inc();
	for (const NodeId* x = n.node->preds(); *x != idMax; x += inc) {
		if (!atoms_[*x].hasSource() && !solver_->isFalse(graph_->getAtom(*x).lit)) {
			pushUfs(*x);
		}
	}
}

// falsifies the atoms one by one from the unfounded set stored in unfounded_
bool DefaultUnfoundedCheck::falsifyUfs(UfsType t) {
	activeClause_.clear();
	for (uint32 rDL = 0; !ufs_.empty(); ) {
		Literal a = graph_->getAtom(ufs_.front()).lit;
		if (!solver_->isFalse(a) && !(assertAtom(a, t) && solver_->propagateUntil(this))) {
			if (t == ufs_non_poly) {
				mini_->schedNext(solver_->decisionLevel(), false);
			}
			break;
		}
		assert(solver_->isFalse(a));
		atoms_[ufs_.pop_ret()].ufs = 0;
		if      (ufs_.qFront == 1)               { rDL = solver_->decisionLevel(); }
		else if (solver_->decisionLevel() != rDL){ break; /* atoms may no longer be unfounded after backtracking */ }
	}
	if (!loopAtoms_.empty()) {
		createLoopFormula();
	}
	resetUfs();
	activeClause_.clear();
	return !solver_->hasConflict();
}

// asserts an unfounded atom using the selected reason strategy
bool DefaultUnfoundedCheck::assertAtom(Literal a, UfsType t) {
	if (solver_->isTrue(a) || strategy_ == distinct_reason || activeClause_.empty()) {
		// Conflict, first atom of unfounded set, or distinct reason for each atom requested -
		// compute reason for a being unfounded.
		// We must flush any not yet created loop formula here - the
		// atoms in loopAtoms_ depend on the current reason which is about to be replaced.
		if (!loopAtoms_.empty()) {
			createLoopFormula();
		}
		activeClause_.assign(1, ~a);
		computeReason(t);
	}
	activeClause_[0] = ~a;
	bool noClause = solver_->isTrue(a) || strategy_ == no_reason || strategy_ == only_reason || (strategy_ == shared_reason && activeClause_.size() > 3);
	if (noClause) {
		if (!solver_->force(~a, this))  { return false; }
		if (strategy_ == only_reason)   { reasons_[a.var()-1].assign(activeClause_.begin()+1, activeClause_.end()); }
		else if (strategy_ != no_reason){ loopAtoms_.push_back(~a); }
		return true;
	}
	else { // learn nogood and assert ~a
		return ClauseCreator::create(*solver_, activeClause_, ClauseCreator::clause_no_prepare, info_).ok();
	}
}
void DefaultUnfoundedCheck::createLoopFormula() {
	assert(activeClause_.size() > 3 && !loopAtoms_.empty());
	Antecedent ante;
	activeClause_[0] = loopAtoms_[0];
	if (loopAtoms_.size() == 1) {
		ante = ClauseCreator::create(*solver_, activeClause_, ClauseCreator::clause_no_prepare, info_).local;
	}
	else {
		ante = LoopFormula::newLoopFormula(*solver_
			, ClauseRep::prepared(&activeClause_[0], (uint32)activeClause_.size(), info_)
			, &loopAtoms_[0], (uint32)loopAtoms_.size());
		solver_->addLearnt(ante.constraint(), uint32(loopAtoms_.size() + activeClause_.size()), Constraint_t::Loop);
	}
	do {
		assert(solver_->isTrue(loopAtoms_.back()) && solver_->reason(loopAtoms_.back()) == this);
		solver_->setReason(loopAtoms_.back(), ante);
		loopAtoms_.pop_back();
	} while (!loopAtoms_.empty());
}

// computes the reason why a set of atoms is unfounded
void DefaultUnfoundedCheck::computeReason(UfsType t) {
	if (strategy_ == no_reason) { return; }
	uint32 ufsScc = graph_->getAtom(ufs_.front()).scc;
	for (VarVec::size_type i = ufs_.qFront; i != ufs_.vec.size(); ++i) {
		const AtomNode& atom = graph_->getAtom(ufs_.vec[i]);
		if (!solver_->isFalse(atom.lit)) {
			assert(atom.scc == ufsScc);
			for (const NodeId* x = atom.bodies_begin(); x != atom.bodies_end(); ++x) {
				BodyPtr body(getBody(*x));
				if (t == ufs_poly || !body.node->delta()){ addIfReason(body, ufsScc); }
				else                                     { addDeltaReason(body, ufsScc); }
			}
		}
	}
	for (VarVec::size_type i = 0; i != pickedExt_.size(); ++i) { bodies_[pickedExt_[i]].picked = 0; }
	pickedExt_.clear();
	info_     = ConstraintInfo(Constraint_t::Loop);
	uint32 rc = !solver_->isFalse(activeClause_[0]) && activeClause_.size() > 100 && activeClause_.size() > (solver_->decisionLevel() * 10);
	uint32 dl = solver_->finalizeConflictClause(activeClause_, info_, rc);
	uint32 cDL= solver_->decisionLevel();
	assert((t == ufs_non_poly || dl == cDL) && "Loop nogood must contain a literal from current DL!");
	if (dl < cDL && solver_->isUndoLevel()) {
		// cancel active propagation on cDL
		cancelPropagation();
		invalidQ_.clear();
		solver_->undoUntil(dl);
	}
}
// check whether n is external to the current unfounded set, i.e.
// does not depend on the atoms from the unfounded set
bool DefaultUnfoundedCheck::isExternal(const BodyPtr& n, weight_t& S) const {
#define IN_UFS(id) ( (atoms_[(id)].ufs) && !solver_->isFalse(graph_->getAtom((id)).lit) )
	if (!n.node->sum()) {
		for (const NodeId* x = n.node->preds(); *x != idMax && S >= 0; ++x) {
			if (IN_UFS(*x)) { S -= 1; }
		}
	}
	else {
		for (const NodeId* x = n.node->preds(); *x != idMax && S >= 0; x+=2) {
			if (IN_UFS(*x)) { S -= static_cast(x[1]); }
		}
	}
	return S >= 0;
#undef IN_UFS
}

// check if n is part of the reason for the current unfounded set
void DefaultUnfoundedCheck::addIfReason(const BodyPtr& n, uint32 uScc) {
	bool inF = solver_->isFalse(n.node->lit);
	weight_t S;
	if (!n.node->extended() || n.node->scc != uScc) {
		if (inF && !solver_->seen(n.node->lit) && (n.node->scc != uScc || isExternal(n, (S=0)))) {
			addReasonLit(n.node->lit);
		}
	}
	else if (bodies_[n.id].picked == 0) {
		if (isExternal(n, S = extended_[bodies_[n.id].lower_or_ext]->slack)) {
			AddReasonLit addFalseLits = { this, n.node, S };
			if (inF) { addReasonLit(n.node->lit); }
			else     { graph_->visitBodyLiterals(*n.node, addFalseLits); }
		}
		bodies_[n.id].picked = 1;
		pickedExt_.push_back(n.id);
	}
}

void DefaultUnfoundedCheck::addDeltaReason(const BodyPtr& n, uint32 uScc) {
	if (bodies_[n.id].picked != 0) return;
	uint32 bodyAbst = solver_->isFalse(n.node->lit) ? solver_->level(n.node->lit.var()) : solver_->decisionLevel() + 1;
	for (const NodeId* x = n.node->heads_begin(); x != n.node->heads_end(); ++x) {
		if (*x != DependencyGraph::sentinel_atom) { // normal head
			if (graph_->getAtom(*x).scc == uScc) {
				addIfReason(n, uScc);
			}
			continue;
		}
		else { // disjunctive head
			uint32  reasonAbst= bodyAbst;
			Literal reasonLit = n.node->lit;
			bool    inUfs     = false;
			Literal aLit;
			for (++x; *x; ++x) {
				if (atoms_[*x].ufs == 1) {
					inUfs = true;
				}
				else if (solver_->isTrue(aLit = graph_->getAtom(*x).lit) && solver_->level(aLit.var()) < reasonAbst) {
					reasonLit  = ~aLit;
					reasonAbst = solver_->level(reasonLit.var());
				}
			}
			if (inUfs && reasonAbst && reasonAbst <= solver_->decisionLevel()) {
				addReasonLit(reasonLit);
			}
		}
	}
	bodies_[n.id].picked = 1;
	pickedExt_.push_back(n.id);
}

void DefaultUnfoundedCheck::addReasonLit(Literal p) {
	if (!solver_->seen(p)) {
		solver_->markSeen(p);
		solver_->markLevel(solver_->level(p.var()));
		activeClause_.push_back(p);
		if (solver_->level(p.var()) > solver_->level(activeClause_[1].var())) {
			std::swap(activeClause_[1], activeClause_.back());
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////
// DefaultUnfoundedCheck - Minimality check for disjunctive logic programs
/////////////////////////////////////////////////////////////////////////////////////////
DefaultUnfoundedCheck::UfsType DefaultUnfoundedCheck::findNonHcfUfs(Solver& s) {
	assert(invalidQ_.empty() && loopAtoms_.empty());
	typedef DependencyGraph::NonHcfIter HccIter;
	HccIter hIt  = graph_->nonHcfBegin() + mini_->scc;
	HccIter hEnd = graph_->nonHcfEnd();
	for (uint32 checks = graph_->numNonHcfs(); checks--;) {
		s.stats.addTest(s.numFreeVars() != 0);
		(*hIt)->assumptionsFromAssignment(s, loopAtoms_);
		if (!(*hIt)->test(s, loopAtoms_, invalidQ_) || s.hasConflict()) {
			uint32 pos = 0, minDL = UINT32_MAX;
			for (VarVec::const_iterator it = invalidQ_.begin(), end = invalidQ_.end(); it != end; ++it) {
				if (s.isTrue(graph_->getAtom(*it).lit) && s.level(graph_->getAtom(*it).lit.var()) < minDL) {
					minDL = s.level(graph_->getAtom(*it).lit.var());
					pos   = (uint32)ufs_.vec.size();
				}
				pushUfs(*it);
			}
			if (pos) {
				std::swap(ufs_.vec.front(), ufs_.vec[pos]);
			}
			invalidQ_.clear();
			loopAtoms_.clear();
			mini_->scc = static_cast(hIt - graph_->nonHcfBegin());
			return ufs_non_poly;
		}
		if (++hIt == hEnd) { hIt = graph_->nonHcfBegin(); }
		loopAtoms_.clear();
	}
	mini_->schedNext(s.decisionLevel(), true);
	return ufs_none;
}

DefaultUnfoundedCheck::MinimalityCheck::MinimalityCheck(const FwdCheck& afwd) : fwd(afwd), high(UINT32_MAX), low(0), next(0), scc(0) {
	if (fwd.highPct > 100) { fwd.highPct  = 100; }
	if (fwd.highStep == 0) { fwd.highStep = ~fwd.highStep; }
	high = fwd.highStep;
}

bool DefaultUnfoundedCheck::MinimalityCheck::partialCheck(uint32 level) {
	if (level < low) {
		next -= (low - level);
		low   = level;
	}
	return !next || next == level;
}

void DefaultUnfoundedCheck::MinimalityCheck::schedNext(uint32 level, bool ok) {
	low  = 0;
	next = UINT32_MAX;
	if (!ok) {
		high = level;
		next = 0;
	}
	else if (fwd.highPct != 0) {
		double p = fwd.highPct / 100.0;
		high     = std::max(high, level);
		low      = level;
		if (low >= high) {
			high  += fwd.highStep;
		}
		next     = low + (uint32)std::ceil((high - low) * p);
	}
}
}
clasp-3.2.2/libclasp/src/weight_constraint.cpp000066400000000000000000000542461304134206100214440ustar00rootroot00000000000000//
// Copyright (c) 2006-2011, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#include 
#include 
#include 
#include 
#include 

namespace Clasp {
/////////////////////////////////////////////////////////////////////////////////////////
// WeightLitsRep
/////////////////////////////////////////////////////////////////////////////////////////
// Removes assigned and merges duplicate/complementary literals.
// return: achievable weight
// post  : lits is sorted by decreasing weights
WeightLitsRep WeightLitsRep::create(Solver& s, WeightLitVec& lits, weight_t bound) {
	// Step 1: remove assigned/superfluous literals and merge duplicate/complementary ones
	LitVec::size_type j = 0, other;
	const weight_t MAX_W= std::numeric_limits::max();
	for (LitVec::size_type i = 0; i != lits.size(); ++i) {
		Literal x = lits[i].first.unflag();
		if (lits[i].second != 0 && s.topValue(x.var()) == value_free) {
			if (lits[i].second < 0) {
				lits[i].second = -lits[i].second;
				lits[i].first  = x = ~lits[i].first;
				CLASP_ASSERT_CONTRACT_MSG(bound < 0 || (MAX_W-bound) >= lits[i].second, "bound out of range");
				bound         += lits[i].second;
			}
			if (!s.seen(x.var())) { // first time we see x, keep and mark x
				if (i != j) lits[j] = lits[i];
				s.markSeen(x);
				++j;
			}
			else if (!s.seen(~x)) { // multi-occurrences of x, merge
				for (other = 0; other != j && lits[other].first != x; ++other) { ; }
				lits[other].second += lits[i].second;
			}
			else {                  // complementary literals ~x x
				for (other = 0; other != j && lits[other].first != ~x; ++other) { ; }
				bound              -= lits[i].second; // decrease by min(w(~x), w(x)) ; assume w(~x) > w(x)
				lits[other].second -= lits[i].second; // keep ~x,
				if (lits[other].second < 0) {         // actually, w(x) > w(~x),
					lits[other].first  = x;             // replace ~x with x
					lits[other].second = -lits[other].second;
					s.clearSeen(x.var());
					s.markSeen(x);
					bound += lits[other].second;        // and correct the bound
				}
				else if (lits[other].second == 0) {   // w(~x) == w(x) - drop both lits
					s.clearSeen(x.var());
					std::memmove(&lits[0]+other, &lits[0]+other+1, (j-other-1)*sizeof(lits[other]));
					--j;
				}
			}
		}
		else if (s.isTrue(x)) { bound -= lits[i].second; }
	}
	lits.erase(lits.begin()+j, lits.end());
	// Step 2: compute min,max, achievable weight and clear flags set in step 1
	weight_t sumW = 0;
	weight_t minW = MAX_W, maxW = 1;
	weight_t B    = std::max(bound, 1);
	for (LitVec::size_type i = 0; i != lits.size(); ++i) {
		assert(lits[i].second > 0);
		s.clearSeen(lits[i].first.var());
		if (lits[i].second > maxW) { maxW = lits[i].second = std::min(lits[i].second, B);  }
		if (lits[i].second < minW) { minW = lits[i].second; }
		CLASP_ASSERT_CONTRACT_MSG((MAX_W - sumW) >= lits[i].second, "Sum of weights out of range");
		sumW += lits[i].second;
	}
	// Step 3: sort by decreasing weight
	if (maxW != minW) {
		std::stable_sort(lits.begin(), lits.end(), compose22(
			std::greater(),
			select2nd(),
			select2nd()));
	}
	else if (minW != 1) {
		// disguised cardinality constraint
		bound = (bound+(minW-1))/minW;
		sumW  = (sumW+(minW-1))/minW;
		for (LitVec::size_type i = 0; i != lits.size(); ++i) { lits[i].second = 1; }
	}
	WeightLitsRep result = { !lits.empty() ? &lits[0] : 0, (uint32)lits.size(), bound, sumW };
	return result;
}

// Propagates top-level assignment.
bool WeightLitsRep::propagate(Solver& s, Literal W) {
	if      (sat())  { return s.force(W); } // trivially SAT
	else if (unsat()){ return s.force(~W);} // trivially UNSAT
	else if (s.topValue(W.var()) == value_free) {
		return true;
	}
	// backward propagate
	bool bpTrue = s.isTrue(W);
	weight_t B  = bpTrue ? (reach-bound)+1 : bound;
	while (lits->second >= B) {
		reach -= lits->second;
		if (!s.force(bpTrue ? lits->first : ~lits->first, 0))        { return false; }
		if ((bpTrue && (bound -= lits->second) <= 0) || --size == 0) { return true;  }
		++lits;
	}
	if (lits->second > 1 && lits->second == lits[size-1].second) {
		B     = lits->second;
		bound = (bound + (B-1)) / B;
		reach = (reach + (B-1)) / B;
		for (uint32 i = 0; i != size && lits[i].second != 1; ++i) { lits[i].second = 1; }
	}
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////////
// WeightConstraint::WL
/////////////////////////////////////////////////////////////////////////////////////////
typedef Clasp::Atomic_t::type RCType;
WeightConstraint::WL::WL(uint32 s, bool shared, bool hasW) : sz(s), rc(shared), w(hasW) { }
uint8* WeightConstraint::WL::address() { return reinterpret_cast(this) - (sizeof(uint32) * rc); }
WeightConstraint::WL* WeightConstraint::WL::clone(){
	if (shareable()) {
		++*reinterpret_cast(address());
		return this;
	}
	else {
		uint32 litSize = (size() << uint32(weights()))*sizeof(Literal);
		WL* x          = new (::operator new(sizeof(WL) + litSize)) WL(size(), false, weights());
		std::memcpy(x->lits, this->lits, litSize);
		return x;
	}
}
void WeightConstraint::WL::release() {
	unsigned char* x = address();
	if (!shareable() || --*reinterpret_cast(x) == 0) {
		::operator delete(x);
	}
}
uint32 WeightConstraint::WL::refCount() const {
	assert(shareable());
	return *reinterpret_cast(const_cast(this)->address());
}
/////////////////////////////////////////////////////////////////////////////////////////
// WeightConstraint
/////////////////////////////////////////////////////////////////////////////////////////
WeightConstraint::CPair WeightConstraint::create(Solver& s, Literal W, WeightLitVec& lits, weight_t bound, uint32 flags) {
	bool const    eq  = (flags & create_eq_bound) != 0;
	WeightLitsRep rep = WeightLitsRep::create(s, lits, bound + static_cast(eq));
	CPair res;
	if (eq) {
		res.con[1] = WeightConstraint::doCreate(s, ~W, rep, flags);
		rep.bound -= 1;
		if (!res.ok()) { return res; }
		// redo coefficient reduction
		for (unsigned i = 0; i != rep.size && rep.lits[i].second > rep.bound; ++i) {
			rep.reach -= rep.lits[i].second;
			rep.reach += (rep.lits[i].second = rep.bound);
		}
	}
	res.con[0] = WeightConstraint::doCreate(s, W, rep, flags);
	return res;
}
WeightConstraint::CPair WeightConstraint::create(Solver& s, Literal W, WeightLitsRep& rep, uint32 flags) {
	CPair res;
	res.con[0] = doCreate(s, W, rep, flags);
	return res;
}

WeightConstraint* WeightConstraint::doCreate(Solver& s, Literal W, WeightLitsRep& rep, uint32 flags) {
	WeightConstraint* conflict = (WeightConstraint*)0x1;
	bool addSat = (flags&create_sat) != 0 && rep.size;
	if (!rep.propagate(s, W))                 { return conflict; }
	if (rep.unsat() || (rep.sat() && !addSat)){ return 0; }
	if ((rep.bound == 1 || rep.bound == rep.reach) && (flags & create_explicit) == 0) {
		LitVec clause; clause.reserve(1 + rep.size);
		Literal bin[2];
		bool disj = rep.bound == 1; // con == disjunction or con == conjunction
		bool sat  = false;
		clause.push_back(W ^ disj);
		for (LitVec::size_type i = 0; i != rep.size; ++i) {
			bin[0] = ~clause[0];
			bin[1] = rep.lits[i].first ^ disj;
			if (bin[0] != ~bin[1]) {
				if (bin[0] != bin[1])                 { clause.push_back(~bin[1]); }
				if (!s.add(ClauseRep::create(bin, 2))){ return conflict; }
			}
			else { sat = true; }
		}
		return (sat || ClauseCreator::create(s, clause, 0)) ? 0 : conflict;
	}
	assert(rep.open() || (rep.sat() && addSat));
	uint32 act  = 3u;
	if (flags & (create_only_btb|create_only_bfb)) {
		act  = ((flags & (create_only_btb|create_only_bfb)) / create_only_btb) - 1u;
		act += (act == 2u);
	}
	if (!s.sharedContext()->physicalShareProblem()) { flags |= create_no_share; }
	if (s.sharedContext()->frozen())                { flags |= (create_no_freeze|create_no_share); }
	bool   hasW = rep.hasWeights();
	uint32 size = 1 + rep.size;
	uint32 nb   = sizeof(WeightConstraint) + (size+uint32(hasW))*sizeof(UndoInfo);
	uint32 wls  = sizeof(WL) + (size << uint32(hasW))*sizeof(Literal);
	void*  m    = 0;
	WL*    sL   = 0;
	if ((flags & create_no_share) != 0) {
		nb = ((nb + 3) / 4)*4;
		m  = ::operator new (nb + wls);
		sL = new (reinterpret_cast(m)+nb) WL(size, false, hasW);
	}
	else {
		static_assert(sizeof(RCType) == sizeof(uint32), "Invalid size!");
		m = ::operator new(nb);
		uint8* t = (uint8*)::operator new(wls + sizeof(uint32));
		*(new (t) RCType) = 1;
		sL = new (t+sizeof(uint32)) WL(size, true, hasW);
	}
	assert(m && (reinterpret_cast(m) & 7u) == 0);
	SharedContext*  ctx = (flags & create_no_freeze) == 0 ? const_cast(s.sharedContext()) : 0;
	WeightConstraint* c = new (m) WeightConstraint(s, ctx, W, rep, sL, act);
	if (!c->integrateRoot(s)) {
		c->destroy(&s, true);
		return conflict;
	}
	if ((flags & create_no_add) == 0) { s.add(c); }
	return c;
}
WeightConstraint::WeightConstraint(Solver& s, SharedContext* ctx, Literal W, const WeightLitsRep& rep, WL* out, uint32 act) {
	typedef unsigned char Byte_t;
	const bool hasW = rep.hasWeights();
	lits_           = out;
	active_         = act;
	ownsLit_        = !out->shareable();
	Literal* p      = lits_->lits;
	Literal* h      = new (reinterpret_cast(undo_)) Literal(W);
	weight_t w      = 1;
	bound_[FFB_BTB]	= (rep.reach-rep.bound)+1; // ffb-btb
	bound_[FTB_BFB]	= rep.bound;               // ftb-bfb
	*p++            = ~W;                      // store constraint literal
	if (hasW) *p++  = Literal::fromRep(w);     // and weight if necessary
	if (ctx) ctx->setFrozen(W.var(), true);    // exempt from variable elimination
	if (s.topValue(W.var()) != value_free) {   // only one direction is relevant
		active_ = FFB_BTB+s.isFalse(W);
	}
	watched_        = 3u - (active_ != 3u || ctx == 0);
	WeightLiteral*x = rep.lits;
	for (uint32 sz = rep.size, j = 1; sz--; ++j, ++x) {
		h    = new (h + 1) Literal(x->first);
		*p++ = x->first;                         // store constraint literal
		w    = x->second;                        // followed by weight
		if (hasW) *p++= Literal::fromRep(w);     // if necessary
		addWatch(s, j, FTB_BFB);                 // watches  lits[idx]
		addWatch(s, j, FFB_BTB);                 // watches ~lits[idx]
		if (ctx) ctx->setFrozen(h->var(), true); // exempt from variable elimination
	}
	// init heuristic
	h -= rep.size;
	uint32 off = active_ != NOT_ACTIVE;
	assert((void*)h == (void*)undo_);
	s.heuristic()->newConstraint(s, h+off, rep.size+(1-off), Constraint_t::Static);
	// init undo stack
	up_                 = undoStart();     // undo stack is initially empty
	undo_[0].data       = 0;
	undo_[up_].data     = 0;
	setBpIndex(1);                         // where to start back propagation
	if (s.topValue(W.var()) == value_free){
		addWatch(s, 0, FTB_BFB);             // watch con in both phases
		addWatch(s, 0, FFB_BTB);             // in order to allow for backpropagation
	}
	else {
		uint32 d = active_;                  // propagate con
		WeightConstraint::propagate(s, ~lit(0, (ActiveConstraint)active_), d);
	}
}

WeightConstraint::WeightConstraint(Solver& s, const WeightConstraint& other) {
	typedef unsigned char Byte_t;
	lits_        = other.lits_->clone();
	ownsLit_     = 0;
	Literal* heu = new (reinterpret_cast(undo_))Literal(~lits_->lit(0));
	bound_[0]	   = other.bound_[0];
	bound_[1]	   = other.bound_[1];
	active_      = other.active_;
	watched_     = other.watched_;
	if (active_ == NOT_ACTIVE && s.value(heu->var()) == value_free) {
		addWatch(s, 0, FTB_BFB);  // watch con in both phases
		addWatch(s, 0, FFB_BTB);  // in order to allow for backpropagation
	}
	for (uint32 i = 1, end = size(); i < end; ++i) {
		heu = new (heu + 1) Literal(lits_->lit(i));
		if (s.value(heu->var()) == value_free) {
			addWatch(s, i, FTB_BFB);  // watches  lits[i]
			addWatch(s, i, FFB_BTB);  // watches ~lits[i]
		}
	}
	// Initialize heuristic with literals (no weights) in constraint.
	uint32 off = active_ != NOT_ACTIVE;
	heu -= (size() - 1);
	assert((void*)heu == (void*)undo_);
	s.heuristic()->newConstraint(s, heu+off, size()-off, Constraint_t::Static);
	// Init undo stack
	std::memcpy(undo_, other.undo_, sizeof(UndoInfo)*(size()+isWeight()));
	up_ = other.up_;
}

WeightConstraint::~WeightConstraint() {}
Constraint* WeightConstraint::cloneAttach(Solver& other) {
	void* m = ::operator new(sizeof(WeightConstraint) + (size()+isWeight())*sizeof(UndoInfo));
	return new (m) WeightConstraint(other, *this);
}

bool WeightConstraint::integrateRoot(Solver& s) {
	if (!s.decisionLevel() || highestUndoLevel(s) >= s.rootLevel() || s.hasConflict()) { return !s.hasConflict(); }
	// check if constraint has assigned literals
	uint32 low = s.decisionLevel(), vDL;
	uint32 np  = 0;
	for (uint32 i = 0, end = size(); i != end; ++i) {
		Var v = lits_->var(i);
		if (s.value(v) != value_free && (vDL = s.level(v)) != 0) {
			++np;
			s.markSeen(v);
			low = std::min(low, vDL);
		}
	}
	// propagate assigned literals in assignment order
	const LitVec& trail = s.trail();
	const uint32  end   = sizeVec(trail) - s.queueSize();
	GenericWatch* w     = 0;
	for (uint32 i = s.levelStart(low); i != end && np; ++i) {
		Literal p = trail[i];
		if (s.seen(p) && np--) {
			s.clearSeen(p.var());
			if (!s.hasConflict() && (w = s.getWatch(trail[i], this)) != 0) {
				w->propagate(s, p);
			}
		}
	}
	for (uint32 i = end; i != trail.size() && np; ++i) {
		if (s.seen(trail[i].var())) { --np; s.clearSeen(trail[i].var()); }
	}
	return !s.hasConflict();
}
void WeightConstraint::addWatch(Solver& s, uint32 idx, ActiveConstraint c) {
	// Add watch only if c is relevant.
	if (uint32(c^1) != active_) {
		// Use LSB to store the constraint that watches the literal.
		s.addWatch(~lit(idx, c), this, (idx<<1)+c);
	}
}

void WeightConstraint::destroy(Solver* s, bool detach) {
	if (s && detach) {
		for (uint32 i = 0, end = size(); i != end; ++i) {
			s->removeWatch( lits_->lit(i), this );
			s->removeWatch(~lits_->lit(i), this );
		}
		for (uint32 last = 0, dl; (dl = highestUndoLevel(*s)) != 0; --up_) {
			if (dl != last) { s->removeUndoWatch(last = dl, this); }
		}
	}
	if (ownsLit_ == 0) { lits_->release(); }
	void* mem = static_cast(this);
	this->~WeightConstraint();
	::operator delete(mem);
}

void WeightConstraint::setBpIndex(uint32 n){
	if (isWeight()) undo_[0].data = (n<<1)+(undo_[0].data&1);
}

// Returns the numerical highest decision level watched by this constraint.
uint32 WeightConstraint::highestUndoLevel(Solver& s) const {
	return up_ != undoStart()
		? s.level(lits_->var(undoTop().idx()))
		: 0;
}

// Updates the bound of sub-constraint c and adds the literal at index idx to the
// undo stack. If the current decision level is not watched, an undo watch is added
// so that the bound can be adjusted once the solver backtracks.
void WeightConstraint::updateConstraint(Solver& s, uint32 idx, ActiveConstraint c) {
	bound_[c] -= weight(idx);
	if (highestUndoLevel(s) != s.decisionLevel()) {
		s.addUndoWatch(s.decisionLevel(), this);
	}
	undo_[up_].data = (idx<<2) + (c<<1) + (undo_[up_].data & 1);
	++up_;
	assert(!litSeen(idx));
	toggleLitSeen(idx);
}

// Since clasp uses an eager assignment strategy where literals are assigned as soon
// as they are added to the propagation queue, we distinguish processed from unprocessed literals.
// Processed literals are those for which propagate was already called and the corresponding bound
// was updated; they are flagged in updateConstraint().
// Unprocessed literals are either free or were not yet propagated. During propagation
// we treat all unprocessed literals as free. This way, conflicts are detected early.
// Consider: x :- 3 [a=3, b=2, c=1,d=1] and PropQ: b, ~Body, c.
// Initially b, ~Body, c are unprocessed and the bound is 3.
// Step 1: propagate(b)    : b is marked as processed and bound is reduced to 1.
//   Now, although we already know that the body is false, we do not backpropagate yet
//   because the body is unprocessed. Deferring backpropagation until the body is processed
//   makes reason computation easier.
// Step 2: propagate(~Body): ~body is marked as processed and bound is reduced to 0.
//   Since the body is now part of our reason set, we can start backpropagation.
//   First we assign the unprocessed and free literal ~a. Literal ~b is skipped, because
//   its complementary literal was already successfully processed. Finally, we force
//   the unprocessed but false literal ~c to true. This will generate a conflict and
//   propagation is stopped. Without the distinction between processed and unprocessed
//   lits we would have to skip ~c. We would then have to manually trigger the conflict
//   {b, ~Body, c} in step 3, when propagate(c) sets the bound to -1.
Constraint::PropResult WeightConstraint::propagate(Solver& s, Literal, uint32& d) {
	// determine the affected constraint and its body literal
	ActiveConstraint c  = (ActiveConstraint)(d&1);
	const uint32   idx  = d >> 1;
	Literal body        = lit(0, c);
	if ( uint32(c^1) == active_ || s.isTrue(body) ) {
		// the other constraint is active or this constraint is already satisfied;
		// nothing to do
		return PropResult(true, true);
	}
	if (idx == 0 && s.decisionLevel() == s.rootLevel() && watched_ == 3u) {
		watched_ = c;
		for (uint32 i = 1, end = size(); i != end; ++i) {
			s.removeWatch(lit(i, c), this);
		}
	}
	// the constraint is not yet satisfied; update it and
	// check if we can now propagate any literals.
	updateConstraint(s, idx, c);
	if (bound_[c] <= 0 || (isWeight() && litSeen(0))) {
		uint32 reasonData = !isWeight() ? UINT32_MAX : up_;
		if (!litSeen(0)) {
			// forward propagate constraint to true
			active_ = c;
			return PropResult(s.force(body, this, reasonData), true);
		}
		else {
			// backward propagate false constraint
			uint32 n = getBpIndex();
			for (const uint32 end = size(); n != end && (bound_[c] - weight(n)) < 0; ++n) {
				if (!litSeen(n)) {
					active_   = c;
					Literal x = lit(n, c);
					if (!s.force(x, this, reasonData)) {
						return PropResult(false, true);
					}
				}
			}
			assert(n == 1 || n == size() || isWeight());
			setBpIndex(n);
		}
	}
	return PropResult(true, true);
}

// Builds the reason for p from the undo stack of this constraint.
// The reason will only contain literals that were processed by the
// active sub-constraint.
void WeightConstraint::reason(Solver& s, Literal p, LitVec& r) {
	assert(active_ != NOT_ACTIVE);
	Literal x;
	uint32 stop = !isWeight() ? up_ : s.reasonData(p);
	assert(stop <= up_);
	for (uint32 i = undoStart(); i != stop; ++i) {
		UndoInfo u = undo_[i];
		// Consider only lits that are relevant to the active constraint
		if (u.constraint() == (ActiveConstraint)active_) {
			x = lit(u.idx(), u.constraint());
			r.push_back( ~x );
		}
	}
}

bool WeightConstraint::minimize(Solver& s, Literal p, CCMinRecursive* rec) {
	assert(active_ != NOT_ACTIVE);
	Literal x;
	uint32 stop = !isWeight() ? up_ : s.reasonData(p);
	assert(stop <= up_);
	for (uint32 i = undoStart(); i != stop; ++i) {
		UndoInfo u = undo_[i];
		// Consider only lits that are relevant to the active constraint
		if (u.constraint() == (ActiveConstraint)active_) {
			x = lit(u.idx(), u.constraint());
			if (!s.ccMinimize(~x, rec)) {
				return false;
			}
		}
	}
	return true;
}

// undoes processed assignments
void WeightConstraint::undoLevel(Solver& s) {
	setBpIndex(1);
	for (UndoInfo u; up_ != undoStart() && s.value(lits_->var((u=undoTop()).idx())) == value_free;) {
		assert(litSeen(u.idx()));
		toggleLitSeen(u.idx());
		bound_[u.constraint()] += weight(u.idx());
		--up_;
	}
	if (!litSeen(0)) {
		active_ = NOT_ACTIVE;
		if (watched_ < 2u) {
			ActiveConstraint other = static_cast(watched_^1);
			for (uint32 i = 1, end = size(); i != end; ++i) {
				addWatch(s, i, other);
			}
			watched_ = 3u;
		}
	}
}

bool WeightConstraint::simplify(Solver& s, bool) {
	if (bound_[0] <= 0 || bound_[1] <= 0) {
		for (uint32 i = 0, end = size(); i != end; ++i) {
			s.removeWatch( lits_->lit(i), this );
			s.removeWatch(~lits_->lit(i), this );
		}
		return true;
	}
	else if (s.value(lits_->var(0)) != value_free && (active_ == NOT_ACTIVE || isWeight())) {
		if (active_ == NOT_ACTIVE) {
			Literal W = ~lits_->lit(0);
			active_   = FFB_BTB+s.isFalse(W);
		}
		for (uint32 i = 0, end = size(); i != end; ++i) {
			s.removeWatch(lit(i, (ActiveConstraint)active_), this);
		}
	}
	if (lits_->unique() && size() > 4 && (up_ - undoStart()) > size()/2) {
		Literal*     lits = lits_->lits;
		const uint32 inc  = 1 + lits_->weights();
		uint32       end  = lits_->size()*inc;
		uint32 i, j, idx  = 1;
		// find first assigned literal - must be there otherwise undo stack would be empty
		for (i = inc; s.value(lits[i].var()) == value_free; i += inc) {
			assert(!litSeen(idx));
			++idx;
		}
		// move unassigned literals down
		// update watches because indices have changed
		for (j = i, i += inc; i != end; i += inc) {
			if (s.value(lits[i].var()) == value_free) {
				lits[j] = lits[i];
				if (lits_->weights()) { lits[j+1] = lits[i+1]; }
				undo_[idx].data = 0;
				assert(!litSeen(idx));
				if (Clasp::GenericWatch* w = s.getWatch(lits[i], this)) {
					w->data = (idx<<1) + 1;
				}
				if (Clasp::GenericWatch* w = s.getWatch(~lits[i], this)) {
					w->data = (idx<<1) + 0;
				}
				j += inc;
				++idx;
			}
			else {
				s.removeWatch(lits[i], this);
				s.removeWatch(~lits[i], this);
			}
		}
		// clear undo stack & update to new size
		up_ = undoStart();
		setBpIndex(1);
		lits_->sz = idx;
	}
	return false;
}

uint32 WeightConstraint::estimateComplexity(const Solver& s) const {
	weight_t B = std::min(bound_[0], bound_[1]);
	uint32 r   = 2;
	for (uint32 i = 1; i != size() && B > 0; ++i) {
		if (s.value(lits_->var(i)) == value_free) {
			++r;
			B -= weight(i);
		}
	}
	return r;
}
}
clasp-3.2.2/libclasp/tests/000077500000000000000000000000001304134206100155455ustar00rootroot00000000000000clasp-3.2.2/libclasp/tests/Makefile000066400000000000000000000015131304134206100172050ustar00rootroot00000000000000SHELL = /bin/sh
CXX = g++
CXXFLAGS = 
INCLUDE = -I../ -I.
ALL_CXXFLAGS = $(INCLUDE) $(CXXFLAGS)
TARGET = clasp_test
CPPUNIT_INCLUDE:=~/cppunit-1.12.1/include
CPPUNIT_LIB:=~/cppunit-1.12.1/lib/libcppunit.a
clasp_lib:=../lib/libclasp.a
sources:=$(wildcard *.cpp)
objects:=$(patsubst %.cpp,%.o,$(sources))
deps:=$(patsubst %.cpp,%.dep,$(sources))

$(TARGET):	$(clasp_lib) $(objects) $(deps)
	$(CXX) $(ALL_CXXFLAGS) $(objects) $(clasp_lib) $(CPPUNIT_LIB) -o $(TARGET)

ifneq ($(MAKECMDGOALS),clean)
  ifneq ($(MAKECMDGOALS),distclean)
    -include $(deps)
  endif
endif

%.o:	%.cpp
	$(CXX) $(ALL_CXXFLAGS) -I $(CPPUNIT_INCLUDE) -c $< -o $@

%.dep: %.cpp
	$(CXX) $(INCLUDE) -I $(CPPUNIT_INCLUDE) -MM $< > $@

$(clasp_lib):
	$(MAKE)  -C ../src

.PHONY:	clean distclean
clean:
	@$(RM) $(TARGET)
	@$(RM) $(objects)
	@$(RM) $(deps)

distclean: clean


clasp-3.2.2/libclasp/tests/clause_creator_test.cpp000066400000000000000000000553241304134206100223140ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 
#include 
#include 
namespace Clasp { namespace Test {
using namespace Clasp::mt;
class ClauseCreatorTest : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(ClauseCreatorTest);
	CPPUNIT_TEST(testEmptyClauseIsFalse);
	CPPUNIT_TEST(testFactsAreAsserted);
	CPPUNIT_TEST(testTopLevelSATClausesAreNotAdded);
	CPPUNIT_TEST(testTopLevelFalseLitsAreRemoved);
	CPPUNIT_TEST(testAddBinaryClause);
	CPPUNIT_TEST(testAddTernaryClause);
	CPPUNIT_TEST(testAddGenericClause);
	CPPUNIT_TEST(testCreatorAssertsFirstLit);
	CPPUNIT_TEST(testCreatorInitsWatches);
	CPPUNIT_TEST(testCreatorNotifiesHeuristic);
	CPPUNIT_TEST(testCreatorAddLitBug);

	CPPUNIT_TEST(testCreatorSimplifyRemovesDuplicates);
	CPPUNIT_TEST(testCreatorSimplifyFindsTauts);
	CPPUNIT_TEST(testCreatorSimplifyMovesWatch);
	CPPUNIT_TEST(testCreatorSimplifyBug);

	CPPUNIT_TEST(testCreateNonAssertingLearntClause);
	CPPUNIT_TEST(testCreateLearntClauseConflict);
	CPPUNIT_TEST(testCreateNonAssertingLearntClauseAsserting);
	CPPUNIT_TEST(testCreateBogusUnit);

	CPPUNIT_TEST(testInitWatches);
	CPPUNIT_TEST(testIntegrateEmpty);
	CPPUNIT_TEST(testIntegrateUnit);
	CPPUNIT_TEST(testIntegrateUnitSAT);
	CPPUNIT_TEST(testIntegrateConflict);
	CPPUNIT_TEST(testIntegrateAssertingConflict);
	CPPUNIT_TEST(testIntegrateAssertingConflictBelowRoot);
	CPPUNIT_TEST(testIntegrateConflictBelowRoot);
	CPPUNIT_TEST(testIntegrateSATBug1);
	CPPUNIT_TEST(testIntegrateSATBug2);
	CPPUNIT_TEST(testIntegrateSATBug3);
	CPPUNIT_TEST(testIntegrateSATBug4);
	CPPUNIT_TEST(testIntegrateKnownOrderBug);
	CPPUNIT_TEST(testIntegrateNotConflictingBug);
	CPPUNIT_TEST(testIntegrateSimplify);
	CPPUNIT_TEST(testIntegrateSAT);
	CPPUNIT_TEST(testIntegrateUnsat);
	CPPUNIT_TEST(testIntegrateAssertingBelowBT);
	CPPUNIT_TEST(testIntegrateConflictBelowBT);

	CPPUNIT_TEST(testFactsAreRemovedFromLearnt);
	CPPUNIT_TEST_SUITE_END();
public:
	ClauseCreatorTest() {
		a = posLit(ctx.addVar(Var_t::Atom));
		b = posLit(ctx.addVar(Var_t::Atom));
		c = posLit(ctx.addVar(Var_t::Atom));
		d = posLit(ctx.addVar(Var_t::Atom));
		e = posLit(ctx.addVar(Var_t::Atom));
		f = posLit(ctx.addVar(Var_t::Atom));
		creator.setSolver(*ctx.master());
		ctx.startAddConstraints(1);
	}
	void testEmptyClauseIsFalse() {
		CPPUNIT_ASSERT_EQUAL(false, (bool)creator.start().end());
	}

	void testFactsAreAsserted() {
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start().add(a).end());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(a));
	}
	void testTopLevelSATClausesAreNotAdded() {
		solver().force(a, 0);
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start().add(a).add(b).end());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
	}
	void testTopLevelFalseLitsAreRemoved() {
		solver().force(~a, 0);
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start().add(a).add(b).end());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(b));
	}
	void testAddBinaryClause() {
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start().add(a).add(b).end());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numConstraints());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numBinary());
	}
	void testAddTernaryClause() {
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start().add(a).add(b).add(c).end());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numConstraints());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numTernary());
	}
	void testAddGenericClause() {
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start().add(a).add(b).add(c).add(d).end());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numConstraints());
	}

	void testCreatorAssertsFirstLit() {
		ctx.endInit();
		solver().assume(~b);
		solver().assume(~c);
		solver().assume(~d);
		solver().propagate();
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start(Constraint_t::Conflict).add(a)
			.add(b).add(c).add(d).end());

		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(a));
		CPPUNIT_ASSERT_EQUAL(false, solver().hasConflict());
		CPPUNIT_ASSERT_EQUAL(1u, solver().numLearntConstraints());
	}

	void testCreatorInitsWatches() {
		ctx.endInit();
		solver().assume(~b);
		solver().assume(~c);
		solver().assume(~d);

		creator.start(Constraint_t::Conflict).add(a).add(b).add(d).add(c);
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.end());	// asserts a
		solver().undoUntil(2);	// clear a and d
		solver().assume(~d);		// hopefully d was watched.
		solver().propagate();
		CPPUNIT_ASSERT_EQUAL( value_true, solver().value(a.var()) );
	}
	void testCreatorNotifiesHeuristic() {
		struct FakeHeu : public SelectFirst {
			void newConstraint(const Solver&, const Literal*, LitVec::size_type size, ConstraintType t) {
				clSizes_.push_back(size);
				clTypes_.push_back(t);
			}
			std::vector clSizes_;
			std::vector clTypes_;
		}heu;
		solver().setHeuristic(&heu, Ownership_t::Retain);
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start().add(a).add(b).add(c).add(d).end());
		ctx.endInit();
		solver().assume(a);
		solver().assume(b);
		solver().propagate();

		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start(Constraint_t::Conflict).add(c)
			.add(~a).add(~b).end());

		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.start(Constraint_t::Loop).add(c)
			.add(~a).add(~b).end(0));

		CPPUNIT_ASSERT_EQUAL(uint32(3), (uint32)heu.clSizes_.size());
		CPPUNIT_ASSERT_EQUAL(uint32(4), (uint32)heu.clSizes_[0]);
		CPPUNIT_ASSERT_EQUAL(uint32(3), (uint32)heu.clSizes_[1]);
		CPPUNIT_ASSERT_EQUAL(uint32(3), (uint32)heu.clSizes_[2]);

		CPPUNIT_ASSERT_EQUAL(Constraint_t::Static, heu.clTypes_[0]);
		CPPUNIT_ASSERT_EQUAL(Constraint_t::Conflict, heu.clTypes_[1]);
		CPPUNIT_ASSERT_EQUAL(Constraint_t::Loop, heu.clTypes_[2]);
	}

	void testCreatorAddLitBug() {
		creator.start(Constraint_t::Conflict).add(a);
		solver().assume(b) && solver().propagate();
		creator.add(~b);
		solver().assume(c) && solver().propagate();
		creator.add(~c);
		solver().assume(d) && solver().propagate();
		creator.add(~d);
		creator.end();
		CPPUNIT_ASSERT_MESSAGE("TODO: Fix me!", creator[0] == a);
	}

	void testCreatorSimplifyRemovesDuplicates() {
		creator.start().add(a).add(b).add(c).add(a).add(b).add(d).prepare(true);
		CPPUNIT_ASSERT(creator.size() == 4);
		CPPUNIT_ASSERT(creator[0] == a);
		CPPUNIT_ASSERT(creator[1] == b);
		CPPUNIT_ASSERT(creator[2] == c);
		CPPUNIT_ASSERT(creator[3] == d);
	}
	void testCreatorSimplifyFindsTauts() {
		creator.start().add(a).add(b).add(c).add(a).add(b).add(~a).end(ClauseCreator::clause_force_simplify);
		CPPUNIT_ASSERT(0 == ctx.numConstraints());
	}
	void testCreatorSimplifyMovesWatch() {
		ctx.endInit();
		solver().assume(a); solver().propagate();
		solver().assume(b); solver().propagate();
		creator.start(Constraint_t::Loop);
		creator.add(~a).add(~b).add(~b).add(~a).add(c).add(d).prepare(true);
		CPPUNIT_ASSERT(creator.size() == 4);
		CPPUNIT_ASSERT_EQUAL(c, creator[0]);
		CPPUNIT_ASSERT_EQUAL(d, creator[1]);
	}

	void testCreatorSimplifyBug() {
		LitVec clause;
		clause.push_back(lit_false());
		clause.push_back(a);
		clause.push_back(b);
		ClauseCreator::prepare(*ctx.master(), clause, ClauseCreator::clause_force_simplify);
		CPPUNIT_ASSERT(clause.size() == 2);
	}

	void testCreateNonAssertingLearntClause() {
		ctx.endInit();
		solver().assume(a); solver().propagate();
		solver().assume(b); solver().propagate();
		creator.start(Constraint_t::Loop);
		creator.add(~a).add(~b).add(c).add(d);
		CPPUNIT_ASSERT(creator.end());
		CPPUNIT_ASSERT_EQUAL(c, creator[0]);
		CPPUNIT_ASSERT_EQUAL(d, creator[1]);
		CPPUNIT_ASSERT(solver().numLearntConstraints() == 1);

		solver().undoUntil(0);
		// test with a short clause
		solver().assume(a); solver().propagate();
		creator.start(Constraint_t::Loop);
		creator.add(~a).add(b).add(c);
		CPPUNIT_ASSERT(creator.end());
		CPPUNIT_ASSERT_EQUAL(b, creator[0]);
		CPPUNIT_ASSERT_EQUAL(c, creator[1]);
		CPPUNIT_ASSERT(ctx.numLearntShort() == 1);
	}
	void testCreateLearntClauseConflict() {
		ctx.endInit();
		solver().assume(a); solver().force(b,0); solver().propagate();// level 1
		solver().assume(c); solver().propagate();                     // level 2
		solver().assume(d); solver().propagate();                     // level 3
		solver().assume(f); solver().propagate();                     // level 4

		creator.start(Constraint_t::Loop);
		creator.add(~c).add(~a).add(~d).add(~b); // 2 1 3 1
		CPPUNIT_ASSERT_EQUAL(false, (bool)creator.end());
		// make sure we watch highest levels, i.e. 3 and 2
		CPPUNIT_ASSERT_EQUAL(~d, creator[0]);
		CPPUNIT_ASSERT_EQUAL(~c, creator[1]);
		CPPUNIT_ASSERT(solver().numLearntConstraints() == 0);


		solver().undoUntil(0);
		// test with a short clause
		solver().assume(a); solver().propagate();// level 1
		solver().assume(c); solver().propagate();// level 2
		creator.start(Constraint_t::Loop);
		creator.add(~a).add(~c);
		CPPUNIT_ASSERT_EQUAL(false, (bool)creator.end());
		CPPUNIT_ASSERT_EQUAL(~c, creator[0]);
		CPPUNIT_ASSERT_EQUAL(~a, creator[1]);
		CPPUNIT_ASSERT(ctx.numBinary() == 0);
	}

	void testCreateNonAssertingLearntClauseAsserting() {
		ctx.endInit();
		solver().assume(a); solver().force(b,0); solver().propagate();// level 1
		solver().assume(c); solver().propagate();                     // level 2
		creator.start(Constraint_t::Loop);
		creator.add(~c).add(~a).add(d).add(~b);                       // 2 1 Free 1
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.end());
		// make sure we watch the right lits, i.e. d (free) and ~c (highest DL)
		CPPUNIT_ASSERT_EQUAL(d, creator[0]);
		CPPUNIT_ASSERT_EQUAL(~c, creator[1]);
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(d));
		CPPUNIT_ASSERT(solver().numLearntConstraints() == 1);
		// test with a short clause
		solver().undoUntil(0);
		solver().reduceLearnts(1.0f);
		solver().assume(a); solver().force(b,0); solver().propagate();// level 1
		solver().assume(c); solver().propagate();                     // level 2
		creator.start(Constraint_t::Loop);
		creator.add(~c).add(~a).add(d);                               // 2 1 Free
		CPPUNIT_ASSERT_EQUAL(true, (bool)creator.end());
		// make sure we watch the right lits, i.e. d (free) and ~c (highest DL)
		CPPUNIT_ASSERT_EQUAL(d, creator[0]);
		CPPUNIT_ASSERT_EQUAL(~c, creator[1]);
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(d));
	}

	void testCreateBogusUnit() {
		solver().assume(a) && solver().propagate();
		solver().assume(~b) && solver().propagate();
		solver().force(~d,0) && solver().propagate();
		solver().assume(~c) && solver().propagate();
		CPPUNIT_ASSERT(solver().decisionLevel() == 3);

		creator.start(Constraint_t::Other).add(d).add(b).add(c).add(a);
		CPPUNIT_ASSERT(ClauseCreator::status(solver(), &creator.lits()[0], &creator.lits()[0] + creator.size()) == ClauseCreator::status_sat);

		ClauseCreator::Result r = creator.end();
		CPPUNIT_ASSERT_EQUAL(true, r.ok());
		CPPUNIT_ASSERT(solver().decisionLevel() == 3);
	}

	void testInitWatches() {
		LitVec cl;
		cl.push_back(a);
		cl.push_back(b);
		cl.push_back(c);
		cl.push_back(d);
		solver().assume(~b)   && solver().propagate();
		solver().force(~c, 0) && solver().propagate();
		solver().assume(~a)   && solver().propagate();
		solver().assume(d)    && solver().propagate();
		// aF@2 bF@1 cF@1 dT@3 -> dT@3 aF@2 cF@1 bF@1
		LitVec temp = cl;
		ClauseCreator::prepare(solver(), temp, 0);
		CPPUNIT_ASSERT(temp[0] == d);
		CPPUNIT_ASSERT(temp[1] == a);

		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, ClauseCreator::clause_no_add);
		temp.clear();
		r.local->clause()->toLits(temp);
		CPPUNIT_ASSERT(temp[0] == d);
		CPPUNIT_ASSERT(temp[1] == a);
		r.local->destroy(&solver(), true);
	}

	void testIntegrateEmpty() {
		LitVec cl;
		solver().assume(~a) && solver().propagate();
		solver().pushRootLevel(solver().decisionLevel());
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT_EQUAL(false, r.ok());
		CPPUNIT_ASSERT_EQUAL(true, solver().hasConflict());
		CPPUNIT_ASSERT_EQUAL(false, solver().clearAssumptions());
	}
	void testIntegrateUnit() {
		solver().assume(a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(c) && solver().propagate();
		solver().assume(d) && solver().propagate();
		solver().pushRootLevel(solver().decisionLevel());
		solver().assume(e) && solver().propagate();

		LitVec cl;
		// ~a ~b ~c f -> Unit: f@3
		cl.push_back(~a); cl.push_back(f);
		cl.push_back(~c); cl.push_back(~b);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT(solver().isTrue(f));
		CPPUNIT_ASSERT(solver().decisionLevel() == solver().rootLevel());
		solver().popRootLevel();
		solver().backtrack() && solver().propagate();
		CPPUNIT_ASSERT(solver().isTrue(f));
		CPPUNIT_ASSERT(solver().decisionLevel() == solver().rootLevel());
		solver().popRootLevel();
		solver().backtrack() && solver().propagate();
		CPPUNIT_ASSERT_EQUAL(false, solver().isTrue(f));
		CPPUNIT_ASSERT(solver().value(c.var()) == value_free);
	}

	void testIntegrateUnitSAT() {
		solver().assume(a) && solver().propagate();
		LitVec cl;
		cl.push_back(a);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT(solver().isTrue(a));
		CPPUNIT_ASSERT(solver().decisionLevel() == 0);
	}

	void testIntegrateConflict() {
		solver().assume(a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(c) && solver().propagate();
		solver().force(d, 0) && solver().propagate();

		// ~a ~b ~c ~d -> conflicting@3
		LitVec cl;
		cl.push_back(~a); cl.push_back(~c); cl.push_back(~b); cl.push_back(~d);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT(!r.ok());
		CPPUNIT_ASSERT(r.local != 0);
		CPPUNIT_ASSERT(solver().hasConflict());
	}

	void testIntegrateAssertingConflict() {
		solver().assume(a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(c) && solver().propagate();
		solver().assume(d) && solver().propagate();

		// ~a ~b ~c -> Conflict @3
		LitVec cl;
		cl.push_back(~a); cl.push_back(~c); cl.push_back(~b);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT(solver().decisionLevel() == uint32(2));
	}

	void testIntegrateAssertingConflictBelowRoot() {
		solver().assume(a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(d) && solver().propagate();
		solver().pushRootLevel(solver().decisionLevel());
		solver().assume(c) && solver().propagate();
		// ~a ~b ~c -> Conflict @3, Asserting @2
		LitVec cl;
		cl.push_back(~a); cl.push_back(~c); cl.push_back(~b);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT(solver().decisionLevel() == uint32(3));
		solver().popRootLevel();
		solver().backtrack() && solver().propagate();
		CPPUNIT_ASSERT(solver().isTrue(~c));
	}
	void testIntegrateConflictBelowRoot() {
		LitVec cl;
		cl.push_back(a); cl.push_back(b); cl.push_back(c);
		solver().assume(~a) && solver().propagate();
		solver().assume(~b) && solver().propagate();
		solver().assume(~c) && solver().propagate();
		solver().assume(~d) && solver().propagate();
		solver().pushRootLevel(solver().decisionLevel());
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, ClauseCreator::clause_explicit);
		CPPUNIT_ASSERT_EQUAL(false, r.ok());
		CPPUNIT_ASSERT_EQUAL(uint32(1), solver().numLearntConstraints());
	}

	void testIntegrateSATBug1() {
		LitVec cl;
		cl.push_back(d); cl.push_back(b); cl.push_back(a); cl.push_back(c);
		solver().assume(~a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(~d) && solver().propagate();
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT_EQUAL(true, r.ok());
		CPPUNIT_ASSERT(3u == solver().numAssignedVars());
	}
	void testIntegrateSATBug2() {
		LitVec cl;
		cl.push_back(d); cl.push_back(b); cl.push_back(c); cl.push_back(a);
		solver().assume(~a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(~d) && solver().propagate();
		solver().force(c,0) && solver().propagate();
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT_EQUAL(true, r.ok());
	}

	void testIntegrateSATBug3() {
		LitVec cl;
		cl.push_back(d); cl.push_back(b); cl.push_back(c); cl.push_back(a);
		solver().assume(~a) && solver().propagate();
		solver().assume(~b) && solver().propagate();
		solver().force(~d,0) && solver().propagate();
		solver().assume(c) && solver().propagate();
		CPPUNIT_ASSERT(solver().decisionLevel() == 3);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, ClauseCreator::clause_not_sat);

		CPPUNIT_ASSERT_EQUAL(true, r.ok());
		CPPUNIT_ASSERT(solver().decisionLevel() == 2);
		CPPUNIT_ASSERT(solver().isTrue(c));
	}

	void testIntegrateSATBug4() {
		LitVec cl;
		cl.push_back(a); cl.push_back(b);
		solver().force(~a, 0);
		solver().assume(b);
		SharedLiterals* p(SharedLiterals::newShareable(cl,Constraint_t::Other));
		CPPUNIT_ASSERT((ClauseCreator::status(solver(), p->begin(), p->end()) & ClauseCreator::status_unit) != 0);
		ClauseCreator::integrate(solver(), p, ClauseCreator::clause_explicit);
	}

	void testIntegrateKnownOrderBug() {
		LitVec cl;
		cl.push_back(a);
		SharedLiterals* p(SharedLiterals::newShareable(cl,Constraint_t::Other));
		CPPUNIT_ASSERT((ClauseCreator::status(solver(), p->begin(), p->end()) & ClauseCreator::status_unit) != 0);
		ClauseCreator::integrate(solver(), p, ClauseCreator::clause_no_prepare);
		CPPUNIT_ASSERT(solver().isTrue(a));
	}

	void testIntegrateNotConflictingBug() {
		LitVec cl;
		cl.push_back(a); cl.push_back(b);
		SharedLiterals* p(SharedLiterals::newShareable(cl,Constraint_t::Other));
		solver().assume(~a) && solver().propagate();
		solver().force(~b,0)&& solver().propagate();
		CPPUNIT_ASSERT((ClauseCreator::status(solver(), p->begin(), p->end()) & ClauseCreator::status_unsat) != 0);
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, ClauseCreator::clause_not_conflict);
		CPPUNIT_ASSERT(r.ok() == false);
		CPPUNIT_ASSERT(r.local == 0);
	}
	void testIntegrateSimplify() {
		LitVec cl;
		cl.push_back(a); cl.push_back(b); cl.push_back(c);
		cl.push_back(d); cl.push_back(e); cl.push_back(f);
		SharedLiterals* p(SharedLiterals::newShareable(cl,Constraint_t::Other));
		solver().force(~d, 0) && solver().propagate();
		solver().assume(~a)   && solver().propagate();
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, ClauseCreator::clause_no_add);
		CPPUNIT_ASSERT(r.ok());
		CPPUNIT_ASSERT(r.local != 0);
		cl.clear();
		r.local->toLits(cl);
		CPPUNIT_ASSERT(cl.size() == 5 && std::find(cl.begin(), cl.end(), d) == cl.end());
	}
	void testIntegrateSAT() {
		LitVec cl;
		cl.push_back(a); cl.push_back(b); cl.push_back(c); cl.push_back(d);
		solver().assume(~a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(~d) && solver().propagate();
		do {
			SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
			ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, ClauseCreator::clause_not_sat);
			CPPUNIT_ASSERT_EQUAL(true, r.ok());
			CPPUNIT_ASSERT(solver().numAssignedVars() == 3);
		} while (std::next_permutation(cl.begin(), cl.end()));
		CPPUNIT_ASSERT(solver().numLearntConstraints() == 0);
	}

	void testIntegrateUnsat() {
		solver().force(~a,0) && solver().propagate();
		solver().assume(b);
		LitVec cl;
		cl.push_back(a);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT_EQUAL(false, r.ok());
		CPPUNIT_ASSERT(0 == r.local);
		CPPUNIT_ASSERT_EQUAL(uint32(0), solver().decisionLevel());
	}

	void testIntegrateAssertingBelowBT() {
		solver().assume(a) && solver().propagate();
		solver().assume(b) && solver().propagate();
		solver().assume(c) && solver().propagate();
		solver().assume(d) && solver().propagate();
		solver().setBacktrackLevel(solver().decisionLevel());
		// ~a ~b ~c -> Conflict @3, Asserting @2
		LitVec cl;
		cl.push_back(~a); cl.push_back(~c); cl.push_back(~b);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT_EQUAL(false, r.ok());
		solver().backtrack();
		CPPUNIT_ASSERT(solver().isTrue(~c));
		CPPUNIT_ASSERT_EQUAL(uint32(2), solver().decisionLevel());
		solver().backtrack();
		CPPUNIT_ASSERT(!solver().isTrue(~c));
	}

	void testIntegrateConflictBelowBT() {
		solver().assume(a) && solver().propagate();
		solver().assume(b) && solver().force(c, 0) && solver().propagate();
		solver().assume(d) && solver().propagate();
		solver().assume(e) && solver().propagate();
		solver().setBacktrackLevel(solver().decisionLevel());
		// ~a ~b ~c -> Conflict @2
		LitVec cl;
		cl.push_back(~a); cl.push_back(~c); cl.push_back(~b);
		SharedLiterals* p(SharedLiterals::newShareable(cl, Constraint_t::Other));
		ClauseCreator::Result r = ClauseCreator::integrate(solver(), p, 0);
		CPPUNIT_ASSERT_EQUAL(false, r.ok());
		CPPUNIT_ASSERT_EQUAL(true, solver().resolveConflict());
		CPPUNIT_ASSERT_EQUAL(uint32(1), solver().decisionLevel());
	}


	void testFactsAreRemovedFromLearnt() {
		ctx.enableStats(1);
		ctx.addUnary(a);
		ctx.endInit();
		solver().assume(~b) && solver().propagate();
		creator.start(Constraint_t::Conflict);
		creator.add(b).add(c).add(~a).end();

		CPPUNIT_ASSERT(1u == ctx.numLearntShort());
		CPPUNIT_ASSERT(ctx.master()->stats.extra->lits[0] == 2);
	}
private:
	const Solver& solver() const { return *ctx.master(); }
	Solver&       solver()       { return *ctx.master(); }
	SharedContext ctx;
	ClauseCreator creator;
	Literal a,b,c,d,e,f;
};
CPPUNIT_TEST_SUITE_REGISTRATION(ClauseCreatorTest);
} }
clasp-3.2.2/libclasp/tests/clause_test.cpp000066400000000000000000000777411304134206100206040ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 
#include 
#include 

#ifdef _MSC_VER
#pragma warning (disable : 4267) //  conversion from 'size_t' to unsigned int
#pragma once
#endif

namespace Clasp { namespace Test {

class ClauseTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(ClauseTest);
	CPPUNIT_TEST(testClauseCtorAddsWatches);
	CPPUNIT_TEST(testClauseTypes);
	CPPUNIT_TEST(testClauseActivity);

	CPPUNIT_TEST(testPropGenericClause);
	CPPUNIT_TEST(testPropGenericClauseConflict);
	CPPUNIT_TEST(testPropAlreadySatisfied);
	CPPUNIT_TEST(testPropRandomClauses);

	CPPUNIT_TEST(testReasonBumpsActivityIfLearnt);

	CPPUNIT_TEST(testSimplifySAT);

	CPPUNIT_TEST(testSimplifyUnitButNotLocked);
	CPPUNIT_TEST(testSimplifyRemovesFalseLitsBeg);
	CPPUNIT_TEST(testSimplifyRemovesFalseLitsMid);
	CPPUNIT_TEST(testSimplifyRemovesFalseLitsEnd);
	CPPUNIT_TEST(testSimplifyShortRemovesFalseLitsBeg);
	CPPUNIT_TEST(testSimplifyShortRemovesFalseLitsMid);
	CPPUNIT_TEST(testSimplifyShortRemovesFalseLitsEnd);

	CPPUNIT_TEST(testStrengthen);
	CPPUNIT_TEST(testStrengthenToUnary);
	CPPUNIT_TEST(testStrengthenContracted);
	CPPUNIT_TEST(testStrengthenBug);
	CPPUNIT_TEST(testStrengthenContractedNoExtend);
	CPPUNIT_TEST(testStrengthenLocked);
	CPPUNIT_TEST(testStrengthenLockedEarly);
	CPPUNIT_TEST(testSimplifyTagged);

	CPPUNIT_TEST(testClauseSatisfied);
	CPPUNIT_TEST(testContraction);
	CPPUNIT_TEST(testNewContractedClause);

	CPPUNIT_TEST(testClone);

	CPPUNIT_TEST(testBug);

	CPPUNIT_TEST(testLoopFormulaInitialWatches);
	CPPUNIT_TEST(testSimplifyLFIfOneBodyTrue);
	CPPUNIT_TEST(testSimplifyLFIfAllAtomsFalse);
	CPPUNIT_TEST(testSimplifyLFRemovesFalseBodies);
	CPPUNIT_TEST(testSimplifyLFRemovesFalseAtoms);
	CPPUNIT_TEST(testSimplifyLFRemovesTrueAtoms);

	CPPUNIT_TEST(testLoopFormulaPropagateBody);
	CPPUNIT_TEST(testLoopFormulaPropagateBody2);
	CPPUNIT_TEST(testLoopFormulaPropagateAtoms);
	CPPUNIT_TEST(testLoopFormulaPropagateAtoms2);
	CPPUNIT_TEST(testLoopFormulaBodyConflict);
	CPPUNIT_TEST(testLoopFormulaAtomConflict);
	CPPUNIT_TEST(testLoopFormulaDontChangeSat);
	CPPUNIT_TEST(testLoopFormulaPropTrueAtomInSatClause);

	CPPUNIT_TEST(testLoopFormulaSatisfied);

	CPPUNIT_TEST(testLoopFormulaBugEq);

	CPPUNIT_TEST_SUITE_END();
public:
	typedef ConstraintInfo ClauseInfo;
	ClauseTest() {
		a1 = posLit(ctx.addVar(Var_t::Atom));
		a2 = posLit(ctx.addVar(Var_t::Atom));
		a3 = posLit(ctx.addVar(Var_t::Atom));
		b1 = posLit(ctx.addVar(Var_t::Body));
		b2 = posLit(ctx.addVar(Var_t::Body));
		b3 = posLit(ctx.addVar(Var_t::Body));

		for (int i = 6; i < 15; ++i) {
			ctx.addVar(Var_t::Atom);
		}
		ctx.startAddConstraints(10);
		solver = ctx.master();
	}
	void testClauseCtorAddsWatches() {
		ClauseHead* cl1;
		solver->add(cl1 = createClause(2,2));
		CPPUNIT_ASSERT_EQUAL(2, countWatches(*solver, cl1, clLits) );
		ClauseHead* cl2 = createClause(clLits, Constraint_t::Conflict);
		solver->add(cl2);
		CPPUNIT_ASSERT_EQUAL(2,  countWatches(*solver, cl2, clLits));
	}

	void testClauseTypes() {
		Clause* cl1 = createClause(2, 2);
		Constraint* cl2 = createClause(clLits, ClauseInfo(Constraint_t::Conflict));
		Constraint* cl3 = createClause(clLits, ClauseInfo(Constraint_t::Loop));
		CPPUNIT_ASSERT_EQUAL(Constraint_t::Static, cl1->type());
		CPPUNIT_ASSERT_EQUAL(Constraint_t::Conflict, cl2->type());
		CPPUNIT_ASSERT_EQUAL(Constraint_t::Loop, cl3->type());
		cl1->destroy();
		cl2->destroy();
		cl3->destroy();
	}

	void testClauseActivity() {
		LitVec lit;
		lit.push_back(posLit(1));
		lit.push_back(posLit(2));
		lit.push_back(posLit(3));
		lit.push_back(posLit(4));
		uint32 exp = 258;
		ClauseHead* cl1 = createClause(lit, ClauseInfo(Constraint_t::Conflict).setActivity(exp));
		ClauseHead* cl2 = createClause(lit, ClauseInfo(Constraint_t::Loop).setActivity(exp));
		solver->add(cl1);
		solver->add(cl2);
		while ( exp != 0 ) {
			CPPUNIT_ASSERT(cl1->activity().activity() == cl2->activity().activity() && cl1->activity().activity() == exp);
			exp >>= 1;
			cl1->decreaseActivity();
			cl2->decreaseActivity();
		}
		CPPUNIT_ASSERT(cl1->activity().activity() == cl2->activity().activity() && cl1->activity().activity() == exp);
	}

	void testPropGenericClause() {
		Clause* c;
		solver->add(c = createClause(2, 2));
		solver->assume(~clLits[0]);
		solver->propagate();
		solver->assume( ~clLits.back() );
		solver->propagate();

		solver->assume(~clLits[1]);
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(true, solver->isTrue( clLits[2] ) );
		CPPUNIT_ASSERT_EQUAL(true, c->locked(*solver));
		Antecedent reason = solver->reason(clLits[2]);
		CPPUNIT_ASSERT(reason == c);

		LitVec r;
		reason.reason(*solver, clLits[2], r);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[0]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[1]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[3]) != r.end());
	}

	void testPropGenericClauseConflict() {
		Clause* c;
		solver->add(c = createClause(2, 2));
		solver->assume( ~clLits[0] );
		solver->force( ~clLits[1], 0 );
		solver->force( ~clLits[2], 0 );
		solver->force( ~clLits[3], 0 );

		CPPUNIT_ASSERT_EQUAL(false, solver->propagate());
		const LitVec& r = solver->conflict();
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[0]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[1]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[2]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[3]) != r.end());
	}

	void testPropAlreadySatisfied() {
		Clause* c;
		solver->add(c = createClause(2, 2));

		// satisfy the clause...
		solver->force(clLits[2], 0);
		solver->propagate();

		// ...make all but one literal false
		solver->force(~clLits[0], 0);
		solver->force(~clLits[1], 0);
		solver->propagate();

		// ...and assert that the last literal is still unassigned
		CPPUNIT_ASSERT(value_free == solver->value(clLits[3].var()));
	}
	void testPropRandomClauses() {
		for (int i = 0; i != 100; ++i) {
			SharedContext cc;
			solver = cc.master();
			for (int j = 0; j < 12; ++j) { cc.addVar(Var_t::Atom); }
			cc.startAddConstraints(1);
			Clause* c;
			solver->add( c = createRandomClause( (rand() % 10) + 2 ) );
			check(*c);
		}
	}

	void testReasonBumpsActivityIfLearnt() {
		clLits.push_back(posLit(1));
		clLits.push_back(posLit(2));
		clLits.push_back(posLit(3));
		clLits.push_back(posLit(4));
		ctx.endInit();
		ClauseHead* cl1 = createClause(clLits, ClauseInfo(Constraint_t::Conflict));
		solver->addLearnt(cl1, (uint32)clLits.size());
		solver->assume(~clLits[0]);
		solver->propagate();
		solver->assume(~clLits[1]);
		solver->propagate();
		solver->assume(~clLits[2]);
		uint32 a = cl1->activity().activity();
		solver->force(~clLits[3], Antecedent(0));
		CPPUNIT_ASSERT_EQUAL(false, solver->propagate());
		CPPUNIT_ASSERT_EQUAL(a+1, cl1->activity().activity());
	}

	void testSimplifySAT() {
		Clause* c;
		solver->add(c = createClause(3, 2));
		solver->force( ~clLits[1], 0);
		solver->force( clLits[2], 0 );
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(true, c->simplify(*solver, false));
	}
	void testSimplifyUnitButNotLocked() {
		Clause* c;
		solver->add(c = createClause(2, 2));
		solver->force( clLits[0], 0);  // SAT clause
		solver->force( ~clLits[1], 0 );
		solver->force( ~clLits[2], 0 );
		solver->force( ~clLits[3], 0 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(true, c->simplify(*solver, false));
	}

	void testSimplifyRemovesFalseLitsBeg() {
		Clause* c;

		solver->add(c = createClause(3, 3));
		CPPUNIT_ASSERT(6 == c->size());

		solver->force(~clLits[0], 0);
		solver->force(~clLits[1], 0);
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(false, c->simplify(*solver));
		CPPUNIT_ASSERT(4 == c->size());

		CPPUNIT_ASSERT_EQUAL(2, countWatches(*solver, c, clLits));
	}

	void testSimplifyRemovesFalseLitsMid() {
		Clause* c;

		solver->add(c = createClause(3, 3));
		CPPUNIT_ASSERT(6 == c->size());

		solver->force(~clLits[1], 0);
		solver->force(~clLits[2], 0);
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(false, c->simplify(*solver));
		CPPUNIT_ASSERT(4 == c->size());

		CPPUNIT_ASSERT_EQUAL(2, countWatches(*solver, c, clLits));
	}

	void testSimplifyShortRemovesFalseLitsBeg() {
		ClauseHead* c = createClause(2, 3);
		solver->add(c);

		solver->force(~clLits[0], 0);
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(false, c->simplify(*solver));
		CPPUNIT_ASSERT(4 == c->size());

		CPPUNIT_ASSERT_EQUAL(2, countWatches(*solver, c, clLits));
	}

	void testSimplifyShortRemovesFalseLitsMid() {
		ClauseHead* c = createClause(2, 3);
		solver->add(c);

		solver->force(~clLits[2], 0);
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(false, c->simplify(*solver));
		CPPUNIT_ASSERT(4 == c->size());

		CPPUNIT_ASSERT_EQUAL(2, countWatches(*solver, c, clLits));
	}

	void testSimplifyShortRemovesFalseLitsEnd() {
		ClauseHead* c = createClause(2, 3);
		solver->add(c);

		solver->force(~clLits[4], 0);
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(false, c->simplify(*solver));
		CPPUNIT_ASSERT(4 == c->size());

		CPPUNIT_ASSERT_EQUAL(2, countWatches(*solver, c, clLits));
	}

	void testStrengthen() {
		ClauseHead* c;
		clLits.push_back(a1);
		clLits.push_back(a2);
		clLits.push_back(a3);
		clLits.push_back(b1);
		clLits.push_back(b2);
		clLits.push_back(b3);
		c = createClause(clLits, ClauseInfo());
		CPPUNIT_ASSERT_EQUAL(false, c->strengthen(*solver, b2).second);
		CPPUNIT_ASSERT(c->size() == 5);
		CPPUNIT_ASSERT_EQUAL(false, c->strengthen(*solver, a3).second);
		CPPUNIT_ASSERT(c->size() == 4);

		CPPUNIT_ASSERT_EQUAL(true, c->strengthen(*solver, a1).second);
		CPPUNIT_ASSERT(c->size() == 3);
		c->destroy(solver, true);
	}

	void testStrengthenToUnary() {
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal x = posLit(ctx.addVar( Var_t::Atom ));
		Literal y = posLit(ctx.addVar( Var_t::Atom ));
		ctx.startAddConstraints();
		ctx.endInit();
		Literal a = posLit(solver->pushTagVar(true));
		solver->assume(x) && solver->propagate();
		solver->assume(y) && solver->propagate();
		solver->setBacktrackLevel(solver->decisionLevel());
		clLits.clear();
		clLits.push_back(b);
		clLits.push_back(~a);
		ClauseInfo extra(Constraint_t::Conflict); extra.setTagged(true);
		ClauseHead* c = ClauseCreator::create(*solver, clLits, 0, extra).local;
		CPPUNIT_ASSERT(c->size() == 2);
		CPPUNIT_ASSERT(solver->isTrue(b) && solver->reason(b).constraint() == c);
		solver->backtrack() && solver->propagate();
		CPPUNIT_ASSERT(solver->isTrue(b) && solver->reason(b).constraint() == c);
		c->strengthen(*solver, ~a);
		solver->backtrack();
		CPPUNIT_ASSERT(solver->isTrue(b));
		LitVec out;
		solver->reason(b, out);
		CPPUNIT_ASSERT(out.size() == 1 && out[0] == lit_true());
		solver->clearAssumptions();
		CPPUNIT_ASSERT(solver->isTrue(b));
	}

	void testStrengthenContracted() {
		ctx.endInit();
		LitVec lits;
		lits.push_back(a1);
		for (uint32 i = 2; i <= 12; ++i) {
			solver->assume(negLit(i));
			lits.push_back(posLit(i));
		}
		solver->strategies().compress = 4;
		ClauseHead* c = ClauseCreator::create(*solver, lits, 0, Constraint_t::Conflict).local;
		uint32 si = c->size();
		c->strengthen(*solver, posLit(12));
		solver->undoUntil(solver->decisionLevel()-1);
		CPPUNIT_ASSERT(solver->value(posLit(12).var()) == value_free && si == c->size());
		solver->undoUntil(solver->level(posLit(9).var())-1);

		CPPUNIT_ASSERT(si+1 <= c->size());
		si = c->size();

		c->strengthen(*solver, posLit(2));
		c->strengthen(*solver, posLit(6));
		CPPUNIT_ASSERT(si == c->size());
		c->strengthen(*solver, posLit(9));

		c->strengthen(*solver, posLit(8));
		c->strengthen(*solver, posLit(5));
		c->strengthen(*solver, posLit(4));
		c->strengthen(*solver, posLit(3));

		CPPUNIT_ASSERT_EQUAL(false, c->strengthen(*solver, posLit(7), false).second);
		CPPUNIT_ASSERT_EQUAL(uint32(3), c->size());
		CPPUNIT_ASSERT_EQUAL(true, c->strengthen(*solver, posLit(11)).second);
		CPPUNIT_ASSERT_EQUAL(uint32(sizeof(Clause) + (9*sizeof(Literal))), ((Clause*)c)->computeAllocSize());
	}

	void testStrengthenBug() {
		ctx.endInit();
		LitVec clause;
		clause.push_back(a1);
		for (uint32 i = 2; i <= 6; ++i) {
			solver->assume(negLit(8-i)) && solver->propagate();
			clause.push_back(posLit(i));
		}
		ClauseHead* c = Clause::newContractedClause(*solver, ClauseRep::create(&clause[0], (uint32)clause.size(), ClauseInfo(Constraint_t::Conflict)) , 5, true);
		solver->addLearnt(c, 5);
		uint32 si = c->size();
		CPPUNIT_ASSERT(si == 5);
		c->strengthen(*solver, posLit(4));
		LitVec clause2;
		c->toLits(clause2);
		CPPUNIT_ASSERT(clause2.size() == 5);
		for (uint32 i = 0; i != clause.size(); ++i) {
			CPPUNIT_ASSERT(std::find(clause2.begin(), clause2.end(), clause[i]) != clause2.end() || clause[i] == posLit(4));
		}
	}

	void testStrengthenContractedNoExtend() {
		ctx.endInit();
		LitVec clause;
		clause.push_back(a1);
		for (uint32 i = 2; i <= 6; ++i) {
			solver->assume(negLit(8-i)) && solver->propagate();
			clause.push_back(posLit(i));
		}
		ClauseRep   x = ClauseRep::create(&clause[0], (uint32)clause.size(), ClauseInfo(Constraint_t::Conflict));
		ClauseHead* c = Clause::newContractedClause(*solver, x, 4, false);
		solver->addLearnt(c, 4);
		CPPUNIT_ASSERT(c->size() == 4);
		c->strengthen(*solver, posLit(2));
		CPPUNIT_ASSERT(c->size() == 4);
		solver->undoUntil(0);
		CPPUNIT_ASSERT(c->size() == 4);
	}

	void testStrengthenLocked() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		ctx.startAddConstraints();
		ctx.endInit();
		Literal tag = posLit(solver->pushTagVar(true));
		solver->assume(posLit(a)) && solver->propagate();
		solver->assume(posLit(b)) && solver->propagate();
		ClauseCreator cc(solver);
		cc.start(Constraint_t::Conflict).add(negLit(a)).add(negLit(b)).add(negLit(c)).add(~tag);
		ClauseHead* clause = cc.end().local;
		CPPUNIT_ASSERT(clause->locked(*solver));
		CPPUNIT_ASSERT(!clause->strengthen(*solver, ~tag).second);
		CPPUNIT_ASSERT(clause->locked(*solver));
		LitVec r;
		solver->reason(negLit(c), r);
		CPPUNIT_ASSERT(r.size() == 2);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), posLit(a)) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), posLit(b)) != r.end());
	}

	void testStrengthenLockedEarly() {
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		Literal x = posLit(ctx.addVar( Var_t::Atom ));
		ctx.startAddConstraints();
		ctx.endInit();
		Literal a = posLit(solver->pushTagVar(true));
		solver->assume(b) && solver->propagate();
		solver->force(c, 0) && solver->propagate();
		solver->assume(x) && solver->propagate();
		solver->setBacktrackLevel(solver->decisionLevel());

		ClauseCreator cc(solver);
		cc.start(Constraint_t::Conflict).add(~a).add(~b).add(~c).add(d);
		ClauseHead* clause = cc.end().local;
		CPPUNIT_ASSERT(clause->locked(*solver));
		bool remove = clause->strengthen(*solver, ~a).second;
		solver->backtrack();
		CPPUNIT_ASSERT(solver->isTrue(d));
		CPPUNIT_ASSERT(!remove || solver->reason(d).type() != Antecedent::Generic || solver->reason(d).constraint() != clause);
	}

	void testSimplifyTagged() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		ctx.startAddConstraints();
		ctx.endInit();
		Literal tag = posLit(solver->pushTagVar(true));
		ClauseCreator cc(solver);
		// ~a ~b ~c ~tag
		cc.start(Constraint_t::Conflict).add(negLit(a)).add(negLit(b)).add(negLit(c)).add(~tag);
		ClauseHead* clause = cc.end().local;

		solver->force(posLit(c));
		CPPUNIT_ASSERT_EQUAL(false, clause->strengthen(*solver, negLit(c)).second);
	}

	void testSimplifyRemovesFalseLitsEnd() {
		Clause* c;
		solver->add(c = createClause(3, 3));
		CPPUNIT_ASSERT(6 == c->size());

		solver->force(~clLits[4], 0);
		solver->force(~clLits[5], 0);
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(false, c->simplify(*solver));
		CPPUNIT_ASSERT(4 == c->size());

		CPPUNIT_ASSERT_EQUAL(2, countWatches(*solver, c, clLits));
	}

	void testClauseSatisfied() {
		ConstraintType t = Constraint_t::Conflict;
		TypeSet ts; ts.addSet(t);
		Clause* c;
		solver->addLearnt(c = createClause(2, 2, t), 4);
		LitVec free;
		CPPUNIT_ASSERT_EQUAL(uint32(t), c->isOpen(*solver, ts, free));
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(4), free.size());

		solver->assume( clLits[2] );
		solver->propagate();
		free.clear();
		CPPUNIT_ASSERT_EQUAL(uint32(0), c->isOpen(*solver, ts, free));
		solver->undoUntil(0);
		solver->assume( ~clLits[1] );
		solver->assume( ~clLits[2] );
		solver->propagate();
		free.clear();
		CPPUNIT_ASSERT_EQUAL(uint32(t), c->isOpen(*solver, ts, free));
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(2), free.size());
		ts.m = 0; ts.addSet(Constraint_t::Loop);
		CPPUNIT_ASSERT_EQUAL(uint32(0), c->isOpen(*solver, ts, free));
	}

	void testContraction() {
		ctx.endInit();
		LitVec lits(1, a1);
		for (uint32 i = 2; i <= 12; ++i) {
			solver->assume(negLit(i));
			lits.push_back(posLit(i));
		}
		solver->strategies().compress = 6;
		ClauseHead* cl = ClauseCreator::create(*solver, lits, 0, Constraint_t::Conflict).local;
		uint32  s1 = cl->size();
		CPPUNIT_ASSERT(s1 < lits.size());
		LitVec r;
		solver->reason(a1, r);
		CPPUNIT_ASSERT( r.size() == lits.size()-1 );

		solver->undoUntil(0);
		CPPUNIT_ASSERT(cl->size() == lits.size());
	}

	void testNewContractedClause() {
		ctx.endInit();
		// head
		clLits.push_back(a1);
		clLits.push_back(a2);
		clLits.push_back(a3);
		for (uint32 i = 4; i <= 12; ++i) {
			solver->assume(negLit(i));
			// (false) tail
			clLits.push_back(posLit(i));
		}
		ClauseRep   x = ClauseRep::create(&clLits[0], (uint32)clLits.size(), ClauseInfo(Constraint_t::Conflict));
		ClauseHead* c = Clause::newContractedClause(*solver, x, 3, false);
		solver->addLearnt(c, static_cast(clLits.size()));
		CPPUNIT_ASSERT(c->size() < clLits.size());

		solver->assume(~a1) && solver->propagate();
		solver->assume(~a3) && solver->propagate();
		CPPUNIT_ASSERT(solver->isTrue(a2));
		LitVec r;
		solver->reason(a2, r);
		CPPUNIT_ASSERT(r.size() == clLits.size()-1);
	}
	void testBug() {
		Clause* c;
		solver->add(c = createClause(3, 3));
		solver->assume(~clLits[1]);
		solver->propagate();
		solver->assume(~clLits[2]);
		solver->propagate();
		solver->assume(~clLits[3]);
		solver->propagate();
		solver->assume(~clLits[0]);
		solver->propagate();
		uint32 exp = solver->numAssignedVars();
		solver->undoUntil(0);
		solver->assume(~clLits[1]);
		solver->propagate();
		solver->assume(~clLits[2]);
		solver->propagate();
		solver->assume(~clLits[3]);
		solver->propagate();
		solver->assume(~clLits[4]);
		solver->propagate();

		CPPUNIT_ASSERT(exp == solver->numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, solver->hasWatch(~clLits[0], c));
		CPPUNIT_ASSERT_EQUAL(true, solver->hasWatch(~clLits[5], c));
	}

	void testClone() {
		Solver& solver2 = ctx.pushSolver();
		ctx.endInit(true);
		ClauseHead* c      = createClause(3, 3);
		ClauseHead* clone  = (ClauseHead*)c->cloneAttach(solver2);
		LitVec lits;
		clone->toLits(lits);
		CPPUNIT_ASSERT(lits == clLits);
		CPPUNIT_ASSERT(countWatches(solver2, clone, lits) == 2);
		clone->destroy(&solver2, true);

		solver->force(~clLits[0], 0);
		solver->force(~clLits[2], 0);
		solver->propagate();
		c->simplify(*solver);
		clone = (ClauseHead*)c->cloneAttach(solver2);
		lits.clear();
		clone->toLits(lits);
		CPPUNIT_ASSERT(lits.size() == 4);
		CPPUNIT_ASSERT(countWatches(solver2, clone, lits) == 2);
		clone->destroy(&solver2, true);
		c->destroy(solver, true);

	}

	void testLoopFormulaInitialWatches() {
		LoopFormula* lf = lfTestInit();
		CPPUNIT_ASSERT_EQUAL(true, solver->hasWatch(a1, lf));
		CPPUNIT_ASSERT_EQUAL(true, solver->hasWatch(a2, lf));
		CPPUNIT_ASSERT_EQUAL(true, solver->hasWatch(a3, lf));
		CPPUNIT_ASSERT_EQUAL(true, solver->hasWatch(~b3, lf));
	}

	void testSimplifyLFIfOneBodyTrue() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->force( b2, 0 );
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL(true, lf->simplify(*solver));
		CPPUNIT_ASSERT_EQUAL(false, solver->hasWatch(a1, lf));
		CPPUNIT_ASSERT_EQUAL(false, solver->hasWatch(~b3, lf));
	}

	void testSimplifyLFIfAllAtomsFalse() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->force( ~a1, 0 );
		solver->force( ~a2, 0 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(false, lf->simplify(*solver));
		solver->assume(a3);
		solver->propagate();
		solver->backtrack();
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(true, lf->simplify(*solver));
		CPPUNIT_ASSERT_EQUAL(false, solver->hasWatch(~b3, lf));
		CPPUNIT_ASSERT_EQUAL(false, solver->hasWatch(a1, lf));
		CPPUNIT_ASSERT_EQUAL(false, solver->hasWatch(a2, lf));
		CPPUNIT_ASSERT_EQUAL(false, solver->hasWatch(a3, lf));
		solver->reduceLearnts(1.0f);
	}

	void testSimplifyLFRemovesFalseBodies() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);

		solver->force( ~b1, 0 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(true, lf->simplify(*solver));
		CPPUNIT_ASSERT(3u == solver->sharedContext()->numLearntShort());
	}

	void testSimplifyLFRemovesFalseAtoms() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->force( ~a1,0 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(false, lf->simplify(*solver));
		CPPUNIT_ASSERT(5 == lf->size());

		solver->force( ~a3,0 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(false, lf->simplify(*solver));
		CPPUNIT_ASSERT(4 == lf->size());

		solver->force( ~a2,0 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(true, lf->simplify(*solver));
	}

	void testSimplifyLFRemovesTrueAtoms() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->force( a1,0 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(true, lf->simplify(*solver));

		CPPUNIT_ASSERT(1u == solver->sharedContext()->numLearntShort());
	}

	void testLoopFormulaPropagateBody() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->assume( ~b1 );
		solver->propagate();
		solver->assume( ~b3 );
		solver->propagate();
		solver->assume( a3 );
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(b2) );
		CPPUNIT_ASSERT_EQUAL( Antecedent::Generic, solver->reason(b2).type() );
		LitVec r;
		solver->reason(b2, r);
		CPPUNIT_ASSERT_EQUAL( LitVec::size_type(3), r.size() );
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), a3) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b3) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b1) != r.end());

		CPPUNIT_ASSERT_EQUAL(true, lf->locked(*solver));
	}

	void testLoopFormulaPropagateBody2() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->assume( a1 );
		solver->propagate();
		solver->undoUntil(0);

		solver->assume( ~b1 );
		solver->propagate();
		solver->assume( a2 );
		solver->propagate();
		solver->assume( ~b2 );
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(b3) );

		CPPUNIT_ASSERT_EQUAL( Antecedent::Generic, solver->reason(b3).type() );
		LitVec r;
		solver->reason(b3, r);
		CPPUNIT_ASSERT_EQUAL( LitVec::size_type(3), r.size() );
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b1) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b2) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), a2) != r.end());

		CPPUNIT_ASSERT_EQUAL(true, lf->locked(*solver));
	}

	void testLoopFormulaPropagateAtoms() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->assume( ~b3 );
		solver->propagate();
		solver->assume( ~b1 );
		solver->propagate();

		solver->assume( ~a1 );
		solver->propagate();

		solver->assume( ~b2 );
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(~a1) );
		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(~a2) );
		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(~a3) );

		CPPUNIT_ASSERT_EQUAL( Antecedent::Generic, solver->reason(~a2).type() );
		LitVec r;
		solver->reason(~a2, r);
		CPPUNIT_ASSERT_EQUAL( LitVec::size_type(3), r.size() );
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b1) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b2) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b3) != r.end());

		CPPUNIT_ASSERT_EQUAL(true, lf->locked(*solver));
	}

	void testLoopFormulaPropagateAtoms2() {
		LoopFormula* lf = lfTestInit();
		solver->undoUntil(0);
		solver->assume( a1 );
		solver->force( a2, 0 );
		solver->propagate();
		solver->undoUntil(0);

		solver->assume( ~b3 );
		solver->propagate();
		solver->assume( ~b1 );
		solver->propagate();
		solver->assume( ~b2 );
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(~a1) );
		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(~a2) );
		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(~a3) );


		CPPUNIT_ASSERT_EQUAL( Antecedent::Generic, solver->reason(~a1).type() );
		LitVec r;
		solver->reason(~a1, r);
		CPPUNIT_ASSERT_EQUAL( LitVec::size_type(3), r.size() );
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b1) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b2) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b3) != r.end());

		CPPUNIT_ASSERT_EQUAL(true, lf->locked(*solver));
	}

	void testLoopFormulaBodyConflict() {
		lfTestInit();
		solver->undoUntil(0);

		solver->assume( ~b3 );
		solver->propagate();
		solver->assume( ~b2 );
		solver->propagate();
		solver->force(a3, 0);
		solver->force(~b1, 0);

		CPPUNIT_ASSERT_EQUAL( false, solver->propagate() );
		const LitVec& r = solver->conflict();

		CPPUNIT_ASSERT_EQUAL( LitVec::size_type(4), r.size() );
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), a3) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b3) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b1) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b2) != r.end());
	}
	void testLoopFormulaAtomConflict() {
		lfTestInit();
		solver->undoUntil(0);
		solver->assume( ~b3 );
		solver->propagate();
		solver->assume(~b1);
		solver->propagate();
		solver->force(~b2, 0);
		solver->force(a2, 0);
		CPPUNIT_ASSERT_EQUAL( false, solver->propagate() );


		LitVec r = solver->conflict();

		CPPUNIT_ASSERT_EQUAL( LitVec::size_type(4), r.size() );
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), a2) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b3) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b1) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b2) != r.end());

		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(~a1));
		solver->reason(~a1, r);
		CPPUNIT_ASSERT_EQUAL( LitVec::size_type(3), r.size() );
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b3) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b1) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b2) != r.end());
	}

	void testLoopFormulaDontChangeSat() {
		lfTestInit();
		solver->undoUntil(0);
		CPPUNIT_ASSERT_EQUAL(true, solver->assume( ~b1 ) && solver->propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver->assume( ~b3 ) && solver->propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver->assume( a2 ) && solver->propagate());

		CPPUNIT_ASSERT_EQUAL(true, solver->isTrue( b2 ));
		LitVec rold;
		solver->reason(b2, rold);

		CPPUNIT_ASSERT_EQUAL(true, solver->assume( a1 ) && solver->propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver->isTrue( b2 ));
		LitVec rnew;
		solver->reason(b2, rnew);
		CPPUNIT_ASSERT(rold == rnew);
	}

	void testLoopFormulaSatisfied() {
		LoopFormula* lf = lfTestInit();
		ConstraintType t= Constraint_t::Loop;
		TypeSet ts, other; ts.addSet(t); other.addSet(Constraint_t::Conflict);
		LitVec free;
		CPPUNIT_ASSERT_EQUAL(uint32(0), lf->isOpen(*solver, ts, free));
		solver->undoUntil(0);
		free.clear();
		CPPUNIT_ASSERT_EQUAL(uint32(lf->type()), lf->isOpen(*solver, ts, free));
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(6), free.size());
		CPPUNIT_ASSERT_EQUAL(uint32(0), lf->isOpen(*solver, other, free));
		solver->assume( a1 );
		solver->assume( ~b2 );
		solver->propagate();
		free.clear();
		CPPUNIT_ASSERT_EQUAL(uint32(lf->type()), lf->isOpen(*solver, ts, free));
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(4), free.size());
		solver->assume( ~b1 );
		solver->propagate();
		CPPUNIT_ASSERT_EQUAL(uint32(0), lf->isOpen(*solver, ts, free));
	}

	void testLoopFormulaBugEq() {
		ctx.endInit();
		Literal body1 = b1;
		Literal body2 = b2;
		Literal body3 = ~b3; // assume body3 is equivalent to some literal ~xy
		solver->assume(~body1);
		solver->assume(~body2);
		solver->assume(~body3);
		solver->propagate();
		Literal lits[4] = { ~a1, body3, body2, body1 };

		LoopFormula* lf = LoopFormula::newLoopFormula(*solver, ClauseRep::prepared(lits, 4), lits, 1);
		solver->addLearnt(lf, lf->size());
		solver->force(~a1, lf);
		solver->propagate();
		solver->undoUntil(solver->decisionLevel()-2);
		CPPUNIT_ASSERT_EQUAL(true, solver->assume(~body3) && solver->propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver->assume(a1) && solver->propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver->isTrue(body2));
	}

	void testLoopFormulaPropTrueAtomInSatClause() {
		lfTestInit();
		solver->undoUntil(0);
		solver->assume( ~a1 );
		solver->propagate();

		solver->assume( a2 );
		solver->force( ~b3, 0 );
		solver->force( ~b2, 0 );
		solver->propagate();

		CPPUNIT_ASSERT_EQUAL( true, solver->isTrue(b1) );
	}
private:
	SharedContext ctx;
	Solver*       solver;
	int countWatches(const Solver& s, ClauseHead* c, const LitVec& lits) {
		int w     = 0;
		for (LitVec::size_type i = 0; i != lits.size(); ++i) {
			w += s.hasWatch(~lits[i], c);
		}
		return w;
	}
	void check(Clause& c) {
		std::string s = toString(clLits);
		std::random_shuffle(clLits.begin(), clLits.end());
		CPPUNIT_ASSERT( value_free == solver->value(clLits.back().var()) );
		for (LitVec::size_type i = 0; i != clLits.size() - 1; ++i) {
			CPPUNIT_ASSERT( value_free == solver->value(clLits[i].var()) );
			solver->force(~clLits[i], 0);
			solver->propagate();
		}
		CPPUNIT_ASSERT_EQUAL_MESSAGE(s.c_str(), true, solver->isTrue(clLits.back()));

		Antecedent reason = solver->reason(clLits.back());
		CPPUNIT_ASSERT(reason == &c);
		LitVec r;
		c.reason(*solver, clLits.back(), r);
		for (LitVec::size_type i = 0; i != clLits.size() - 1; ++i) {
			LitVec::iterator it = std::find(r.begin(), r.end(), ~clLits[i]);
			CPPUNIT_ASSERT_MESSAGE(s.c_str(), it != r.end());
			r.erase(it);
		}
		while (!r.empty() && isSentinel(r.back())) r.pop_back();
		CPPUNIT_ASSERT(r.empty());
	}
	std::string toString(const LitVec& c) {
		std::string res="[";
		for (uint32 i = 0; i != c.size(); ++i) {
			if (c[i].sign()) {
				res += '~';
			}
			res += ('a' + i);
			res += ' ';
		}
		res+="]";
		return res;
	}
	Clause* createClause(LitVec& lits, const ClauseInfo& info) {
		uint32 flags = ClauseCreator::clause_explicit | ClauseCreator::clause_no_add | ClauseCreator::clause_no_prepare;
		return (Clause*)ClauseCreator::create(*solver, lits, flags, info).local;
	}
	Clause* createClause(int pos, int neg, ConstraintType t = Constraint_t::Static) {
		clLits.clear();
		int size = pos + neg;
		LitVec lit(size);
		for (int i = 0; i < pos; ++i) {
			lit[i] = posLit(i+1);
			clLits.push_back(lit[i]);
		}
		for (int i = pos; i < pos + neg; ++i) {
			lit[i] = negLit(i+1);
			clLits.push_back(lit[i]);
		}
		return createClause(clLits, ClauseInfo(t));
	}

	Clause* createRandomClause(int size) {
		int pos = rand() % size + 1;
		return createClause( pos, size - pos );
	}

	LoopFormula* lfTestInit() {
		ctx.endInit();
		solver->assume(~b1);
		solver->assume(~b2);
		solver->assume(~b3);
		solver->propagate();
		Literal lits[] = { ~a1, b3, b2, b1, ~a1, ~a2, ~a3 };
		LoopFormula* lf = LoopFormula::newLoopFormula(*solver, ClauseRep::prepared(lits, 4), lits+4, 3);
		solver->addLearnt(lf, lf->size());
		solver->force(~a1, lf);
		solver->force(~a2, lf);
		solver->force(~a3, lf);
		solver->propagate();
		return lf;
	}
	Literal a1, a2, a3, b1, b2, b3;
	LitVec clLits;
};
CPPUNIT_TEST_SUITE_REGISTRATION(ClauseTest);
} }
clasp-3.2.2/libclasp/tests/cli_test.cpp000066400000000000000000000701561304134206100200700ustar00rootroot00000000000000//
// Copyright (c) 2014, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 
#include 
#include 
#include 
namespace Clasp { namespace Cli { namespace Test {

inline bool operator==(const ScheduleStrategy& lhs, const ScheduleStrategy& rhs) {
	return lhs.type == rhs.type && lhs.base == rhs.base && lhs.len == rhs.len && lhs.grow == rhs.grow;
}

class CliTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(CliTest);
	CPPUNIT_TEST(testConfigArgv);

	CPPUNIT_TEST(testConfigStrInterface);
	CPPUNIT_TEST(testConfigImplicitSolverMaster);
	CPPUNIT_TEST(testConfigImplicitCreateSolver);
	CPPUNIT_TEST(testConfigImplicitCreateTester);

	CPPUNIT_TEST(testConfigEnumerateKeys);
	CPPUNIT_TEST(testConfigQueryKeys);
	CPPUNIT_TEST(testConfigQueryArrKey);

	CPPUNIT_TEST(testConfigInit);
	CPPUNIT_TEST(testConfigInitFromFile);
	CPPUNIT_TEST(testConfigInitInvalidOptionInFile);

	CPPUNIT_TEST(testSetLookahead);
	CPPUNIT_TEST(testSetHeuristic);
	CPPUNIT_TEST(testSetStrengthen);
	CPPUNIT_TEST(testSetContraction);
	CPPUNIT_TEST(testSetLoops);
	CPPUNIT_TEST(testSetDeletion);
	CPPUNIT_TEST(testSetShareMode);
	CPPUNIT_TEST(testSetTrMode);
	CPPUNIT_TEST(testSetEnumMode);
	CPPUNIT_TEST(testSetOptStrategy);
	CPPUNIT_TEST(testSetSolveLimit);
#if WITH_THREADS
	CPPUNIT_TEST(testSetParallelMode);
	CPPUNIT_TEST(testSetDistribute);
	CPPUNIT_TEST(testSetIntegrate);
#endif
	CPPUNIT_TEST(testConfigQueryStrValues);
	CPPUNIT_TEST(testSetOptBound);
	CPPUNIT_TEST_SUITE_END();
public:
	void testConfigArgv() {
		ClaspCliConfig config;
		CPPUNIT_ASSERT(config.numSolver() == 1);
		CPPUNIT_ASSERT(config.solve.numSolver() == 1);
		CPPUNIT_ASSERT(config.solve.numModels != 0);
		uint32 nSolver = 1;
#if WITH_THREADS
		const char* argv[] = {"-n0", "--parallel-mode", "4", "--save-progress=20", "--stats", "--tester=--config=frumpy"};
		nSolver = 4;
#else
		const char* argv[] = {"-n0", "--save-progress=20", "--stats", "--tester=--config=frumpy"};
#endif
		config.setConfig(argv, argv + (sizeof(argv)/sizeof(const char*)), Problem_t::Asp);
		CPPUNIT_ASSERT(config.solve.numSolver() == nSolver);
		CPPUNIT_ASSERT(config.numSolver() == nSolver);
		CPPUNIT_ASSERT(config.solve.numModels == 0);
		for (uint32 i = 0; i != config.numSolver(); ++i) {
			CPPUNIT_ASSERT(config.solver(i).saveProgress == 20);
		}
		CPPUNIT_ASSERT(config.testerConfig() && config.testerConfig()->numSolver() == 1);
		CPPUNIT_ASSERT(config.getValue("tester.configuration") == "frumpy");
	}

	void testConfigStrInterface()  {
		ClaspCliConfig config;
		config.setValue("configuration", "auto,6");
		CPPUNIT_ASSERT(config.numSolver() == 6);
		CPPUNIT_ASSERT(config.setValue("asp.eq", "0") && config.asp.iters == 0);
		CPPUNIT_ASSERT(config.setValue("solver.0.heuristic", "berkmin") && config.solver(0).heuId == Heuristic_t::Berkmin);

		CPPUNIT_ASSERT(config.getValue("asp.eq") == "0");
		CPPUNIT_ASSERT(config.getValue("solver.0.heuristic").find("berkmin") == 0);

		CPPUNIT_ASSERT(config.validate());
		CPPUNIT_ASSERT(config.setValue("tester.configuration", "frumpy"));
		CPPUNIT_ASSERT(config.testerConfig() && config.testerConfig()->numSolver() == 1);
		CPPUNIT_ASSERT(config.setValue("tester.configuration", "many,6"));
		CPPUNIT_ASSERT(config.testerConfig() && config.testerConfig()->numSolver() == config.numSolver());

		CPPUNIT_ASSERT_THROW(config.setValue("foo.bar", "123"), std::logic_error);
		CPPUNIT_ASSERT_THROW(config.setValue("tester.eq", "1"), std::logic_error);
		CPPUNIT_ASSERT_THROW(config.setValue("solver.2", "1"), std::logic_error);

		CPPUNIT_ASSERT_THROW(config.getValue("foo.bar"), std::logic_error);
		CPPUNIT_ASSERT_THROW(config.getValue("tester.eq"), std::logic_error);
		CPPUNIT_ASSERT_THROW(config.getValue("solver.0"), std::logic_error);
	}

	void testConfigImplicitSolverMaster() {
		ClaspCliConfig config;
		CPPUNIT_ASSERT(config.getValue("solver.heuristic") == "auto,0");
		CPPUNIT_ASSERT(config.setValue("solver.heuristic", "berkmin") && config.solver(0).heuId == Heuristic_t::Berkmin);
	}
	void testConfigImplicitCreateSolver() {
		ClaspCliConfig config;
		CPPUNIT_ASSERT(config.numSolver() == 1);
		// solver option
		CPPUNIT_ASSERT(config.setValue("solver.1.heuristic", "berkmin"));
		CPPUNIT_ASSERT(config.numSolver() == 2);
		CPPUNIT_ASSERT(config.solver(1).heuId == Heuristic_t::Berkmin);
		// search option
		CPPUNIT_ASSERT(config.setValue("solver.2.restarts", "+,100,10"));
		CPPUNIT_ASSERT(config.numSearch() == 3);
		CPPUNIT_ASSERT(config.search(2).restart.sched == ScheduleStrategy::arith(100, 10));
		CPPUNIT_ASSERT(config.numSolver() == 3);

		CPPUNIT_ASSERT(config.setValue("solver.17.heuristic", "unit"));
		CPPUNIT_ASSERT(config.numSolver() == 18);
		for (uint32 i = 0; i != config.numSolver(); ++i) {
			CPPUNIT_ASSERT_EQUAL_MESSAGE("solver id not set", i, config.solver(i).id);
		}
	}
	void testConfigImplicitCreateTester() {
		ClaspCliConfig config;
		CPPUNIT_ASSERT(config.testerConfig() == 0);
		CPPUNIT_ASSERT(config.setValue("tester.learn_explicit", "1"));
		CPPUNIT_ASSERT(config.testerConfig() != 0 && config.testerConfig()->shortMode == 1);
	}

	void testConfigEnumerateKeys() {
		ClaspCliConfig config;
		std::vector keys;
		traverseKey(config, keys, ClaspCliConfig::KEY_ROOT, "");
		CPPUNIT_ASSERT(std::find(keys.begin(), keys.end(), "configuration") != keys.end());
		CPPUNIT_ASSERT(std::find(keys.begin(), keys.end(), "tester.configuration") != keys.end());
		bool tester = false;
		for (std::string grp;; ) {
			#define OPTION(k, e, a, d, x,...) CPPUNIT_ASSERT_MESSAGE(grp + #k, std::find(keys.begin(), keys.end(), grp + #k) != keys.end() || (tester && !isValidOption(config, grp + #k)));
			#define GROUP_BEGIN(X) grp += X;
			#define GROUP_END(X)   grp.erase(grp.find(X));
			#define CLASP_CONTEXT_OPTIONS ""
			#define CLASP_GLOBAL_OPTIONS ""
			#define CLASP_SOLVE_OPTIONS   "solve."
			#define CLASP_ASP_OPTIONS     "asp."
			#define CLASP_SOLVER_OPTIONS  "solver."
			#define CLASP_SEARCH_OPTIONS  "solver."
			#include 
			if (tester) { break; }
			tester = true;
			grp    = "tester.";
		}
	}

	void testConfigQueryKeys(){
		ClaspCliConfig config;
		int nSubkeys, arrLen, nValues;
		const char* help;
		CPPUNIT_ASSERT(config.getKeyInfo(ClaspCliConfig::KEY_ROOT, &nSubkeys, &arrLen, &help, &nValues) == 4);
		CPPUNIT_ASSERT(nSubkeys > 0 && arrLen == -1 && help != 0 && nValues == -1 && ClaspCliConfig::isLeafKey(ClaspCliConfig::KEY_ROOT) == false);

		CPPUNIT_ASSERT(config.getKeyInfo(ClaspCliConfig::KEY_SOLVER, &nSubkeys, &arrLen, &help, &nValues) == 4);
		CPPUNIT_ASSERT(nSubkeys > 0 && arrLen >= 0 && help != 0 && nValues == -1 && ClaspCliConfig::isLeafKey(ClaspCliConfig::KEY_ROOT) == false);

		ClaspCliConfig::KeyType s1 = config.getKey(ClaspCliConfig::KEY_SOLVER, "1");
		CPPUNIT_ASSERT(s1 != ClaspCliConfig::KEY_INVALID);
		int nSolverKeys = nSubkeys;
		CPPUNIT_ASSERT(config.getKeyInfo(s1, &nSubkeys, &arrLen, &help, &nValues) == 4);
		CPPUNIT_ASSERT(nSubkeys == nSolverKeys && arrLen == -1);

		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_SOLVER, "heuristic") != ClaspCliConfig::KEY_INVALID);
		CPPUNIT_ASSERT(config.getKey(s1, ".heuristic") != ClaspCliConfig::KEY_INVALID);
		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_SOLVER, ".") == ClaspCliConfig::KEY_SOLVER);
		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_SOLVER, "") == ClaspCliConfig::KEY_SOLVER);
		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_SOLVER, "asp") == ClaspCliConfig::KEY_INVALID);

		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_ROOT, "stats") != ClaspCliConfig::KEY_INVALID);
		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_TESTER, "stats") == ClaspCliConfig::KEY_INVALID);
		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_ROOT, "tester")!= ClaspCliConfig::KEY_INVALID);
		CPPUNIT_ASSERT(config.getKey(ClaspCliConfig::KEY_TESTER, "tester")== ClaspCliConfig::KEY_INVALID);


		ClaspCliConfig::KeyType tester = config.getKey(ClaspCliConfig::KEY_ROOT, "tester");
		CPPUNIT_ASSERT(tester == ClaspCliConfig::KEY_TESTER);
		CPPUNIT_ASSERT(config.getKey(tester, "asp") == ClaspCliConfig::KEY_INVALID);

		ClaspCliConfig::KeyType heuS0 = config.getKey(ClaspCliConfig::KEY_SOLVER, "heuristic");
		ClaspCliConfig::KeyType heuS1 = config.getKey(s1, "heuristic");
		ClaspCliConfig::KeyType heuT  = config.getKey(ClaspCliConfig::KEY_TESTER, "solver.heuristic");

		CPPUNIT_ASSERT(heuS0 != heuS1 && heuS0 != heuT && heuS1 != heuT);

		CPPUNIT_ASSERT(config.getKey(heuS0, "restarts") == ClaspCliConfig::KEY_INVALID);

		CPPUNIT_ASSERT(config.getKeyInfo(heuS0, 0, 0, &help, 0) == 1 && help);
		CPPUNIT_ASSERT(std::strstr(help, "decision heuristic") != 0);
	}

	void testConfigQueryArrKey() {
		ClaspCliConfig config;
		CPPUNIT_ASSERT(config.getArrKey(ClaspCliConfig::KEY_ROOT, 0) == ClaspCliConfig::KEY_INVALID);
		ClaspCliConfig::KeyType s0 = config.getArrKey(ClaspCliConfig::KEY_SOLVER, 0);
		CPPUNIT_ASSERT(s0 != ClaspCliConfig::KEY_INVALID);
		CPPUNIT_ASSERT(s0 != ClaspCliConfig::KEY_SOLVER);
		CPPUNIT_ASSERT(config.getArrKey(ClaspCliConfig::KEY_SOLVER, 64) == ClaspCliConfig::KEY_INVALID);

		ClaspCliConfig::KeyType st0 = config.getArrKey(config.getKey(ClaspCliConfig::KEY_TESTER, "solver"), 0);
		CPPUNIT_ASSERT(s0 != st0 && st0 != ClaspCliConfig::KEY_INVALID);
		if (config.solve.supportedSolvers() > 1) {
			ClaspCliConfig::KeyType s5 = config.getArrKey(ClaspCliConfig::KEY_SOLVER, 5);
			config.setValue(config.getKey(s5, "heuristic"), "unit");
			CPPUNIT_ASSERT(config.solver(5).heuId == Heuristic_t::Unit);
		}
	}
	void testConfigInit() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType initGen  = config.getKey(ClaspCliConfig::KEY_ROOT, "configuration");
		ClaspCliConfig::KeyType initTest = config.getKey(ClaspCliConfig::KEY_TESTER, "configuration");
		CPPUNIT_ASSERT(ClaspCliConfig::isLeafKey(initGen) && ClaspCliConfig::isLeafKey(initTest) && initTest != initGen);
		int nSub, nArr, nVal;
		const char* help;
		config.getKeyInfo(initGen, &nSub, &nArr, &help, &nVal);
		CPPUNIT_ASSERT(nSub == 0 && nArr == -1 && nVal == 1 && std::strstr(help, "frumpy") != 0);
		config.getKeyInfo(initTest, &nSub, &nArr, &help, &nVal);
		CPPUNIT_ASSERT(nSub == 0 && nArr == -1 && nVal == 0 && std::strstr(help, "tweety") != 0);

		CPPUNIT_ASSERT_EQUAL(true, config.setValue("configuration", "many"));
		CPPUNIT_ASSERT(config.numSolver() > 1);
		CPPUNIT_ASSERT(config.testerConfig() == 0);
		CPPUNIT_ASSERT_EQUAL(true, config.setValue("tester.configuration", "tweety"));
		CPPUNIT_ASSERT(config.testerConfig() != 0);
		config.getKeyInfo(initTest, 0, 0, 0, &nVal);
		CPPUNIT_ASSERT(nVal == 1);

		CPPUNIT_ASSERT(config.solver(1).id == 1);
		CPPUNIT_ASSERT(config.solver(0).heuId == Heuristic_t::Vsids);
		config.setValue("configuration", "frumpy");
		CPPUNIT_ASSERT(config.solver(0).heuId == Heuristic_t::Berkmin);
		CPPUNIT_ASSERT(config.numSolver() == 1);
	}

	void testConfigInitFromFile() {
		const char* tempName = ".test_testConfigInitFromFile.port";
		std::ofstream temp(tempName);
		const char* parallel = "";
#if WITH_THREADS
		parallel = "--parallel-mode=4";
#endif
		temp << "# A test portfolio" << std::endl;
		temp << "[t0]: --models=0 " << parallel << " --heuristic=Berkmin --restarts=x,100,1.5\n"
		     << "[t1](tweety): --heuristic=Vsids,98 --restarts=L,128\n"
		     << "t2   (jumpy): --heuristic=Vmtf --restarts=D,100,0.7\n"
		     << "[t3]: --heuristic=None --restarts=F,1000\n";
		temp.close();
		ClaspCliConfig config;
		config.setValue("configuration", tempName);

		CPPUNIT_ASSERT(config.getValue("configuration") == tempName);
		CPPUNIT_ASSERT(config.solve.numModels == 0);
		CPPUNIT_ASSERT(config.solver(0).heuId == Heuristic_t::Berkmin);
		CPPUNIT_ASSERT(config.search(0).restart.sched == ScheduleStrategy::geom(100, 1.5));
		if (std::strcmp(parallel, "") != 0) {
			CPPUNIT_ASSERT(config.solve.numSolver() == 4);
			CPPUNIT_ASSERT(config.numSolver() == 4);
			CPPUNIT_ASSERT(config.solver(1).heuId == Heuristic_t::Vsids);
			CPPUNIT_ASSERT(config.solver(2).heuId == Heuristic_t::Vmtf);
			CPPUNIT_ASSERT(config.solver(3).heuId == Heuristic_t::None);
			CPPUNIT_ASSERT(config.search(1).restart.sched == ScheduleStrategy::luby(128));
			CPPUNIT_ASSERT(config.search(2).restart.sched == ScheduleStrategy(ScheduleStrategy::User, 100, 0.7, 0));
			CPPUNIT_ASSERT(config.search(3).restart.sched == ScheduleStrategy::fixed(1000));
		}
		std::remove(tempName);
		CPPUNIT_ASSERT(config.setValue(config.getKey(ClaspCliConfig::KEY_ROOT, "configuration"), tempName) == -2);
	}

	void testConfigInitInvalidOptionInFile() {
		const char* tempName = ".test_testConfigInitInvalidOptionInCmdString.port";
		std::ofstream temp(tempName);
		temp << "[fail]: --config=many" << std::endl;
		temp.close();
		ClaspCliConfig config;
		CPPUNIT_ASSERT_THROW(config.setValue("configuration", tempName), std::logic_error);
		std::remove(tempName);
	}

	void testSetLookahead() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType lookahead = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.lookahead");
		CPPUNIT_ASSERT(config.setValue(lookahead, "no,0") == 0);
		CPPUNIT_ASSERT(config.setValue(lookahead, "body,0") > 0);
		CPPUNIT_ASSERT(config.solver(0).lookType == Var_t::Body && config.solver(0).lookOps == 0);
		CPPUNIT_ASSERT(config.setValue(lookahead, "hybrid,umax") > 0);
		CPPUNIT_ASSERT(config.solver(0).lookType == Var_t::Hybrid && config.solver(0).lookOps == 0);
		CPPUNIT_ASSERT(config.setValue(lookahead, "no") > 0);
		CPPUNIT_ASSERT(!Lookahead::isType(config.solver(0).lookType) && config.solver(0).lookOps == 0);
	}
	void testSetHeuristic() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType heuristic = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.heuristic");
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(heuristic, "vsidsS"));
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(heuristic, "vsids"));
		CPPUNIT_ASSERT(config.solver(0).heuId == Heuristic_t::Vsids && config.solver(0).heuristic.param == 0);
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(heuristic, "vmtf,12"));
		CPPUNIT_ASSERT(config.solver(0).heuId == Heuristic_t::Vmtf && config.solver(0).heuristic.param == 12);
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(heuristic, "Berkmin"));
		CPPUNIT_ASSERT(config.solver(0).heuId == Heuristic_t::Berkmin && config.solver(0).heuristic.param == 0);

		heuristic = config.getKey(ClaspCliConfig::KEY_SOLVER, "score_other");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(heuristic, "2"));
		CPPUNIT_ASSERT(config.solver(0).heuristic.other == 2);
	}
	void testSetStrengthen() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType strengthen = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.strengthen");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(strengthen, "no"));
		CPPUNIT_ASSERT(config.solver(0).ccMinAntes == SolverStrategies::no_antes);
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(strengthen, "no,1"));

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(strengthen, "recursive"));
		CPPUNIT_ASSERT(config.solver(0).ccMinAntes == SolverStrategies::all_antes);
		CPPUNIT_ASSERT(config.solver(0).ccMinRec == SolverStrategies::cc_recursive);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(strengthen, "local,2"));
		CPPUNIT_ASSERT(config.solver(0).ccMinAntes == SolverStrategies::binary_antes);
		CPPUNIT_ASSERT(config.solver(0).ccMinRec == SolverStrategies::cc_local);

		CPPUNIT_ASSERT_EQUAL(0, config.setValue(strengthen, "recs"));
	}
	void testSetContraction() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType contraction = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.contraction");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(contraction, "no"));
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(contraction, "0"));


		CPPUNIT_ASSERT_EQUAL(0, config.setValue(contraction, "0,1"));
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(contraction, "1,1"));
	}
	void testSetLoops() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType loops = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.loops");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(loops, "no"));
		CPPUNIT_ASSERT(config.solver(0).loopRep == DefaultUnfoundedCheck::only_reason);
		loops = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.1.loops");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(loops, "shared"));
		CPPUNIT_ASSERT(config.solver(1).loopRep == DefaultUnfoundedCheck::shared_reason);
	}
	void testSetDeletion() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType deletion = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.deletion");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(deletion, "0"));
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.fReduce == 0);
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(deletion, "0,10"));
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(deletion, "ipSort"));
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.algo == ReduceStrategy::reduce_sort);
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.fReduce == 75);
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.score == 0);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(deletion, "sort,50"));
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.algo == ReduceStrategy::reduce_stable);
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.fReduce == 50);
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.score == 0);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(deletion, "basic,90,1"));
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.algo == ReduceStrategy::reduce_linear);
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.fReduce == 90);
		CPPUNIT_ASSERT(config.search(0).reduce.strategy.score == 1);

		CPPUNIT_ASSERT_EQUAL(0, config.setValue(deletion, "basic,102"));
	}
	void testSetShareMode() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType share = config.getKey(ClaspCliConfig::KEY_ROOT, "share");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(share, "no"));
		CPPUNIT_ASSERT(config.shareMode == ContextParams::share_no);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(share, "problem"));
		CPPUNIT_ASSERT(config.shareMode == ContextParams::share_problem);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(share, "LEARNT"));
		CPPUNIT_ASSERT(config.shareMode == ContextParams::share_learnt);
	}

	void testSetTrMode() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType tr = config.getKey(ClaspCliConfig::KEY_ROOT, "asp.trans_ext");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(tr, "no"));
		CPPUNIT_ASSERT(config.asp.erMode == Asp::LogicProgram::mode_native);
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(tr, "scc"));
		CPPUNIT_ASSERT(config.asp.erMode == Asp::LogicProgram::mode_transform_scc);
		tr = config.getKey(ClaspCliConfig::KEY_ROOT, "tester.asp.trans_ext");
		CPPUNIT_ASSERT_EQUAL(ClaspCliConfig::KEY_INVALID, tr);
		CPPUNIT_ASSERT(config.setValue(tr, "scc") == -1);
		CPPUNIT_ASSERT_THROW(config.setValue("tester.asp.trans_ext", "scc"), std::logic_error);
	}
	void testSetEnumMode() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType eMode = config.getKey(ClaspCliConfig::KEY_ROOT, "solve.enum_mode");

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(eMode, "brave"));
		CPPUNIT_ASSERT(config.solve.enumMode == EnumOptions::enum_brave);
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(eMode, "consequences"));

		CPPUNIT_ASSERT_EQUAL(true, config.setValue("solve.opt_mode", "ignore"));
		CPPUNIT_ASSERT(config.solve.optMode == MinimizeMode_t::ignore);

		CPPUNIT_ASSERT_THROW(config.setValue("tester.solve.enum_mode", "brave"), std::logic_error);
	}
	void testSetOptStrategy() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType oStrat = config.getKey(ClaspCliConfig::KEY_ROOT, "solver.opt_strategy");
		std::string val;
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(oStrat, "bb"));
		CPPUNIT_ASSERT(config.getValue(oStrat, val) > 0 && val == "bb,0");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(oStrat, "bb,2"));
		CPPUNIT_ASSERT(config.getValue(oStrat, val) > 0 && val == "bb,2");
		CPPUNIT_ASSERT(config.solver(0).optStrat == 0u && config.solver(0).optParam == 2u);
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(oStrat, "bb,4"));

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(oStrat, "usc"));
		CPPUNIT_ASSERT(config.getValue(oStrat, val) > 0 && val == "usc,0");
		CPPUNIT_ASSERT(config.solver(0).optStrat == MinimizeMode_t::opt_usc);
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(oStrat, "usc,4"));
		CPPUNIT_ASSERT(config.solver(0).optStrat == MinimizeMode_t::opt_usc && config.solver(0).optParam == 4u);

		CPPUNIT_ASSERT(config.getValue(oStrat, val) > 0 && val == "usc,4");
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(oStrat, "usc,16"));
	}
	void testSetSolveLimit() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType limit = config.getKey(ClaspCliConfig::KEY_ROOT, "solve.solve_limit");
		std::string val;
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(limit, "0"));
		CPPUNIT_ASSERT(config.getValue(limit, val) > 0);
		CPPUNIT_ASSERT_EQUAL(std::string("0,umax"), val);
		CPPUNIT_ASSERT(config.solve.limit.conflicts == 0);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(limit, "no"));
		CPPUNIT_ASSERT(config.getValue(limit, val) > 0);
		CPPUNIT_ASSERT(config.solve.limit.conflicts == UINT64_MAX);
		CPPUNIT_ASSERT_EQUAL(std::string("umax,umax"), val);
	}

#if WITH_THREADS
	void testSetParallelMode() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType pMode = config.getKey(ClaspCliConfig::KEY_ROOT, "solve.parallel_mode");
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(pMode, "0"));
		CPPUNIT_ASSERT_EQUAL(uint32(1), config.solve.algorithm.threads);
		CPPUNIT_ASSERT(SolveOptions::Algorithm::mode_compete == config.solve.algorithm.mode);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(pMode, "10"));
		CPPUNIT_ASSERT_EQUAL(uint32(10), config.solve.algorithm.threads);
		CPPUNIT_ASSERT(SolveOptions::Algorithm::mode_compete == config.solve.algorithm.mode);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(pMode, "10,split"));
		CPPUNIT_ASSERT_EQUAL(uint32(10), config.solve.algorithm.threads);
		CPPUNIT_ASSERT(SolveOptions::Algorithm::mode_split == config.solve.algorithm.mode);

		CPPUNIT_ASSERT_EQUAL(0, config.setValue(pMode, "65"));
	}
	void testSetDistribute() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType distribute = config.getKey(ClaspCliConfig::KEY_ROOT, "solve.distribute");
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(distribute, "0"));
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(distribute, "0,1"));
		CPPUNIT_ASSERT_EQUAL(1, config.setValue(distribute, "conflict"));
		CPPUNIT_ASSERT(Distributor::Policy::conflict == config.solve.distribute.types);
		CPPUNIT_ASSERT(4 == config.solve.distribute.lbd);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(distribute, "loop,2"));
		CPPUNIT_ASSERT(Distributor::Policy::loop == config.solve.distribute.types);
		CPPUNIT_ASSERT(2 == config.solve.distribute.lbd);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(distribute, "all,2,123"));
		CPPUNIT_ASSERT(Distributor::Policy::all == config.solve.distribute.types);
		CPPUNIT_ASSERT(2 == config.solve.distribute.lbd);
		CPPUNIT_ASSERT(123 == config.solve.distribute.size);
	}
	void testSetIntegrate() {
		ClaspCliConfig config;
		ClaspCliConfig::KeyType integrate = config.getKey(ClaspCliConfig::KEY_ROOT, "solve.integrate");

		CPPUNIT_ASSERT_EQUAL(0, config.setValue(integrate, "0"));
		CPPUNIT_ASSERT_EQUAL(0, config.setValue(integrate, "no"));

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(integrate, "active"));
		CPPUNIT_ASSERT(SolveOptions::Integration::filter_heuristic == config.solve.integrate.filter);
		CPPUNIT_ASSERT(1024 == config.solve.integrate.grace);
		CPPUNIT_ASSERT(SolveOptions::Integration::topo_all == config.solve.integrate.topo);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(integrate, "unsat,100"));
		CPPUNIT_ASSERT(SolveOptions::Integration::filter_sat == config.solve.integrate.filter);
		CPPUNIT_ASSERT(100 == config.solve.integrate.grace);
		CPPUNIT_ASSERT(SolveOptions::Integration::topo_all == config.solve.integrate.topo);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(integrate, "gp,200,cubeX"));
		CPPUNIT_ASSERT(SolveOptions::Integration::filter_gp == config.solve.integrate.filter);
		CPPUNIT_ASSERT(200 == config.solve.integrate.grace);
		CPPUNIT_ASSERT(SolveOptions::Integration::topo_cubex == config.solve.integrate.topo);

		CPPUNIT_ASSERT_EQUAL(1, config.setValue(integrate, "gp,77,cube"));
		CPPUNIT_ASSERT(SolveOptions::Integration::filter_gp == config.solve.integrate.filter);
		CPPUNIT_ASSERT(77 == config.solve.integrate.grace);
		CPPUNIT_ASSERT(SolveOptions::Integration::topo_cube == config.solve.integrate.topo);
	}
#endif

	void testConfigQueryStrValues() {
		ClaspCliConfig config;
		std::string out;
		CPPUNIT_ASSERT(config.getValue(config.getKey(ClaspCliConfig::KEY_TESTER, "configuration"), out) == -1);
		config.setValue("configuration", "tweety");
		CPPUNIT_ASSERT(config.getValue("configuration") == "tweety");

		CPPUNIT_ASSERT(config.getValue("solver.heuristic") == "vsids,92");
		CPPUNIT_ASSERT(config.getValue("solver.strengthen") == "recursive,0,0");
		CPPUNIT_ASSERT(config.getValue("solver.deletion") == "basic,50,0");
		CPPUNIT_ASSERT(config.getValue("solver.restarts") == "l,60");
		CPPUNIT_ASSERT(config.getValue("solver.loops") == "shared");
		CPPUNIT_ASSERT(config.getValue("solver.partial_check") == "no");

		CPPUNIT_ASSERT(config.getValue("sat_prepro") == "no");

		std::vector leafs;
		traverseKey(config, leafs, ClaspCliConfig::KEY_ROOT, "");
		std::string val;
		for (uint32 i = 0; i != leafs.size(); ++i) {
			if (config.hasValue(leafs[i].c_str())) {
				val = config.getValue(leafs[i].c_str());
				CPPUNIT_ASSERT(config.setValue(leafs[i].c_str(), val.c_str()));
			}
		}
		config.setValue("sat_prepro", "2,20,25");
		CPPUNIT_ASSERT(std::strncmp(config.getValue("sat_prepro").c_str(), "2,20,25", std::strlen("2,20,25")) == 0);
		config.reset();
		std::string x = config.getValue("solver.del_cfl");
		CPPUNIT_ASSERT(x == "no" || x == "0");
		x = config.getValue("solver.del_grow");

		CPPUNIT_ASSERT(config.setValue("solver.del_grow", x.c_str()));
		x = config.getValue("solve.opt_bound");
		CPPUNIT_ASSERT(x == "no");
		config.setValue("solve.opt_bound", "122");
		CPPUNIT_ASSERT(config.getValue("solve.opt_bound") == "122");
		config.setValue("solver.del_init", "3,100,200");
		CPPUNIT_ASSERT(config.getValue("solver.del_init") == "3,100,200");

		CPPUNIT_ASSERT(!config.hasValue("tester.learn_explicit"));
		config.setValue("tester.learn_explicit", "1");
		CPPUNIT_ASSERT(config.hasValue("tester.learn_explicit"));

		CPPUNIT_ASSERT_THROW(config.getValue("enum"), std::logic_error);
		CPPUNIT_ASSERT_THROW(config.getValue("tester.solve.opt_bound"), std::logic_error);
	}

	void testSetOptBound() {
		ClaspCliConfig config;
		std::string bound = config.getValue("solve.opt_bound");
		CPPUNIT_ASSERT(bound == "no");
		CPPUNIT_ASSERT_EQUAL(true, config.setValue("solve.opt_bound", "100"));
		CPPUNIT_ASSERT((bound = config.getValue("solve.opt_bound")) == "100");
		CPPUNIT_ASSERT_EQUAL(true, config.setValue("solve.opt_bound", "50,20"));
		bound = config.getValue("solve.opt_bound");
		CPPUNIT_ASSERT_EQUAL(bound, std::string("50,20"));
		CPPUNIT_ASSERT_EQUAL(true, config.setValue("solve.opt_bound", "no"));
		CPPUNIT_ASSERT((bound = config.getValue("solve.opt_bound")) == "no");

		CPPUNIT_ASSERT_EQUAL(true, config.setValue("solve.opt_bound", "50,20"));
		CPPUNIT_ASSERT_EQUAL(false, config.setValue("solve.opt_bound", "a,b"));
		bound = config.getValue("solve.opt_bound");
		CPPUNIT_ASSERT_EQUAL(bound, std::string("50,20"));
	}
private:
	bool isValidOption(const ClaspCliConfig& c, const std::string& k) const {
		return ClaspCliConfig::isLeafKey(c.getKey(ClaspCliConfig::KEY_ROOT, k.c_str()));
	}
	void traverseKey(const ClaspCliConfig& c, std::vector& keys, ClaspCliConfig::KeyType k, std::string accu) {
		if (k == ClaspCliConfig::KEY_INVALID) { throw std::runtime_error("Invalid key"); }
		if (ClaspCliConfig::isLeafKey(k)) {
			keys.push_back(accu);
		}
		else {
			int i = 0;
			if (!accu.empty()) { accu += '.'; }
			std::size_t pop = accu.size();
			for (const char* x = 0; (x = c.getSubkey(k, i)) != 0; ++i, accu.resize(pop)) {
				accu += x;
				traverseKey(c, keys, c.getKey(k, x), accu);
			}
		}
	}
};

CPPUNIT_TEST_SUITE_REGISTRATION(CliTest);
} } }

clasp-3.2.2/libclasp/tests/decision_heuristic_test.cpp000066400000000000000000000701531304134206100231720ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
#include 
#include 
#include 
namespace Clasp { namespace Test {
using namespace Clasp::Asp;
class DecisionHeuristicTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(DecisionHeuristicTest);
	CPPUNIT_TEST(testBodyLookahead);
	CPPUNIT_TEST(testAtomLookahead);
	CPPUNIT_TEST(testLookaheadBugNoSimplify);
	CPPUNIT_TEST(testLookaheadBugDepsNotCleared);
	CPPUNIT_TEST(testLookaheadBugNoDeps);
	CPPUNIT_TEST(testLookaheadBugNoNant);
	CPPUNIT_TEST(testLookaheadStopConflict);

	CPPUNIT_TEST(testBerkmin);
	CPPUNIT_TEST(testVmtf);
	CPPUNIT_TEST(testVsids);
	CPPUNIT_TEST(testVsidsAux);
	CPPUNIT_TEST(testStrangeLookSeq);
	CPPUNIT_TEST(testStrangeLookSeq2);
	CPPUNIT_TEST(testRestrictDetach);

	CPPUNIT_TEST(testDomSignPos);
	CPPUNIT_TEST(testDomSignNeg);
	CPPUNIT_TEST(testDomSignInv);

	CPPUNIT_TEST(testDomLevel);
	CPPUNIT_TEST(testDomDynamic);
	CPPUNIT_TEST(testDomPrio);
	CPPUNIT_TEST(testDomPrio2);
	CPPUNIT_TEST(testDomPrio3);
	CPPUNIT_TEST(testDomInit);
	CPPUNIT_TEST(testDomInc);
	CPPUNIT_TEST(testDomIncPrio);
	CPPUNIT_TEST(testDomIncDynPrio);
	CPPUNIT_TEST(testDomReinit);
	CPPUNIT_TEST(testDomMinBug);
	CPPUNIT_TEST(testDomSameVar);

	CPPUNIT_TEST(testDomEqAtomLevel);
	CPPUNIT_TEST(testDomEqAtomSign);
	CPPUNIT_TEST(testDomCompAtomLevel);
	CPPUNIT_TEST(testDomCompAtomSign);
	CPPUNIT_TEST(testDomCompAtomTF);

	CPPUNIT_TEST(testDomDefault);

	CPPUNIT_TEST(testDomAtomicPrio);
	CPPUNIT_TEST(testDomEqVarDiffLevel);
	CPPUNIT_TEST(testDomEqVarDiffLevelInc);
	CPPUNIT_TEST(testDomEqVarDiffLevelCond);

	CPPUNIT_TEST_SUITE_END();

	LogicProgram lp;
public:
	void testBodyLookahead() {
		SharedContext ctx;
		Solver& s = ctx.pushSolver();
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq().noScc()),
			"x1 :- not x1.\n"
			"x1 :- not x2, not x5.\n"
			"x2 :- not x5.\n"
			"x5 :- not x2.\n"
			"x1 :- not x3, not x6.\n"
			"x3 :- not x6.\n"
			"x6 :- not x3.\n"
			"x1 :- not x4, not x7.\n"
			"x4 :- not x7.\n"
			"x7 :- not x4.\n");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		s.addPost(new Lookahead(Lookahead::Params(Var_t::Body).addImps(false)));
		CPPUNIT_ASSERT_EQUAL(false, ctx.attach(s));
		ctx.detach(s, true);
		s.addPost(new Lookahead(Lookahead::Params(Var_t::Atom).addImps(false)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.attach(s));
		ctx.detach(s, true);
		s.addPost(new Lookahead(Lookahead::Params(Var_t::Hybrid).addImps(false)));
		CPPUNIT_ASSERT_EQUAL(false, ctx.attach(s));
	}
	void testAtomLookahead() {
		SharedContext ctx;
		Solver& s = ctx.pushSolver();
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq().noScc()),
			"x1 :- x2, x3, x4, not x1.\n"
			"x2 :- not x5.\n"
			"x2 :- not x8.\n"
			"x5 :- not x8.\n"
			"x8 :- not x5.\n"
			"x3 :- not x6.\n"
			"x3 :- not x9.\n"
			"x6 :- not x9.\n"
			"x9 :- not x6.\n"
			"x4 :- not x7.\n"
			"x4 :- not x10.\n"
			"x7 :- not x10.\n"
			"x10 :- not x7.\n");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		Lookahead::Params p; p.addImps(false);
		s.addPost(new Lookahead(p.lookahead(Var_t::Body)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.attach(s));
		ctx.detach(s, true);
		s.addPost(new Lookahead(p.lookahead(Var_t::Atom)));
		CPPUNIT_ASSERT_EQUAL(false, ctx.attach(s));
		ctx.detach(s, true);
		s.addPost(new Lookahead(p.lookahead(Var_t::Hybrid)));
		CPPUNIT_ASSERT_EQUAL(false, ctx.attach(s));
	}

	void testLookaheadBugNoSimplify() {
		UnitHeuristic unit;
		SharedContext ctx;
		ctx.master()->setHeuristic(&unit, Ownership_t::Retain);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal e = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints(10);
		ctx.addBinary(a,  b);
		s.addPost(new Lookahead(Var_t::Atom));
		ctx.endInit();
		ctx.addBinary(a, ~b);
		s.assume(e) && s.propagate();
		CPPUNIT_ASSERT(unit.select(s));
		CPPUNIT_ASSERT(s.isTrue(a));
		CPPUNIT_ASSERT(s.seen(a.var()));
		CPPUNIT_ASSERT(s.decisionLevel() == 1);
	}
	void testLookaheadBugDepsNotCleared() {
		UnitHeuristic unit;
		SharedContext ctx;
		ctx.master()->setHeuristic(&unit, Ownership_t::Retain);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Literal e = posLit(ctx.addVar(Var_t::Atom));
		Literal f = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(a, b);
		ctx.addBinary(b, c);
		ctx.addBinary(c, f);
		ctx.addUnary(e);
		s.addPost(new Lookahead(Var_t::Atom));
		ctx.endInit();
		// Assume without using lookahead (e.g. a random choice)
		s.assume(b);
		s.propagate();
		// Deps not cleared
		CPPUNIT_ASSERT(unit.select(s));
		CPPUNIT_ASSERT(s.isFalse(c) || s.isFalse(f));
	}
	void testLookaheadBugNoDeps() {
		UnitHeuristic unit;
		SharedContext ctx;
		ctx.master()->setHeuristic(&unit, Ownership_t::Retain);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Literal e = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		s.addPost(new Lookahead(Var_t::Atom));
		ctx.addBinary(a, b);
		ctx.addBinary(b, c);
		ctx.addUnary(e);
		ctx.endInit();
		CPPUNIT_ASSERT(unit.select(s));
		CPPUNIT_ASSERT(s.isFalse(b));
		s.undoUntil(0);
		s.simplify();
		CPPUNIT_ASSERT(unit.select(s));
		CPPUNIT_ASSERT(s.isFalse(b));
	}
	void testLookaheadBugNoNant() {
		Clasp::Lookahead::Params p(Var_t::Atom);
		p.restrictNant = true;
		UnitHeuristic unit;
		SharedContext ctx;
		ctx.master()->setHeuristic(&unit, Ownership_t::Retain);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		s.addPost(new Lookahead(p));
		ctx.addBinary(a, b);
		ctx.addBinary(b, c);
		ctx.addBinary(~a, ~b);
		ctx.addBinary(~b, ~c);
		ctx.endInit();
		uint32 n = s.numFreeVars();
		CPPUNIT_ASSERT(unit.select(s) && s.numFreeVars() != n);
	}

	void testLookaheadStopConflict() {
		UnitHeuristic unit;
		SharedContext ctx;
		ctx.master()->setHeuristic(&unit, Ownership_t::Retain);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(a, b);
		s.addPost(new Lookahead(Var_t::Atom));
		ctx.endInit();
		struct StopConflict : public PostPropagator {
			bool propagateFixpoint(Solver& s, PostPropagator*) { s.setStopConflict(); return false; }
			uint32 priority() const   { return PostPropagator::priority_class_simple; }
		}* x = new StopConflict;
		s.addPost(x);
		CPPUNIT_ASSERT(!unit.select(s) && s.hasConflict());
		CPPUNIT_ASSERT(s.search(0,0) == value_false);
	}

	void testBerkmin() {
		ClaspBerkmin berkmin;
		SharedContext ctx;
		ctx.master()->setHeuristic(&berkmin, Ownership_t::Retain);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Literal d = posLit(ctx.addVar(Var_t::Atom));
		Literal e = posLit(ctx.addVar(Var_t::Atom));
		Literal f = posLit(ctx.addVar(Var_t::Atom));
		Literal g = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		s.stats.conflicts = 1;
		LitVec up;
		berkmin.updateReason(s, up, Literal() );
		up.push_back(a);
		berkmin.updateReason( s,up,a );
		up.clear();
		up.push_back(b);
		up.push_back(b);
		berkmin.updateReason( s,up,b );
		up.clear();
		berkmin.updateReason( s,up,e );
		s.assume( ~b );
		s.assume( ~c );
		s.assume( ~d );
		ClauseCreator cc(&s);
		cc.start(Constraint_t::Conflict).add(a).add(b).add(c).add(d).end();
		s.undoUntil(0);
		s.assume( ~e );
		s.assume( ~f );
		s.assume( ~g );
		cc.start(Constraint_t::Loop).add(d).add(e).add(f).add(g).end();
		s.undoUntil(0);
		CPPUNIT_ASSERT_EQUAL(0u, s.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, berkmin.select(s));
		CPPUNIT_ASSERT_EQUAL(b, s.trail().back());	// from conflict clause
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(true, berkmin.select(s));
		CPPUNIT_ASSERT_EQUAL(e, s.trail().back());	// from loop clause
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(true, berkmin.select(s));
		CPPUNIT_ASSERT_EQUAL(a.var(), s.trail().back().var());	// highest activity
	}
	void testVmtf() {
		ClaspVmtf vmtf;
		SharedContext ctx;
		ctx.master()->setHeuristic(&vmtf, Ownership_t::Retain);
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(true, vmtf.select(s));
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(true, vmtf.select(s));
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(false, vmtf.select(s));
	}

	void testVsids() {
		ClaspVsids vsids;
		SharedContext ctx;
		ctx.master()->setHeuristic(&vsids, Ownership_t::Retain);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		LitVec up;
		up.push_back(a);
		vsids.updateReason( s,up,a );
		CPPUNIT_ASSERT_EQUAL(true, vsids.select(s));
		CPPUNIT_ASSERT_EQUAL(true, s.trail().back() == ~a && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, vsids.select(s));
		CPPUNIT_ASSERT_EQUAL(true, s.trail().back() == ~b && s.propagate());
		CPPUNIT_ASSERT_EQUAL(false, vsids.select(s));
	}
	void testVsidsAux() {
		ClaspVsids vsids;
		SharedContext ctx;
		ctx.master()->setHeuristic(&vsids, Ownership_t::Retain);
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Var v = s.pushAuxVar();
		LitVec up;
		vsids.updateReason(s,up,posLit(v));
		CPPUNIT_ASSERT_EQUAL(true, vsids.select(s));
		CPPUNIT_ASSERT(s.value(v) != value_free);
		s.popAuxVar(1);
		CPPUNIT_ASSERT_EQUAL(true, vsids.select(s));
		CPPUNIT_ASSERT(s.trail().back().var() != v);
	}

	void testStrangeLookSeq() {
		SharedContext ctx;
		Lookahead::Params p(Var_t::Body); p.limit(3);
		ctx.master()->setHeuristic(UnitHeuristic::restricted(new SelectFirst), Ownership_t::Acquire);
		Literal a = posLit(ctx.addVar(Var_t::Body));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		s.addPost(new Lookahead(p));
		ctx.endInit();
		s.force(a);
		s.simplify();
		bool x = s.decideNextBranch();
		CPPUNIT_ASSERT(x == true && s.value(b.var()) != value_free);
	}

	void testStrangeLookSeq2() {
		SharedContext ctx;
		Lookahead::Params p(Var_t::Atom); p.limit(2);
		ctx.master()->setHeuristic(UnitHeuristic::restricted(new SelectFirst), Ownership_t::Acquire);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		s.addPost(new Lookahead(p));
		ctx.addBinary(a, b);
		ctx.addBinary(a, ~b);
		ctx.addBinary(~a, b);
		ctx.endInit();
		bool x = ctx.master()->decideNextBranch();
		CPPUNIT_ASSERT(x == false && s.decisionLevel() == 0 && s.numFreeVars() == 0);
	}

	void testRestrictDetach() {
		SharedContext ctx;
		Lookahead::Params p(Var_t::Atom); p.limit(3);
		ctx.master()->setHeuristic(UnitHeuristic::restricted(new SelectFirst), Ownership_t::Acquire);
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		posLit(ctx.addVar(Var_t::Atom));
		posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		s.addPost(new Lookahead(p));
		ctx.addBinary(a, b);
		ctx.endInit();
		bool x = ctx.master()->decideNextBranch();
		CPPUNIT_ASSERT(x == true && s.decisionLevel() == 1);
		s.propagate();
		CPPUNIT_ASSERT(s.getPost(PostPropagator::priority_reserved_look) != 0);
		s.setHeuristic(new SelectFirst, Ownership_t::Acquire);
		while (s.getPost(PostPropagator::priority_reserved_look) != 0) {
			s.propagate();
			s.decideNextBranch();
		}
	}
	void testDomSignPos() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1;
		lp.start(ctx).addRule(Head_t::Choice, Potassco::toSpan(&a, 1), Potassco::toSpan());
		lp.addDomHeuristic(a, DomModType::Sign, 1, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(a)));
	}
	void testDomSignNeg() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1;
		lp.start(ctx).addRule(Head_t::Choice, Potassco::toSpan(&a, 1), Potassco::toSpan());
		lp.addDomHeuristic(a, DomModType::Sign, -1, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(~lp.getLiteral(a)));
	}
	void testDomSignInv() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1;
		lpAdd(lp.start(ctx), "a :- not b.\n"
			"b :- not a.\n");
		lp.addDomHeuristic(a, DomModType::Sign, 1, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(a)));
	}
	void testDomLevel() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2;
		lpAdd(lp.start(ctx), "{a;b}.");
		lp.addDomHeuristic(a, DomModType::Sign, 1, 1);
		lp.addDomHeuristic(b, DomModType::Sign, 1, 1);
		lp.addDomHeuristic(a, DomModType::Level, 10, 10);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(a)));
	}

	void testDomDynamic() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2, c = 3;
		lpAdd(lp.start(ctx), "{a;b;c}.\n"
			"d :- a, b.\n"
			":- d.\n");

		lp.addDomHeuristic(a, DomModType::Sign, 1, 1);
		lp.addDomHeuristic(b, DomModType::Sign, 1, 1);
		lp.addDomHeuristic(a, DomModType::Level, 10, 10);
		lp.addDomHeuristic(c, DomModType::Sign, 1, 1, b);
		lp.addDomHeuristic(c, DomModType::Sign, -1, 1, Potassco::neg(b));

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(a)));
		s.propagate();
		CPPUNIT_ASSERT(s.isFalse(lp.getLiteral(b)));

		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(~lp.getLiteral(c)));

		s.clearAssumptions();
		uint32 n = s.numWatches(posLit(2));
		// test removal of watches
		ctx.master()->setHeuristic(new SelectFirst(), Ownership_t::Acquire);
		CPPUNIT_ASSERT_MESSAGE("Heuristic not detached", s.numWatches(posLit(2)) != n);
	}

	void testDomPrio() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		LogicProgram api;
		lpAdd(lp.start(ctx), "{a;b;c}.\n"
			"d :- a, b.\n"
			":- d.\n"
			"#heuristic b.         [1@1,sign]\n"
			"#heuristic a.         [10@10,true]\n"
			"#heuristic c.         [1@10,sign]\n"
			"#heuristic c : not b. [-1@20,sign]\n");
		Var a = 1, b = 2, c = 3;
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(a)));
		s.propagate();
		CPPUNIT_ASSERT(s.isFalse(lp.getLiteral(b)));

		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(~lp.getLiteral(c)));
	}
	void testDomPrio2() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		lpAdd(lp.start(ctx), "{a;b;c}.\n"
			"d :- a, b.\n"
			":- d.\n"
			"#heuristic b.         [1@1,sign]\n"
			"#heuristic a.         [10@10,true]\n"
			"#heuristic c.         [1@30,sign]\n"
			"#heuristic c : not b. [-1@20,sign]\n");
		Var a = 1, b = 2, c = 3;
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(a)));
		s.propagate();
		CPPUNIT_ASSERT(s.isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(c)));
	}
	void testDomPrio3() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var b = 2, c = 3;
		lpAdd(lp.start(ctx), "{a;c}.\n"
			"b :- a.\n"
			"#heuristic a.     [1@30,true]\n"
			"#heuristic a.     [1@20,false]\n"
			"#heuristic b.     [2@10,true]\n"
			"#heuristic b : c. [2@25,false]\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		s.assume(lp.getLiteral(c)) && s.propagate();
		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.isTrue(~lp.getDomLiteral(b)));
		s.undoUntil(0);
	}
	void testDomInit() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2;
		lpAdd(lp.start(ctx), "{a;b}.\n"
			"#heuristic a. [10@20,init]\n"
			"#heuristic a. [50@10,init]\n"
			"#heuristic b. [10@10,init]\n"
			"#heuristic b. [30@20,init]\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		ctx.heuristic.add(lp.getLiteral(a).var(), DomModType::Init, 21, 20, lit_true());
		ctx.endInit();
		CPPUNIT_ASSERT(s.decideNextBranch());
		CPPUNIT_ASSERT(s.value(lp.getLiteral(b).var()) != value_free);
	}
	void testDomInc() {
		SharedContext ctx;
		Solver& s = *ctx.master();

		Var a = 1, b = 2, c = 3, d = 4, e = 5;
		lp.start(ctx).updateProgram();
		lpAdd(lp, "{a;b;c;d}.\n");
		lp.addDomHeuristic(a, DomModType::Level, 1, 1, c);
		lp.addDomHeuristic(b, DomModType::Level, 1, 1, d);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		uint32 n = s.numWatches(posLit(c));
		DomainHeuristic dom;
		dom.startInit(s);
		dom.endInit(s);
		s.setHeuristic(&dom, Ownership_t::Retain);
		CPPUNIT_ASSERT(s.numWatches(posLit(c)) > n);
		CPPUNIT_ASSERT(lp.updateProgram());
		lpAdd(lp, "{e}.");
		lp.addDomHeuristic(e, DomModType::Level, 1, 1, c);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		s.setHeuristic(new SelectFirst(), Ownership_t::Acquire);
		CPPUNIT_ASSERT_MESSAGE("Heuristic not detached", s.numWatches(posLit(c)) == n);
	}
	void testDomIncPrio() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		lp.start(ctx).updateProgram();
		lpAdd(lp, "{a}.");
		Var a = 1, b = 2;
		lp.addDomHeuristic(a, DomModType::False,3, 3);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isFalse(lp.getLiteral(a)));
		s.undoUntil(0);
		CPPUNIT_ASSERT(lp.updateProgram());
		lpAdd(lp, "{b}.\n");
		lp.addDomHeuristic(a, DomModType::False, 1, 1);
		lp.addDomHeuristic(b, DomModType::False, 2, 2);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isFalse(lp.getLiteral(a)));
	}
	void testDomIncDynPrio() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		lp.start(ctx).updateProgram();
		Var a = 1, b = 2;
		lpAdd(lp, "{a;b}.");
		lp.addDomHeuristic(a, DomModType::True, 1, 10);
		lp.addDomHeuristic(a, DomModType::False, 1, 20, b);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isTrue(lp.getLiteral(a)));
		s.undoUntil(0);

		CPPUNIT_ASSERT(lp.updateProgram());
		lp.addDomHeuristic(a, DomModType::True, 1, 30);
		lp.addDomHeuristic(b, DomModType::True, 2, 2);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isTrue(lp.getLiteral(b)));
		CPPUNIT_ASSERT(s.propagate());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isTrue(lp.getLiteral(a)));
	}

	void testDomReinit() {
		SharedContext ctx;
		Solver& s = *ctx.master();
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Var b = 2;
		lp.start(ctx).updateProgram();
		lpAdd(lp, "{a;b}.");
		lp.addDomHeuristic(b, DomModType::Level, 1, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getLiteral(b).var()) != value_free);
		CPPUNIT_ASSERT(lp.updateProgram());
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		lpAdd(lp, "{c}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getLiteral(b).var()) != value_free);
	}

	void testDomMinBug() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);

		Var a = 1, b = 2;
		lpAdd(lp.start(ctx), "a :- not b. b :- not a.");
		lp.addDomHeuristic(a, DomModType::False, 1, 1);
		lp.addDomHeuristic(b, DomModType::False, 1, 1);
		LitVec min;
		ctx.heuristic.domRec = &min;
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT(min.size() == 2);
	}

	void testDomSameVar() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2;
		lpAdd(lp.start(ctx), "a :- not b. b :- not a.");
		lp.addDomHeuristic(a, DomModType::True, 2, 2);
		lp.addDomHeuristic(b, DomModType::True, 1, 1);
		LitVec min;
		ctx.heuristic.domRec = &min;
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT(min.size() == 2);
	}

	void testDomEqAtomLevel() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2, c = 3;
		lpAdd(lp.start(ctx),
			"{a;c}.\n"
			"b :- a.\n");
		lp.addDomHeuristic(a, DomModType::Level, 1, 3);
		lp.addDomHeuristic(b, DomModType::Level, 3, 2);
		lp.addDomHeuristic(c, DomModType::Level, 2, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getDomLiteral(b).var()) != value_free);
	}
	void testDomEqAtomSign() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Var a = 1, b = 2;
		lpAdd(lp.start(ctx), "{a}. b :- a.");
		lp.addDomHeuristic(a, DomModType::Sign, 1, 1);
		lp.addDomHeuristic(b, DomModType::Sign,-1, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->pref(lp.getDomLiteral(a).var()).has(ValueSet::user_value));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->pref(lp.getDomLiteral(b).var()).has(ValueSet::user_value));
	}
	void testDomCompAtomLevel() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2, c = 3;
		lpAdd(lp.start(ctx), "{a;c}. b :- not a.");
		lp.addDomHeuristic(a, DomModType::Level, 1, 3);
		lp.addDomHeuristic(b, DomModType::Level, 3, 2);
		lp.addDomHeuristic(c, DomModType::Level, 2, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getDomLiteral(b).var()) != value_free);
	}
	void testDomCompAtomSign() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Var a = 1, b = 2;
		lpAdd(lp.start(ctx), "{a}. b :- not a.");
		lp.addDomHeuristic(a, DomModType::Sign, 1, 1);
		lp.addDomHeuristic(b, DomModType::Sign, 1, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->pref(lp.getDomLiteral(a).var()).has(ValueSet::user_value));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->pref(lp.getDomLiteral(b).var()).has(ValueSet::user_value));
	}
	void testDomCompAtomTF() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2;
		lpAdd(lp.start(ctx), "a :- not b. b :- not a. {c}.");
		lp.addDomHeuristic(a, DomModType::True, 10, 10);
		lp.addDomHeuristic(b, DomModType::True, 20, 20);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isTrue(lp.getDomLiteral(b)));
	}
	void testDomDefault() {
		SharedContext ctx;
		DomainHeuristic dom;
		dom.setDefaultMod(HeuParams::mod_level, 0);
		ctx.master()->setHeuristic(&dom, Ownership_t::Retain);
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Body);
		ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT(dom.score(v1).level == 1);
		CPPUNIT_ASSERT(dom.score(v2).level == 0);
		ctx.unfreeze();
		dom.setDefaultMod(HeuParams::mod_level, HeuParams::pref_show);
		Var v3 = ctx.addVar(Var_t::Atom);
		ctx.output.add("v1", posLit(v1));
		ctx.output.add("v3", posLit(v3));
		ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT(dom.score(v1).level == dom.score(v3).level);
		CPPUNIT_ASSERT(dom.score(v2).level == 0);
	}

	// UNSUPPORTED

	void testDomAtomicPrio() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		lp.start(ctx).updateProgram();
		Var a = 1, b = 2;
		lpAdd(lp, "{a}. b :- a.");
		lp.addDomHeuristic(a, DomModType::False, 2, 3);
		lp.addDomHeuristic(b, DomModType::False, 1, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isFalse(lp.getDomLiteral(a)));
		s.undoUntil(0);
		CPPUNIT_ASSERT(lp.updateProgram());
		lp.addDomHeuristic(b, DomModType::True, 3, 2);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isTrue(lp.getDomLiteral(b)));
	}
	void testDomEqVarDiffLevel() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2, c = 3;
		lp.start(ctx);
		lpAdd(lp, "{a;c}. b :- a.");
		lp.addDomHeuristic(a, DomModType::Level, 2, 1);
		lp.addDomHeuristic(c, DomModType::Level, 2, 1);
		lp.addDomHeuristic(c, DomModType::Init, 10, 1);
		lp.addDomHeuristic(b, DomModType::Init, 20, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.value(lp.getLiteral(c).var()) == value_free);
		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getLiteral(c).var()) != value_free);
	}
	void testDomEqVarDiffLevelInc() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2, c = 3;
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "{a;c}. b :- a.");
		lp.addDomHeuristic(a, DomModType::Level, 2, 1);
		lp.addDomHeuristic(c, DomModType::Level, 2, 1);
		lp.addDomHeuristic(c, DomModType::Init, 10, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getLiteral(c).var()) != value_free);

		s.undoUntil(0);
		CPPUNIT_ASSERT(lp.updateProgram());
		lp.addDomHeuristic(b, DomModType::Init, 20, 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getLiteral(c).var()) != value_free);
	}
	void testDomEqVarDiffLevelCond() {
		SharedContext ctx;
		ctx.master()->setHeuristic(new DomainHeuristic, Ownership_t::Acquire);
		Solver& s = *ctx.master();
		Var a = 1, b = 2, c = 3, d = 4;
		lp.start(ctx);
		lpAdd(lp, "{a;b;c;d}. b :- a.");
		lp.addDomHeuristic(b, DomModType::Init, 40, 1);
		lp.addDomHeuristic(d, DomModType::Init, 50, 1);
		lp.addDomHeuristic(d, DomModType::Sign, 1, 1);
		lp.addDomHeuristic(a, DomModType::True, 2, 1, d);
		lp.addDomHeuristic(c, DomModType::True, 2, 1, d);
		lp.addDomHeuristic(c, DomModType::Init, 30, 1);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(s.decideNextBranch() && s.isTrue(lp.getLiteral(d)));
		s.propagate();
		CPPUNIT_ASSERT(s.decideNextBranch() && s.value(lp.getLiteral(c).var()) != value_free);
	}
};

CPPUNIT_TEST_SUITE_REGISTRATION(DecisionHeuristicTest);

} }
clasp-3.2.2/libclasp/tests/dependency_graph_test.cpp000066400000000000000000000304021304134206100226060ustar00rootroot00000000000000//
// Copyright (c) 2009, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
namespace Clasp { namespace Test {
using namespace Clasp::Asp;
class DependencyGraphTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(DependencyGraphTest);
	CPPUNIT_TEST(testTightProgram);
	CPPUNIT_TEST(testInitOrder);
	CPPUNIT_TEST(testProgramWithLoops);
	CPPUNIT_TEST(testWithSimpleCardinalityConstraint);
	CPPUNIT_TEST(testWithSimpleWeightConstraint);
	CPPUNIT_TEST(testIgnoreAtomsFromPrevSteps);
	CPPUNIT_TEST_SUITE_END();
public:
	DependencyGraphTest() {
	}
	void setUp() {
		ctx = new SharedContext();
	}
	void tearDown() {
		delete ctx;
	}
	void testTightProgram() {
		lp.start(*ctx);
		lpAdd(lp, "x1 :- not x2.");
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.stats.sccs == 0);
		CPPUNIT_ASSERT(ctx->sccGraph.get() == 0);
	}

	void testInitOrder() {
		lp.start(*ctx, LogicProgram::AspOptions().noEq());
		lpAdd(lp,
			"x4 :- x3.\n"
			"x3 :- x4.\n"
			"x2 :- x3.\n"
			"x2 :- x1.\n"
			"x1 :- x2.\n"
			"x3 :- not a.\n");
		lp.endProgram();

		CPPUNIT_ASSERT_EQUAL(true, lp.stats.sccs == 2);

		DG* graph = ctx->sccGraph.get();

		CPPUNIT_ASSERT_EQUAL(uint32(10), graph->nodes());

		const DG::AtomNode& b = graph->getAtom(lp.getAtom(2)->id());
		const DG::AtomNode& x = graph->getAtom(lp.getAtom(3)->id());

		CPPUNIT_ASSERT(graph->getBody(b.body(0)).scc != b.scc);
		CPPUNIT_ASSERT(graph->getBody(b.body(1)).scc == b.scc);
		CPPUNIT_ASSERT(b.bodies_begin()+2 == b.bodies_end());

		CPPUNIT_ASSERT(graph->getBody(x.body(0)).scc != x.scc);
		CPPUNIT_ASSERT(graph->getBody(x.body(1)).scc == x.scc);
		CPPUNIT_ASSERT(x.bodies_begin()+2 == x.bodies_end());

		const DG::BodyNode& xBody = graph->getBody(b.body(0));
		CPPUNIT_ASSERT(graph->getAtom(xBody.heads_begin()[0]).scc == xBody.scc);
		CPPUNIT_ASSERT(graph->getAtom(xBody.heads_begin()[1]).scc != xBody.scc);
		CPPUNIT_ASSERT(xBody.heads_begin()+2 == xBody.heads_end());
	}

	void testProgramWithLoops() {
		lpAdd(lp.start(*ctx),
			"a :- not f.\n"
			"b :- a.\n"
			"a :- b, d.\n"
			"b :- not e.\n"
			"c :- f.\n"
			"d :- c.\n"
			"c :- d.\n"
			"d :- not e.\n"
			"g :- not e.\n"
			"f :- g.\n"
			"e :- not g.\n");
		lp.endProgram();

		DG* graph = ctx->sccGraph.get();
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(6), lp.getLiteral(7));
		CPPUNIT_ASSERT_EQUAL(~lp.getLiteral(6), lp.getLiteral(5));

		CPPUNIT_ASSERT( graph->getAtom(lp.getAtom(1)->id()).scc == 0 );
		CPPUNIT_ASSERT( graph->getAtom(lp.getAtom(2)->id()).scc == 0 );
		CPPUNIT_ASSERT( graph->getAtom(lp.getAtom(3)->id()).scc == 1 );
		CPPUNIT_ASSERT( graph->getAtom(lp.getAtom(4)->id()).scc == 1 );
		CPPUNIT_ASSERT( lp.getAtom(5)->id() == PrgNode::noNode );
		CPPUNIT_ASSERT( lp.getAtom(6)->eq() || lp.getAtom(6)->id() == PrgNode::noNode );
		CPPUNIT_ASSERT( lp.getAtom(7)->id() == PrgNode::noNode );

		CPPUNIT_ASSERT(uint32(11) == graph->nodes());
		// check that lists are partitioned by component number
		const DG::AtomNode& a =  graph->getAtom(lp.getAtom(1)->id());
		CPPUNIT_ASSERT(graph->getBody(a.body(0)).scc == PrgNode::noScc);
		CPPUNIT_ASSERT(graph->getBody(a.body(1)).scc == a.scc);
		CPPUNIT_ASSERT(a.bodies_begin()+2 == a.bodies_end());
		CPPUNIT_ASSERT_EQUAL(true, ctx->varInfo(a.lit.var()).frozen());

		const DG::BodyNode& bd = graph->getBody(a.body(1));
		CPPUNIT_ASSERT_EQUAL(true, ctx->varInfo(bd.lit.var()).frozen());
		CPPUNIT_ASSERT(graph->getAtom(bd.preds()[0]).lit == lp.getLiteral(2));
		CPPUNIT_ASSERT(bd.preds()[1]== idMax);
		CPPUNIT_ASSERT(bd.heads_begin()[0] == graph->id(a));
		CPPUNIT_ASSERT(bd.heads_begin()+1 == bd.heads_end());
	}

	void testWithSimpleCardinalityConstraint() {
		lpAdd(lp.start(*ctx),
			"{x2}.\n"
			"x1 :- 1 {x1, x2}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		DG* graph = ctx->sccGraph.get();
		CPPUNIT_ASSERT( uint32(3) == graph->nodes() );
		const DG::AtomNode& a    = graph->getAtom(lp.getAtom(1)->id());
		const DG::BodyNode& body = graph->getBody(a.body(0));

		CPPUNIT_ASSERT(body.num_preds() == 2);
		CPPUNIT_ASSERT(body.extended());
		CPPUNIT_ASSERT(body.ext_bound() == 1);
		CPPUNIT_ASSERT(body.pred_inc() == 1);
		CPPUNIT_ASSERT(body.preds()[0] == graph->id(a));
		CPPUNIT_ASSERT(body.preds()[1] == idMax);
		CPPUNIT_ASSERT(body.preds()[2] == lp.getLiteral(2).rep());
		CPPUNIT_ASSERT(body.preds()[3] == idMax);
		CPPUNIT_ASSERT(body.pred_weight(0,false) == 1);
		CPPUNIT_ASSERT(body.pred_weight(1,true) == 1);

		CPPUNIT_ASSERT(a.inExtended());
		CPPUNIT_ASSERT(a.succs()[0] == idMax);
		CPPUNIT_ASSERT(a.succs()[1] == a.body(0));
		CPPUNIT_ASSERT(a.succs()[2] == 0);
		CPPUNIT_ASSERT(a.succs()[3] == idMax);
	}

	void testWithSimpleWeightConstraint() {
		lpAdd(lp.start(*ctx),
			"{x2;x3}.\n"
			"x1 :- 2 {x1 = 2, x2 = 2, x3 = 1}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		DG* graph = ctx->sccGraph.get();
		CPPUNIT_ASSERT( uint32(3) == graph->nodes() );

		const DG::AtomNode& a    = graph->getAtom(lp.getAtom(1)->id());
		const DG::BodyNode& body = graph->getBody(a.body(0));

		CPPUNIT_ASSERT(body.num_preds() == 3);
		CPPUNIT_ASSERT(body.extended());
		CPPUNIT_ASSERT(body.ext_bound() == 2);
		CPPUNIT_ASSERT(body.pred_inc() == 2);
		CPPUNIT_ASSERT(body.preds()[0] == graph->id(a));
		CPPUNIT_ASSERT(body.preds()[2] == idMax);
		CPPUNIT_ASSERT(body.preds()[3] == lp.getLiteral(2).rep());
		CPPUNIT_ASSERT(body.preds()[5] == lp.getLiteral(3).rep());
		CPPUNIT_ASSERT(body.preds()[7] == idMax);
		CPPUNIT_ASSERT(body.pred_weight(0, false) == 2);
		CPPUNIT_ASSERT(body.pred_weight(1, true) == 2);
		CPPUNIT_ASSERT(body.pred_weight(2, true) == 1);

		CPPUNIT_ASSERT(a.inExtended());
		CPPUNIT_ASSERT(a.succs()[0] == idMax);
		CPPUNIT_ASSERT(a.succs()[1] == a.body(0));
		CPPUNIT_ASSERT(a.succs()[2] == 0);
		CPPUNIT_ASSERT(a.succs()[3] == idMax);
	}

	void testIgnoreAtomsFromPrevSteps() {
		lp.start(*ctx, LogicProgram::AspOptions().noEq());
		lp.updateProgram();
		lpAdd(lp,
			"{x1;x2;x3}.\n"
			"x4 :- x5.\n"
			"x5 :- x4.\n"
			"x4 :- x1.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		DG* graph  = ctx->sccGraph.get();
		uint32 nA  = lp.getAtom(4)->id();
		{
			const DG::AtomNode& a = graph->getAtom(nA);
			CPPUNIT_ASSERT(std::distance(a.bodies_begin(), a.bodies_end()) == 2);
		}

		lp.update();
		lpAdd(lp,
			"x6|x7.\n"
			"x7 :- x6.\n"
			"x6 :- x7.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		{
			const DG::AtomNode& a = graph->getAtom(nA);
			CPPUNIT_ASSERT(std::distance(a.bodies_begin(), a.bodies_end()) == 2);
		}
		const DG::AtomNode& c = graph->getAtom(lp.getAtom(6)->id());
		CPPUNIT_ASSERT(std::distance(c.bodies_begin(), c.bodies_end()) == 2);
	}
private:
	typedef Asp::PrgDepGraph DG;
	SharedContext* ctx;
	LogicProgram   lp;
};
CPPUNIT_TEST_SUITE_REGISTRATION(DependencyGraphTest);

class AcycGraphTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(AcycGraphTest);
	CPPUNIT_TEST(testSelfLoop);
	CPPUNIT_TEST(testSimpleLoop);
	CPPUNIT_TEST(testNoOutgoingEdge);
	CPPUNIT_TEST(testLogicProgram);
	CPPUNIT_TEST(testIncrementalOnlyNew);
	CPPUNIT_TEST(testIncrementalExtend);
	CPPUNIT_TEST_SUITE_END();
public:
	AcycGraphTest() {}
	void testSelfLoop() {
		SharedContext ctx;
		Literal x1 = posLit(ctx.addVar(Var_t::Atom));
		ExtDepGraph graph;
		graph.addEdge(x1, 0, 0);
		graph.finalize(ctx);
		ctx.startAddConstraints();
		AcyclicityCheck* check;
		ctx.master()->addPost(check = new AcyclicityCheck(&graph));
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->isFalse(x1));
	}
	void testSimpleLoop() {
		SharedContext ctx;
		Literal x1 = posLit(ctx.addVar(Var_t::Atom));
		Literal x2 = posLit(ctx.addVar(Var_t::Atom));
		ExtDepGraph graph;
		graph.addEdge(x1, 0, 1);
		graph.addEdge(x2, 1, 0);
		graph.finalize(ctx);
		ctx.startAddConstraints();
		AcyclicityCheck* check;
		ctx.master()->addPost(check = new AcyclicityCheck(&graph));
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->topValue(x1.var()) == value_free);
		CPPUNIT_ASSERT(ctx.master()->topValue(x2.var()) == value_free);
		CPPUNIT_ASSERT(ctx.master()->hasWatch(x1, check));
		CPPUNIT_ASSERT(ctx.master()->hasWatch(x2, check));
		CPPUNIT_ASSERT(ctx.master()->assume(x1) && ctx.master()->propagate());

		CPPUNIT_ASSERT(ctx.master()->isFalse(x2));
		ctx.master()->removePost(check);
		check->destroy(ctx.master(), true);
		CPPUNIT_ASSERT(!ctx.master()->hasWatch(x1, check));
		CPPUNIT_ASSERT(!ctx.master()->hasWatch(x2, check));
	}
	void testNoOutgoingEdge() {
		SharedContext ctx;
		Literal x1 = posLit(ctx.addVar(Var_t::Atom));
		Literal x2 = posLit(ctx.addVar(Var_t::Atom));
		ExtDepGraph graph;
		graph.addEdge(x1, 0, 1);
		graph.finalize(ctx);
		ctx.startAddConstraints();
		AcyclicityCheck* check;
		ctx.master()->addPost(check = new AcyclicityCheck(&graph));
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->assume(x1) && ctx.master()->propagate());

		CPPUNIT_ASSERT(!ctx.master()->isFalse(x2));
		ctx.master()->removePost(check);
		check->destroy(ctx.master(), true);
		CPPUNIT_ASSERT(!ctx.master()->hasWatch(x1, check));
	}
	void testLogicProgram() {
		SharedContext     ctx;
		Asp::LogicProgram lp;
		lpAdd(lp.start(ctx),
			"{x1;x2}.\n"
			"x3 :- x1.\n"
			"x4 :- x2.\n"
			"#edge (0,1) : x3.\n"
			"#edge (1,0) : x4.\n"
			"% ignore because x5 is false\n"
			"#edge (1,0) : x5.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.extGraph.get() && ctx.extGraph->nodes() == 2);
		AcyclicityCheck* check;
		ctx.master()->addPost(check = new AcyclicityCheck(0));
		CPPUNIT_ASSERT(ctx.endInit());

		ctx.master()->assume(lp.getLiteral(1));
		ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(2)));
	}

	void testIncrementalOnlyNew() {
		SharedContext     ctx;
		Asp::LogicProgram lp;
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"{x1;x2}.\n"
			"#edge (0,1) : x1.\n"
			"#edge (1,0) : x2.\n");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());

		AcyclicityCheck* check;
		ctx.master()->addPost(check = new AcyclicityCheck(0));
		CPPUNIT_ASSERT(ctx.endInit());

		lp.updateProgram();
		lpAdd(lp,
			"{x3;x4}.\n"
			"#edge (2,3) : x3.\n"
			"#edge (3,2) : x4.\n");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.extGraph.get() && ctx.extGraph->nodes() == 4);
		CPPUNIT_ASSERT(ctx.endInit());
		Literal lit = lp.getLiteral(3);
		CPPUNIT_ASSERT(ctx.master()->hasWatch(lit, check));
	}

	void testIncrementalExtend() {
		SharedContext     ctx;
		Asp::LogicProgram lp;
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"{x1;x2}.\n"
			"#edge (1,2) : x1.\n"
			"#edge (2,1) : x2.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());

		AcyclicityCheck* check;
		ctx.master()->addPost(check = new AcyclicityCheck(0));
		CPPUNIT_ASSERT(ctx.endInit());

		lp.updateProgram();
		lpAdd(lp, "{x3;x4;x5;x6;x7}.\n"
			"#edge (2,3) : x3.\n"
			"#edge (3,4) : x4.\n"
			"#edge (4,1) : x5.\n"
			"#edge (1,5) : x6.\n"
			"#edge (5,3) : x7.\n");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.extGraph.get() && ctx.extGraph->edges() == 7);
		CPPUNIT_ASSERT(ctx.endInit());
		Var x1 =1, x2 = 2, x3 = 3, x4 = 4, x5 = 5, x6 = 6, x7 = 7;
		Solver& s = *ctx.master();
		CPPUNIT_ASSERT(s.assume(lp.getLiteral(x1)) && s.propagate());
		CPPUNIT_ASSERT(s.isFalse(lp.getLiteral(x2)));
		CPPUNIT_ASSERT(s.assume(lp.getLiteral(x3)) && s.propagate());
		CPPUNIT_ASSERT(s.assume(lp.getLiteral(x4)) && s.propagate());
		CPPUNIT_ASSERT(s.isFalse(lp.getLiteral(x5)));
		s.undoUntil(0);
		CPPUNIT_ASSERT(s.assume(lp.getLiteral(x4)) && s.propagate());
		CPPUNIT_ASSERT(s.assume(lp.getLiteral(x7)) && s.propagate());
		CPPUNIT_ASSERT(s.assume(lp.getLiteral(x5)) && s.propagate());
		CPPUNIT_ASSERT(s.isFalse(lp.getLiteral(x6)));
	}
private:
	typedef ExtDepGraph DG;
};
CPPUNIT_TEST_SUITE_REGISTRATION(AcycGraphTest);
} }
clasp-3.2.2/libclasp/tests/dlp_builder_test.cpp000066400000000000000000000263051304134206100216030ustar00rootroot00000000000000//
// Copyright (c) 2012, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
#include 
#include 
using namespace std;
namespace Clasp { namespace Test {
using namespace Clasp::Asp;
class DlpBuilderTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(DlpBuilderTest);
	CPPUNIT_TEST(testSimpleChoice);
	CPPUNIT_TEST(testNotAChoice);
	CPPUNIT_TEST(testStillAChoice);
	CPPUNIT_TEST(testSubsumedChoice);
	CPPUNIT_TEST(testSubsumedByChoice);
	CPPUNIT_TEST(testChoiceDisjBug);
	CPPUNIT_TEST(testTautOverOne);
	CPPUNIT_TEST(testSimpleLoop);
	CPPUNIT_TEST(testSimpleLoopNoGamma);
	CPPUNIT_TEST(testComputeTrue);
	CPPUNIT_TEST(testComputeFalse);
	CPPUNIT_TEST(testIncremental);
	CPPUNIT_TEST(testSimplify);
	CPPUNIT_TEST(testSimplifyNoRemove);

	CPPUNIT_TEST(testNoDupGamma);
	CPPUNIT_TEST(testPreNoGamma);
	CPPUNIT_TEST(testPreNoGamma2);
	CPPUNIT_TEST(testRecAgg);
	CPPUNIT_TEST(testPropagateSource);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
		a = 1, b = 2, c = 3, d = 4, e = 5, f = 6;
	}
	void tearDown(){
		ctx.reset();
	}
	void testSimpleChoice() {
		lpAdd(lp.start(ctx), "a | b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(lp.getLiteral(a) != lp.getLiteral(b));
		ctx.master()->assume(lp.getLiteral(a)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
		ctx.master()->undoUntil(0);
		ctx.master()->assume(lp.getLiteral(b)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(a)));
	}
	void testNotAChoice() {
		lpAdd(lp.start(ctx), "a | b. a :- not c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(lp.getLiteral(b) == lp.getLiteral(c));
		CPPUNIT_ASSERT(lp.getLiteral(a) == lit_true());
	}

	void testStillAChoice() {
		lpAdd(lp.start(ctx), "a|b. {b}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(lp.getLiteral(a) != lp.getLiteral(b));
		ctx.master()->assume(lp.getLiteral(a)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
		ctx.master()->undoUntil(0);
		ctx.master()->assume(lp.getLiteral(b)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(a)));
	}

	void testSubsumedChoice() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().iterations(-1)),
			"a | b.\n"
			"a | b | c | d.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 2);
		CPPUNIT_ASSERT(lp.getLiteral(c) == lit_false() || !(ctx.master()->assume(lp.getLiteral(c)) && ctx.master()->propagate()));
		ctx.master()->undoUntil(0);
		CPPUNIT_ASSERT(lp.getLiteral(d) == lit_false() || !(ctx.master()->assume(lp.getLiteral(d)) && ctx.master()->propagate()));
	}

	void testSubsumedByChoice() {
		lpAdd(lp.start(ctx),
			"a | b.\n"
			"{a,b}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		ctx.master()->assume(~lp.getLiteral(a)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(b)));
	}
	void testChoiceDisjBug() {
		lpAdd(lp.start(ctx),
			"a | b.\n"
			"{a,b,b}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);

		ctx.master()->assume(lp.getLiteral(c)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->value(lp.getLiteral(a).var()) == value_free);
		CPPUNIT_ASSERT(ctx.master()->value(lp.getLiteral(b).var()) == value_free);
		ctx.master()->assume(~lp.getLiteral(a)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(b)));
		ctx.master()->undoUntil(0);
		ctx.master()->assume(lp.getLiteral(a)) && ctx.master()->propagate();
		ctx.master()->assume(lp.getLiteral(b)) && ctx.master()->propagate();
		ctx.master()->assume(lp.getLiteral(c)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(!ctx.master()->hasConflict() && ctx.master()->numFreeVars() == 0);
	}

	void testTautOverOne() {
		lpAdd(lp.start(ctx),
			"{b}.\n"
			"c :- b.\n"
			"a | b :- c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);

		CPPUNIT_ASSERT(lp.getLiteral(a) == lit_false() && !(ctx.master()->assume(lp.getLiteral(a)) && ctx.master()->propagate()));
	}

	void testSimpleLoop() {
		lpAdd(lp.start(ctx),
			"a | b."
			"a :- b."
			"b :- a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.sccGraph.get());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		ctx.master()->addPost(new DefaultUnfoundedCheck(*ctx.sccGraph));
		CPPUNIT_ASSERT_EQUAL(true, ctx.endInit());

		CPPUNIT_ASSERT(lp.getLiteral(a) != lp.getLiteral(b));
		CPPUNIT_ASSERT(ctx.master()->assume(lp.getLiteral(a)) && ctx.master()->propagate());
		CPPUNIT_ASSERT(!ctx.master()->isFalse(lp.getLiteral(b)));
		ctx.master()->undoUntil(0);
		CPPUNIT_ASSERT(ctx.master()->assume(lp.getLiteral(b)) && ctx.master()->propagate());
		CPPUNIT_ASSERT(!ctx.master()->isFalse(lp.getLiteral(a)));
	}

	void testSimpleLoopNoGamma() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().disableGamma()),
			"a | b.\n"
			"a :- b.\n"
			"b :- a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);

		CPPUNIT_ASSERT(!(ctx.master()->assume(~lp.getLiteral(a)) && ctx.master()->propagate()) || ctx.master()->isTrue(lp.getLiteral(b)));
	}
	void testComputeTrue() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noScc()),
			"a | b.\n"
			"a :- b.\n"
			":- not a.\n");
		CPPUNIT_ASSERT(lp.getAtom(a)->value() == value_true);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);

		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
	}
	void testComputeFalse() {
		lpAdd(lp.start(ctx),
			"a | b | c.\n"
			"a :- c.\n"
			" :- a.");
		CPPUNIT_ASSERT(lp.getAtom(a)->value() == value_false);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);

		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(a)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(c)));
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(b)));
	}
	void testIncremental() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"% Step 0:\n"
			"a | b :- c.\n"
			"a :- b.\n"
			"b :- a.\n"
			"#external c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		CPPUNIT_ASSERT(lp.stats.nonHcfs == 1);

		lp.update();
		lpAdd(lp,
			"% Step 1:\n"
			"d | e :- a, f.\n"
			"d :- e, b.\n"
			"e :- d, a.\n"
			"#external f.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		CPPUNIT_ASSERT(lp.stats.nonHcfs == 1);
	}

	void testSimplify() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"a | b :- d.\n"
			"a :- b.\n"
			"b :- c.\n"
			"c :- a,e.\n"
			"{d,e}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		CPPUNIT_ASSERT(lp.stats.nonHcfs == 1);
		DG& graph = *ctx.sccGraph;
		CPPUNIT_ASSERT(graph.numNonHcfs() == 1);
		ctx.addUnary(~lp.getLiteral(a));
		ctx.master()->propagate();
		graph.simplify(*ctx.master());
		CPPUNIT_ASSERT(graph.numNonHcfs() == 0);
	}
	void testSimplifyNoRemove() {
		ctx.setConcurrency(2);
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"a | b :- d.\n"
			"a :- b.\n"
			"b :- c.\n"
			"c :- a,e.\n"
			"{d,e}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		Solver& s2= ctx.pushSolver();
		CPPUNIT_ASSERT(ctx.endInit(true));
		DG& graph = *ctx.sccGraph;
		CPPUNIT_ASSERT(graph.numNonHcfs() == 1);
		Literal u = ~lp.getLiteral(a);
		ctx.master()->add(ClauseRep::create(&u, 1, Constraint_t::Conflict));
		ctx.master()->simplify() && s2.simplify();
		graph.simplify(*ctx.master());
		graph.simplify(s2);
		CPPUNIT_ASSERT(graph.numNonHcfs() == 1);
		const DG::NonHcfComponent* c = *graph.nonHcfBegin();

		LitVec temp;
		VarVec ufs;
		c->assumptionsFromAssignment(*ctx.master(), temp);
		CPPUNIT_ASSERT_EQUAL(true, c->test(*ctx.master(), temp, ufs) && ufs.empty());

		temp.clear();
		c->assumptionsFromAssignment(s2, temp);
		CPPUNIT_ASSERT_EQUAL(true, c->test(s2, temp, ufs) && ufs.empty());
	}
	void testNoDupGamma() {
		lpAdd(lp.start(ctx),
			"a | b.\n"
			"a :- b.\n"
			"b :- a.\n"
			"a :- not b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.numBodies() == 5); // + b :- not a.
		CPPUNIT_ASSERT(lp.stats.gammas == 1);
		std::stringstream exp("1 1 1 1 2\n1 1 1 1 2");
		CPPUNIT_ASSERT_EQUAL(false, findSmodels(exp, lp));
	}
	void testPreNoGamma() {
		lpAdd(lp.start(ctx),
			"a | b.\n"
			"a :- b.\n"
			"b :- a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		std::stringstream exp("1 1 1 1 2");
		CPPUNIT_ASSERT_EQUAL(false, findSmodels(exp, lp));
	}
	void testPreNoGamma2() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().disableGamma()),
			"a | b.\n"
			"a :- b.\n"
			"b :- a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		std::stringstream exp("3 2 1 2 0 0");
		CPPUNIT_ASSERT_EQUAL(false, findSmodels(exp, lp));
	}
	void testRecAgg() {
		lpAdd(lp.start(ctx),
			"{c}.\n"
			"a | b.\n"
			"a :- 1 {c, b}.\n"
			"b :- 1 {c, a}.");
		CPPUNIT_ASSERT(lp.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(lp.stats.bodies[0][Body_t::Count] == 2);
		std::stringstream exp("2 2 2 0 1 3 1");
		CPPUNIT_ASSERT_EQUAL(true, findSmodels(exp, lp));
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		exp.clear(); exp.seekg(0);
		std::stringstream str;
		AspParser::write(lp, str, AspParser::format_smodels);
		CPPUNIT_ASSERT_EQUAL(false, findProgram(exp, str));
		exp.clear();  exp.str("");
		str.clear(); str.seekg(0);
		exp << "1 1 1 0 3\n" << "1 2 1 0 3\n";
		CPPUNIT_ASSERT_EQUAL(true, findProgram(exp, str));
	}
	void testPropagateSource() {
		lpAdd(lp.start(ctx),
			"d; c.\n"
			"b; a:-c.\n"
			"b; a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.getLiteral(a) != lp.getLiteral(b));
		CPPUNIT_ASSERT(lp.getLiteral(b) != lp.getLiteral(c));
		CPPUNIT_ASSERT(lp.getLiteral(c) != lp.getLiteral(d));
	}
private:
	typedef Asp::PrgDepGraph DG;
	SharedContext ctx;
	LogicProgram  lp;
	Var           a, b, c, d, e, f;
};
CPPUNIT_TEST_SUITE_REGISTRATION(DlpBuilderTest);
 } }

clasp-3.2.2/libclasp/tests/enumerator_test.cpp000066400000000000000000000332631304134206100215000ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
namespace Clasp { namespace Test {
using namespace Clasp::Asp;
class EnumeratorTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(EnumeratorTest);
	CPPUNIT_TEST(testProjectToOutput);
	CPPUNIT_TEST(testProjectExplicit);

	CPPUNIT_TEST(testMiniProject);
	CPPUNIT_TEST(testProjectBug);
	CPPUNIT_TEST(testProjectRestart);
	CPPUNIT_TEST(testProjectWithBacktracking);
	CPPUNIT_TEST(testTerminateRemovesWatches);
	CPPUNIT_TEST(testParallelRecord);
	CPPUNIT_TEST(testParallelUpdate);
	CPPUNIT_TEST(testTagLiteral);
	CPPUNIT_TEST(testIgnoreTagLiteralInPath);
	CPPUNIT_TEST(testSplittable);
	CPPUNIT_TEST(testLearnStepLiteral);
	CPPUNIT_TEST(testAssignStepLiteral);
	CPPUNIT_TEST_SUITE_END();
public:
	void testProjectToOutput() {
		SharedContext ctx;
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Atom);
		Var v3 = ctx.addVar(Var_t::Atom);
		ctx.output.add("a", posLit(v1));
		ctx.output.add("_aux", posLit(v2));
		ctx.output.add("b", posLit(v3));
		ctx.startAddConstraints();
		ModelEnumerator e;
		e.setStrategy(ModelEnumerator::strategy_backtrack, ModelEnumerator::project_enable_simple, '_');
		e.init(ctx);
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.output.projectMode() == OutputTable::project_output);
		CPPUNIT_ASSERT(e.project(v1));
		CPPUNIT_ASSERT(e.project(v3));

		ctx.detach(0);
	}
	void testProjectExplicit() {
		SharedContext ctx;
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Atom);
		Var v3 = ctx.addVar(Var_t::Atom);
		ctx.output.add("a", posLit(v1));
		ctx.output.add("_aux", posLit(v2));
		ctx.output.add("b", posLit(v3));
		ctx.output.addProject(posLit(v2));
		ctx.output.addProject(posLit(v3));
		CPPUNIT_ASSERT(ctx.output.projectMode() == OutputTable::project_explicit);

		ctx.startAddConstraints();
		ModelEnumerator e;
		e.setStrategy(ModelEnumerator::strategy_backtrack, ModelEnumerator::project_enable_simple, '_');
		e.init(ctx);
		ctx.endInit();
		CPPUNIT_ASSERT(!e.project(v1));
		CPPUNIT_ASSERT(e.project(v2));
		CPPUNIT_ASSERT(e.project(v3));
		ctx.detach(0);
	}
	void testMiniProject() {
		SharedContext ctx;
		Solver& solver = *ctx.master();
		lpAdd(builder.start(ctx, LogicProgram::AspOptions().noEq().noScc()),
			"{x1;x2;x3}.\n"
			"x3 :- not x1.\n"
			"x3 :- not x2.\n"
			"#minimize{x3}.");
		builder.addOutput("a", 1);
		builder.addOutput("b", 2);
		builder.addOutput("_ignore_in_project", 3);
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		ModelEnumerator e;
		e.setStrategy(ModelEnumerator::strategy_backtrack, ModelEnumerator::project_enable_simple);
		e.init(ctx);
		ctx.endInit();

		solver.assume(builder.getLiteral(1));
		solver.propagate();
		solver.assume(builder.getLiteral(2));
		solver.propagate();
		solver.assume(builder.getLiteral(3));
		solver.propagate();
		CPPUNIT_ASSERT(solver.numVars() == solver.numAssignedVars());
		e.commitModel(solver);
		bool ok = e.update(solver) && solver.propagate();
		CPPUNIT_ASSERT(!ok);
		solver.backtrack();
		CPPUNIT_ASSERT(false == solver.propagate() && !solver.resolveConflict());
	}

	void testProjectBug() {
		SharedContext ctx;
		Solver& solver = *ctx.master();
		lpAdd(builder.start(ctx, LogicProgram::AspOptions().noEq().noScc()),
			"{x1;x2;x4}.\n"
			"x5 :- x1, x4.\n"
			"x6 :- x2, x4.\n"
			"x3 :- x5, x6.\n");
		Var x = 1, y = 2, z = 3, _p = 4;
		builder.addOutput("x", x).addOutput("y", y).addOutput("z", z).addOutput("_p", _p);
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		ModelEnumerator e;
		e.setStrategy(ModelEnumerator::strategy_backtrack, ModelEnumerator::project_enable_full);
		e.init(ctx);
		ctx.endInit();

		solver.assume(builder.getLiteral(x));
		solver.propagate();
		solver.assume(builder.getLiteral(y));
		solver.propagate();
		solver.assume(builder.getLiteral(_p));
		solver.propagate();
		CPPUNIT_ASSERT(solver.numVars() == solver.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, e.commitModel(solver) && e.update(solver));

		solver.undoUntil(0);
		uint32 numT = 0;
		if (solver.value(builder.getLiteral(x).var()) == value_free) {
			solver.assume(builder.getLiteral(x)) && solver.propagate();
			++numT;
		}
		else if (solver.isTrue(builder.getLiteral(x))) {
			++numT;
		}
		if (solver.value(builder.getLiteral(y).var()) == value_free) {
			solver.assume(builder.getLiteral(y)) && solver.propagate();
			++numT;
		}
		else if (solver.isTrue(builder.getLiteral(y))) {
			++numT;
		}
		if (solver.value(builder.getLiteral(_p).var()) == value_free) {
			solver.assume(builder.getLiteral(_p)) && solver.propagate();
		}
		if (solver.isTrue(builder.getLiteral(z))) {
			++numT;
		}
		CPPUNIT_ASSERT(numT < 3);
	}

	void testProjectRestart() {
		SharedContext ctx;
		Solver& solver = *ctx.master();
		lpAdd(builder.start(ctx, LogicProgram::AspOptions().noEq().noScc()), "{x1;x2;x3}.");
		builder.addOutput("a", 1).addOutput("b", 2);
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		ModelEnumerator e;
		e.setStrategy(ModelEnumerator::strategy_backtrack, ModelEnumerator::project_enable_full);
		e.init(ctx);
		ctx.endInit();


		solver.assume(builder.getLiteral(1));
		solver.propagate();
		solver.assume(builder.getLiteral(2));
		solver.propagate();
		solver.assume(builder.getLiteral(3));
		solver.propagate();
		solver.strategies().restartOnModel = true;
		CPPUNIT_ASSERT(solver.numVars() == solver.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, e.commitModel(solver));
		CPPUNIT_ASSERT_EQUAL(true, e.update(solver));
		CPPUNIT_ASSERT(solver.isFalse(builder.getLiteral(2)));
	}
	void testProjectWithBacktracking() {
		SharedContext ctx;
		Solver& solver = *ctx.master();
		lpAdd(builder.start(ctx, LogicProgram::AspOptions().noEq().noScc()),
			"{x1, x2, x3}."
			"#output a : x1.");
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		ModelEnumerator e;
		e.setStrategy(ModelEnumerator::strategy_backtrack, ModelEnumerator::project_enable_full);
		e.init(ctx);
		ctx.endInit();

		solver.assume(builder.getLiteral(2));
		solver.propagate();
		solver.assume(builder.getLiteral(3));
		solver.propagate();
		// x2@1 -x3
		solver.backtrack();
		// x1@1 -x3 a@2
		solver.assume(builder.getLiteral(1));
		solver.propagate();
		CPPUNIT_ASSERT(solver.numVars() == solver.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, e.commitModel(solver));
		e.update(solver);
		solver.undoUntil(0);
		while (solver.backtrack()) { ; }
		CPPUNIT_ASSERT(solver.isFalse(builder.getLiteral(1)));
	}
	void testTerminateRemovesWatches() {
		SharedContext ctx; Solver& solver = *ctx.master();
		lpAdd(builder.start(ctx, LogicProgram::AspOptions().noEq().noScc()), "{x1;x2;x3;x4}.");
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		ModelEnumerator e(ModelEnumerator::strategy_record);
		e.init(ctx);
		CPPUNIT_ASSERT_EQUAL(true, ctx.endInit());


		solver.assume(builder.getLiteral(1)) && solver.propagate();
		solver.assume(builder.getLiteral(2)) && solver.propagate();
		solver.assume(builder.getLiteral(3)) && solver.propagate();
		solver.assume(builder.getLiteral(4)) && solver.propagate();
		CPPUNIT_ASSERT_EQUAL(uint32(0), solver.numFreeVars());
		e.commitModel(solver) && e.update(solver);
		uint32 numW = solver.numWatches(builder.getLiteral(1)) + solver.numWatches(builder.getLiteral(2)) + solver.numWatches(builder.getLiteral(3)) + solver.numWatches(builder.getLiteral(4));
		CPPUNIT_ASSERT(numW > 0);
		ctx.detach(solver);
		numW = solver.numWatches(builder.getLiteral(1)) + solver.numWatches(builder.getLiteral(2)) + solver.numWatches(builder.getLiteral(3)) + solver.numWatches(builder.getLiteral(4));
		CPPUNIT_ASSERT(numW == 0);
	}

	void testParallelRecord() {
		SharedContext ctx; Solver& solver = *ctx.master();
		lpAdd(builder.start(ctx, LogicProgram::AspOptions().noEq().noScc()), "{x1;x2;x3;x4}.");
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		ctx.setConcurrency(2);
		ModelEnumerator e(ModelEnumerator::strategy_record);
		e.init(ctx);
		Solver& solver2 = ctx.pushSolver();
		ctx.endInit(true);

		solver.assume(builder.getLiteral(1)) && solver.propagate();
		solver.assume(builder.getLiteral(2)) && solver.propagate();
		solver.assume(builder.getLiteral(3)) && solver.propagate();
		solver.assume(builder.getLiteral(4)) && solver.propagate();
		CPPUNIT_ASSERT_EQUAL(uint32(0), solver.numFreeVars());
		e.commitModel(solver) && e.update(solver);
		solver.undoUntil(0);

		CPPUNIT_ASSERT_EQUAL(true, e.update(solver2));

		solver2.assume(builder.getLiteral(1)) && solver2.propagate();
		solver2.assume(builder.getLiteral(2)) && solver2.propagate();
		solver2.assume(builder.getLiteral(3)) && solver2.propagate();
		CPPUNIT_ASSERT(solver2.isFalse(builder.getLiteral(4)) && solver2.propagate());
		CPPUNIT_ASSERT_EQUAL(uint32(0), solver2.numFreeVars());
		e.commitModel(solver2) && e.update(solver2);
		solver.undoUntil(0);

		CPPUNIT_ASSERT_EQUAL(true, e.update(solver));

		solver.assume(builder.getLiteral(1)) && solver.propagate();
		solver.assume(builder.getLiteral(2)) && solver.propagate();
		CPPUNIT_ASSERT(solver.isFalse(builder.getLiteral(3)));

		ctx.detach(solver2);
		ctx.detach(solver);
		solver2.undoUntil(0);
		ctx.attach(solver2);
		solver2.assume(builder.getLiteral(1)) && solver2.propagate();
		solver2.assume(builder.getLiteral(2)) && solver2.propagate();
		solver2.assume(builder.getLiteral(3)) && solver2.propagate();
		CPPUNIT_ASSERT(solver2.value(builder.getLiteral(4).var()) == value_free);
	}

	void testParallelUpdate() {
		SharedContext ctx; Solver& solver = *ctx.master();
		lpAdd(builder.start(ctx, LogicProgram::AspOptions().noEq().noScc()), "{x1;x2;x3}. #minimize{x2}.");
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		ctx.setConcurrency(2);
		ModelEnumerator e(ModelEnumerator::strategy_record);
		e.init(ctx);

		Solver& solver2 = ctx.pushSolver();
		ctx.endInit(true);

		// x1
		solver.assume(builder.getLiteral(1));
		solver.pushRootLevel(1);
		solver.propagate();
		// ~x2
		solver2.assume(~builder.getLiteral(1));
		solver2.pushRootLevel(1);
		solver2.propagate();

		// M1: ~x2, x3
		solver.assume(~builder.getLiteral(2));
		solver.propagate();
		solver.assume(builder.getLiteral(3));
		solver.propagate();
		CPPUNIT_ASSERT_EQUAL(uint32(0), solver.numFreeVars());
		e.commitModel(solver);
		solver.undoUntil(0);
		e.update(solver);

		// M2: ~x2, ~x3
		solver2.assume(~builder.getLiteral(2));
		solver2.propagate();
		solver2.assume(~builder.getLiteral(3));
		solver2.propagate();
		// M2 is NOT VALID!
		CPPUNIT_ASSERT_EQUAL(false, e.update(solver2));
	}

	void testTagLiteral() {
		ModelEnumerator e;
		SharedContext ctx;
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		e.init(ctx);
		ctx.endInit();
		CPPUNIT_ASSERT(2 == ctx.numVars());
		e.start(*ctx.master());
		ctx.master()->pushTagVar(true);
		CPPUNIT_ASSERT(2 == ctx.numVars());
		CPPUNIT_ASSERT(3 == ctx.master()->numVars());
		CPPUNIT_ASSERT(ctx.master()->isTrue(ctx.master()->tagLiteral()));
	}
	void testIgnoreTagLiteralInPath() {
		SharedContext ctx;
		Var a = ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		Solver& s1 = ctx.startAddConstraints();
		Solver& s2 = ctx.pushSolver();
		ctx.endInit();
		ctx.attach(s2);
		s1.pushRoot(posLit(a));
		s1.pushTagVar(true);
		CPPUNIT_ASSERT(s1.rootLevel() == 2 && s1.isTrue(s1.tagLiteral()));
		LitVec path;
		s1.copyGuidingPath(path);
		CPPUNIT_ASSERT(path.size() == 1 && path.back() == posLit(a));
	}
	void testSplittable() {
		SharedContext ctx;
		Var a = ctx.addVar(Var_t::Atom);
		Var b = ctx.addVar(Var_t::Atom);
		Var c = ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		s.pushRoot(posLit(a));
		CPPUNIT_ASSERT(!s.splittable());
		s.assume(posLit(b)) && s.propagate();
		CPPUNIT_ASSERT(s.splittable());
		s.pushTagVar(true);
		CPPUNIT_ASSERT(!s.splittable());
		s.assume(posLit(c)) && s.propagate();
		CPPUNIT_ASSERT(s.splittable());
		s.pushRootLevel();
		Var aux = s.pushAuxVar();
		s.assume(posLit(aux)) && s.propagate();
		CPPUNIT_ASSERT(!s.splittable());
	}
	void testLearnStepLiteral() {
		SharedContext ctx;
		ctx.requestStepVar();
		Var a = ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		Solver& s1 = ctx.startAddConstraints();
		ctx.pushSolver();
		ctx.endInit(true);
		ClauseCreator cc(&s1);
		cc.start(Constraint_t::Conflict).add(posLit(a)).add(~ctx.stepLiteral()).end();
		ctx.unfreeze();
		ctx.endInit(true);
		s1.pushRoot(negLit(a));
		CPPUNIT_ASSERT(s1.value(ctx.stepLiteral().var()) == value_free);
	}

	void testAssignStepLiteral() {
		SharedContext ctx;
		ctx.requestStepVar();
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT(s.value(ctx.stepLiteral().var()) == value_free);
		ctx.addUnary(ctx.stepLiteral());
		CPPUNIT_ASSERT(s.value(ctx.stepLiteral().var()) != value_free);
		ctx.unfreeze();
		ctx.endInit();
		CPPUNIT_ASSERT(s.value(ctx.stepLiteral().var()) == value_free);
	}
private:
	LogicProgram builder;
	stringstream str;
	Model model;
};
CPPUNIT_TEST_SUITE_REGISTRATION(EnumeratorTest);
 } }
clasp-3.2.2/libclasp/tests/facade_test.cpp000066400000000000000000001540331304134206100205210ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

namespace Clasp { namespace Test {
using namespace Clasp::mt;

class FacadeTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(FacadeTest);
	CPPUNIT_TEST(testPrepareIsIdempotent);
	CPPUNIT_TEST(testPrepareIsImplicit);
	CPPUNIT_TEST(testPrepareSolvedProgram);
	CPPUNIT_TEST(testSolveSolvedProgram);
	CPPUNIT_TEST(testSolveAfterStopConflict);
	CPPUNIT_TEST(testRestartAfterPrepare);

	CPPUNIT_TEST(testUpdateWithoutPrepareDoesNotIncStep);
	CPPUNIT_TEST(testUpdateWithoutSolveDoesNotIncStep);
	CPPUNIT_TEST(testInterruptBeforePrepareInterruptsNext);
	CPPUNIT_TEST(testInterruptBeforeSolveInterruptsNext);
	CPPUNIT_TEST(testInterruptAfterSolveInterruptsNext);
	CPPUNIT_TEST(testInterruptBeforeUpdateInterruptsNext);
	CPPUNIT_TEST(testUpdateCanIgnoreQueuedSignals);
	CPPUNIT_TEST(testShutdownStopsStep);

	CPPUNIT_TEST(testSolveUnderAssumptions);
	CPPUNIT_TEST(testPrepareTooStrongBound);

	CPPUNIT_TEST(testComputeBraveViaOutput);
	CPPUNIT_TEST(testComputeBraveViaProject);
	CPPUNIT_TEST(testComputeQuery);
	CPPUNIT_TEST(testOptN);
	CPPUNIT_TEST(testOptNGenerator);

	CPPUNIT_TEST(testIncrementalSolve);
	CPPUNIT_TEST(testIncrementalEnum);
	CPPUNIT_TEST(testIncrementalCons);
	CPPUNIT_TEST(testIncrementalMin);
	CPPUNIT_TEST(testIncrementalMinIgnore);
	CPPUNIT_TEST(testIncrementalMinAdd);
	CPPUNIT_TEST(testUpdateConfig);
	CPPUNIT_TEST(testIncrementalProjectUpdate);
	CPPUNIT_TEST(testIncrementalDomRecUpdate);
	CPPUNIT_TEST(testIncrementalConfigUpdateBug);
	CPPUNIT_TEST(testIncrementalLookaheadAddHeuristic);
	CPPUNIT_TEST(testIncrementalDisableLookahead);
	CPPUNIT_TEST(testIncrementalChangeLookahead);
	CPPUNIT_TEST(testIncrementalExtendLookahead);
	CPPUNIT_TEST(testIncrementalAddSolver);
	CPPUNIT_TEST(testIncrementalRemoveSolver);
	CPPUNIT_TEST(testClingoStats);
	CPPUNIT_TEST(testClingoStatsKeyIntegrity);
	CPPUNIT_TEST(testClingoStatsWithoutStats);
#if WITH_THREADS
	CPPUNIT_TEST(testClingoSolverStatsRemainValid);
	CPPUNIT_TEST(testShareModeRegression);
	CPPUNIT_TEST(testAsyncSolveTrivialUnsat);
	CPPUNIT_TEST(testInterruptBeforeSolve);
	CPPUNIT_TEST(testCancelAsyncOperation);
	CPPUNIT_TEST(testAsyncResultDtorCancelsOp);
	CPPUNIT_TEST(testDestroyAsyncResultNoFacade);
	CPPUNIT_TEST(testDestroyDanglingAsyncResult);
	CPPUNIT_TEST(testCancelDanglingAsyncOperation);
#endif
	CPPUNIT_TEST(testGenSolveTrivialUnsat);
	CPPUNIT_TEST(testInterruptBeforeGenSolve);
	CPPUNIT_TEST(testGenSolveWithLimit);
	CPPUNIT_TEST(testCancelGenSolve);
	CPPUNIT_TEST(testGenDtorCancelsSolve);
	CPPUNIT_TEST(testGenStopFromHandler);
#if WITH_THREADS
	CPPUNIT_TEST(testGenSolveMt);
#endif

	CPPUNIT_TEST(testUserConfigurator);
	CPPUNIT_TEST(testUserHeuristic);
	CPPUNIT_TEST_SUITE_END();
public:
	typedef ClaspFacade::Result Result;
	void addProgram(Clasp::Asp::LogicProgram& prg) {
		lpAdd(prg, "a :- not b. b :- not a.");
	}

	void testPrepareIsIdempotent() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		libclasp.prepare();
		libclasp.prepare();

		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.summary().step == 0);
	}

	void testPrepareIsImplicit() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config);
		addProgram(asp);

		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.summary().step == 0);
	}

	void testPrepareSolvedProgram() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.summary().step == 0);

		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.summary().step == 1);
	}
	void testSolveSolvedProgram() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());

		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.summary().step == 1);
	}
	void testSolveAfterStopConflict() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		struct PP : public PostPropagator {
			uint32 priority() const { return priority_reserved_msg; }
			bool propagateFixpoint(Solver& s, PostPropagator*) {
				s.setStopConflict();
				return false;
			}
		} pp;
		libclasp.ctx.master()->addPost(&pp);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().unknown());
		libclasp.ctx.master()->removePost(&pp);
		libclasp.update();
		CPPUNIT_ASSERT(libclasp.solve().sat());
	}
	void testRestartAfterPrepare() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		libclasp.startAsp(config);
		libclasp.prepare();
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config);
		CPPUNIT_ASSERT(!asp.frozen());
	}
	void testUpdateWithoutPrepareDoesNotIncStep() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		CPPUNIT_ASSERT(libclasp.update().ok());
		CPPUNIT_ASSERT(libclasp.update().ok());
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.summary().step == 0);
	}
	void testUpdateWithoutSolveDoesNotIncStep() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.update().ok());
		libclasp.prepare();

		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.summary().step == 0);
	}

	void testInterruptBeforePrepareInterruptsNext() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		struct FH : EventHandler {
			FH() : finished(0) {}
			virtual void onEvent(const Event& ev) {
				finished += event_cast(ev) != 0;
			}
			int finished;
		} fh;
		CPPUNIT_ASSERT(libclasp.interrupt(1) == false);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve(&fh).interrupted());
		CPPUNIT_ASSERT(libclasp.solved());
		CPPUNIT_ASSERT(fh.finished == 1);
	}

	void testInterruptBeforeSolveInterruptsNext() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		struct FH : EventHandler {
			FH() : finished(0) {}
			virtual void onEvent(const Event& ev) {
				finished += event_cast(ev) != 0;
			}
			int finished;
		} fh;
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.interrupt(1) == false);
		CPPUNIT_ASSERT(!libclasp.solved());
		CPPUNIT_ASSERT(libclasp.solve(&fh).interrupted());
		CPPUNIT_ASSERT(libclasp.solved());
		CPPUNIT_ASSERT(fh.finished == 1);
	}

	void testInterruptAfterSolveInterruptsNext() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		struct FH : EventHandler {
			FH() : finished(0) {}
			virtual void onEvent(const Event& ev) {
				finished += event_cast(ev) != 0;
			}
			int finished;
		} fh;
		libclasp.prepare();
		CPPUNIT_ASSERT(!libclasp.solve(&fh).interrupted());
		CPPUNIT_ASSERT(fh.finished == 1);
		CPPUNIT_ASSERT(libclasp.solved());
		CPPUNIT_ASSERT(!libclasp.interrupted());
		CPPUNIT_ASSERT(libclasp.interrupt(1) == false);
		CPPUNIT_ASSERT(libclasp.solve(&fh).interrupted());
		CPPUNIT_ASSERT(fh.finished == 2);
	}
	void testInterruptBeforeUpdateInterruptsNext() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		libclasp.prepare();
		libclasp.interrupt(1);
		libclasp.update(false);
		CPPUNIT_ASSERT(!libclasp.interrupted());
		CPPUNIT_ASSERT(libclasp.solve().interrupted());
	}
	void testUpdateCanIgnoreQueuedSignals() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		libclasp.prepare();
		libclasp.interrupt(1);
		libclasp.update(false, SIG_IGN);
		CPPUNIT_ASSERT(!libclasp.solve().interrupted());
	}

	void testShutdownStopsStep() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		libclasp.prepare();
		libclasp.shutdown();
		CPPUNIT_ASSERT(libclasp.solved());
	}

	void testSolveUnderAssumptions() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		addProgram(asp);
		Var ext = asp.newAtom();
		asp.freeze(ext, value_true);
		libclasp.prepare();
		LitVec assume(1, asp.getLiteral(1));
		struct MH : public Clasp::EventHandler {
			MH() : models(0) {}
			bool onModel(const Clasp::Solver&, const Clasp::Model& m) {
				for (LitVec::const_iterator it = exp.begin(), end = exp.end(); it != end; ++it) {
					CPPUNIT_ASSERT(m.isTrue(*it));
				}
				++models;
				return true;
			}
			LitVec exp;
			int    models;
		} mh1, mh2;
		mh1.exp.push_back(asp.getLiteral(1));
		mh1.exp.push_back(~asp.getLiteral(2));
		mh1.exp.push_back(asp.getLiteral(ext));
		libclasp.solve(&mh1, assume);
		CPPUNIT_ASSERT(mh1.models == 1);
		libclasp.update();
		asp.freeze(ext, value_false);
		assume.assign(1, asp.getLiteral(2));
		mh2.exp.push_back(~asp.getLiteral(1));
		mh2.exp.push_back(asp.getLiteral(2));
		mh2.exp.push_back(~asp.getLiteral(ext));
		libclasp.solve(&mh2, assume);
		CPPUNIT_ASSERT(mh2.models == 1);
		libclasp.update();
		libclasp.solve();
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
	}

	void testPrepareTooStrongBound() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.optBound.assign(1, 0);
		lpAdd(libclasp.startAsp(config, true),
			"a :-not b.\n"
			"b :-not a.\n"
			"c.\n"
			"#minimize{c, a, b}.");

		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().unsat());
	}

	void testComputeBraveViaOutput() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_brave;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp,
			"x1 :- not x2.\n"
			"x2 :- not x1.\n"
			"x3 :- not x1.\n"
			"#output a : x1.\n"
			"#output b : x2.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		const Model& m = *libclasp.summary().model();
		CPPUNIT_ASSERT(m.isDef(asp.getLiteral(1)));
		CPPUNIT_ASSERT(m.isDef(asp.getLiteral(2)));
	}
	void testComputeQuery() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode = EnumOptions::enum_query;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp,
			"{a,b}."
			"c :- a.\n"
			"c :- b.\n"
			"c :- not a, not b.\n"
			"#output a : a.\n"
			"#output b : b.\n"
			"#output c : c.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		const Model& m = *libclasp.summary().model();
		CPPUNIT_ASSERT(m.isDef(asp.getLiteral(3)));
		CPPUNIT_ASSERT(!m.isDef(asp.getLiteral(1)));
		CPPUNIT_ASSERT(!m.isDef(asp.getLiteral(2)));
	}
	void testComputeBraveViaProject() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_brave;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp,
			"x1 :- not x2.\n"
			"x2 :- not x1.\n"
			"x3 :- not x1.\n"
			"#project {x1,x2,x3}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		const Model& m = *libclasp.summary().model();
		CPPUNIT_ASSERT(m.isDef(asp.getLiteral(1)));
		CPPUNIT_ASSERT(m.isDef(asp.getLiteral(2)));
	}
	void testOptN() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.optMode   = MinimizeMode_t::enumOpt;
		lpAdd(libclasp.startAsp(config, false),
			"{x1;x2;x3}.\n"
			":- not x1, not x2, not x3.\n"
			":- x2, not x1.\n"
			":- x3, not x1.\n"
			"#minimize{not x1}@0.\n"
			"#minimize{x1}@1.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT_EQUAL(uint64(4), libclasp.summary().optimal());
	}
	void testOptNGenerator() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.optMode   = MinimizeMode_t::enumOpt;
		lpAdd(libclasp.startAsp(config, false),
			"{x1;x2;x3}.\n"
			":- not x1, not x2, not x3.\n"
			":- x2, not x1.\n"
			":- x3, not x1.\n"
			"#minimize{not x1}@0.\n"
			"#minimize{x1}@1.");
		libclasp.prepare();
		Clasp::ClaspFacade::ModelGenerator it = libclasp.startSolve();
		unsigned num = 0, opt = 0;
		while (it.next()) {
			++num;
			opt += it.model().opt;
		}
		CPPUNIT_ASSERT(num > opt && opt == 4);
	}

	void testRunIncremental(Result::Base stop, int maxStep, int minStep, Result::Base expectedRes, int expectedSteps) {
		ClaspConfig config;
		ClaspFacade f;
		f.ctx.enableStats(2);
		config.asp.noEq();
		Asp::LogicProgram& asp = f.startAsp(config, true);
		Result::Base       res = Result::UNKNOWN;
		do {
			f.update();
			switch(f.step()) {
			default: break;
			case 0:
				lpAdd(asp,
				"x1 :- x2.\n"
				"x2 :- x1.\n"
				"x1 :- x3.\n"
				":- not x1.\n"
				"#external x3.");
				break;
			case 1:
				lpAdd(asp,
					"x3 :- x4.\n"
					"x4 :- x3.\n"
					"x4 :- x5.\n"
					"#external x5.");
				break;
			case 2:
				lpAdd(asp,
					"x5 :- x6, x7.\n"
					"x6 :- not x3.\n"
					"x7 :- not x1, not x2.\n"
					"{x5}.");
				break;
			case 3:
				lpAdd(asp, "{x8}.");
				break;
			}
			f.prepare();
			res = f.solve();
		} while (--maxStep && ((minStep > 0 && --minStep) || res != stop));
		CPPUNIT_ASSERT_EQUAL(expectedRes,  (Result::Base)f.result());
		CPPUNIT_ASSERT_EQUAL(expectedSteps, f.step());
	}
	void testIncrementalSolve() {
		testRunIncremental(Result::SAT  , -1, -1, Result::SAT  , 2);
		testRunIncremental(Result::UNSAT, -1, -1, Result::UNSAT, 0);
		testRunIncremental(Result::SAT  ,  2, -1, Result::UNSAT, 1);
		testRunIncremental(Result::SAT  , -1,  4, Result::SAT  , 3);
	}
	void testIncrementalEnum() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_record;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		CPPUNIT_ASSERT(libclasp.update().ok());
		lpAdd(asp, "{x2}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 4);
	}
	void testIncrementalCons() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_cautious;
		lpAdd(libclasp.startAsp(config, true),
			"{x1;x2;x3}.\n"
			"#output a : x1.\n"
			"#output b : x2.\n"
			"#output c : x3.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		config.solve.enumMode = EnumOptions::enum_brave;
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum > 1);
	}
	void testIncrementalMin() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_auto;
		lpAdd(libclasp.startAsp(config, true),
			"{x1;x2;x3}.\n"
			"#minimize{x1, x2, x3}.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum < 8u);
		libclasp.update().ctx()->removeMinimize();
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 8);
	}
	void testIncrementalMinIgnore() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.optMode = MinimizeMode_t::ignore;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true),
			"{x1;x2}.\n"
			"#minimize{x1, x2}.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 4u);
		config.solve.optMode = MinimizeMode_t::optimize;
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 1u);
	}
	void testIncrementalMinAdd() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_auto;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp,
			"{x1;x2}.\n"
			"#minimize{not x1}.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().model()->isTrue(asp.getLiteral(1)));
		libclasp.update();
		lpAdd(asp, "#minimize{not x2}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().model()->isTrue(asp.getLiteral(1)));
		CPPUNIT_ASSERT(libclasp.summary().model()->isTrue(asp.getLiteral(2)));
	}
	void testUpdateConfig() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_auto;
		config.addSolver(0).heuId  = Heuristic_t::Berkmin;
		lpAdd(libclasp.startAsp(config, true), "{x1;x2;x3}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		config.addSolver(0).heuId = Heuristic_t::Vsids;
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(dynamic_cast(libclasp.ctx.master()->heuristic()));
	}
	void testIncrementalProjectUpdate() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_auto;
		config.solve.project   = 1;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}. #output b : x2.");
		libclasp.prepare();
		CPPUNIT_ASSERT(static_cast(libclasp.enumerator())->project(asp.getLiteral(2).var()));
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);
		config.solve.project = 0;
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 4);
		config.solve.project = 1;
		libclasp.update(true);
		lpAdd(asp, "{x3;x4}. #output y : x4.");
		libclasp.prepare();
		CPPUNIT_ASSERT(static_cast(libclasp.enumerator())->project(asp.getLiteral(2).var()));
		CPPUNIT_ASSERT(static_cast(libclasp.enumerator())->project(asp.getLiteral(4).var()));
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT_EQUAL(uint64(4), libclasp.summary().numEnum);
	}
	void testIncrementalDomRecUpdate() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.enumMode  = EnumOptions::enum_dom_record;
		config.addSolver(0).heuId  = Heuristic_t::Domain;
		config.addSolver(0).heuristic.domMod  = HeuParams::mod_false;
		config.addSolver(0).heuristic.domPref = HeuParams::pref_show;
		lpAdd(libclasp.startAsp(config, true),
			"{x1;x2}.\n"
			":- not x1, not x2.\n"
			"#output b : x2.\n"
			"#output a : x1.\n");
		CPPUNIT_ASSERT(libclasp.solve().sat());
		// {a} ; {b}
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 2);

		config.addSolver(0).heuristic.domMod = HeuParams::mod_true;
		libclasp.update(true);
		CPPUNIT_ASSERT(libclasp.solve().sat());
		// {a,b}
		CPPUNIT_ASSERT(libclasp.summary().numEnum == 1);
	}
	void testIncrementalConfigUpdateBug() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.asp.erMode = Asp::LogicProgram::mode_transform;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.ok());
		CPPUNIT_ASSERT(asp.stats.auxAtoms == 2);
		config.asp.erMode = Asp::LogicProgram::mode_native;
		libclasp.update(true);
		lpAdd(asp, "{x3;x4}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(asp.stats.auxAtoms == 0);
	}

	void testIncrementalLookaheadAddHeuristic() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.addSolver(0).lookType = Var_t::Atom;
		lpAdd(libclasp.startAsp(config, true), "{x1;x2}.");
		libclasp.prepare();
		PostPropagator* look = libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look);
		CPPUNIT_ASSERT(look && look->next == 0);
		config.addSolver(0).heuId = Heuristic_t::Unit;
		libclasp.update(true);
		libclasp.prepare();
		look = libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look);
		CPPUNIT_ASSERT(look && look->next == 0);
	}
	void testIncrementalDisableLookahead() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.addSolver(0).lookType = Var_t::Atom;
		lpAdd(libclasp.startAsp(config, true), "{x1;x2}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look));
		config.addSolver(0).lookType = 0;
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look) == 0);
	}
	void testIncrementalChangeLookahead() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.addSolver(0).lookType = Var_t::Atom;
		lpAdd(libclasp.startAsp(config, true), "{x1;x2}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look));
		config.addSolver(0).lookType = Var_t::Body;
		libclasp.update(true);
		libclasp.prepare();
		Lookahead* look = static_cast(libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look));
		CPPUNIT_ASSERT(look && look->score.types == Var_t::Body );
	}
	void testIncrementalExtendLookahead() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.addSolver(0).lookType = Var_t::Atom;
		config.addSolver(0).lookOps  = 3;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look));
		config.addSolver(0).lookOps  = 0;
		libclasp.update(true);
		lpAdd(asp, "{x3;x4}.");
		libclasp.prepare();
		Lookahead* look = static_cast(libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look));
		CPPUNIT_ASSERT(look && look->next == 0 );
		while (libclasp.ctx.master()->numFreeVars() != 0) {
			libclasp.ctx.master()->decideNextBranch();
			libclasp.ctx.master()->propagate();
			CPPUNIT_ASSERT(libclasp.ctx.master()->getPost(PostPropagator::priority_reserved_look) == look);
		}
	}
	void testIncrementalAddSolver() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(!isSentinel(libclasp.ctx.stepLiteral()));
#if WITH_THREADS
		config.solve.setSolvers(2);
		libclasp.update(true);
		lpAdd(asp, "{x3;x4}.");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.concurrency() == 2 && libclasp.ctx.hasSolver(1));
#endif
	}

	void testIncrementalRemoveSolver() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.solve.numModels = 0;
		config.solve.setSolvers(4);
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp,
			"{x1;x2;x4;x3}.\n"
			":- 3 {x1, x2, x3, x4}.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat());
		CPPUNIT_ASSERT_EQUAL(uint64(11), libclasp.summary().numEnum);

		config.solve.setSolvers(1);
		libclasp.update(true);
		lpAdd(asp, ":- x1, x2.\n");
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat() && libclasp.summary().numEnum == 10);

		config.solve.setSolvers(2);
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().sat() && libclasp.summary().numEnum == 10);
	}

	void testClingoStats() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.stats = 2;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2;x3}. #minimize{x1, x2}.");
		libclasp.prepare();
		libclasp.solve();
		Potassco::AbstractStatistics* stats = libclasp.getStats();
		typedef Potassco::AbstractStatistics::Key_t Key_t;
		Key_t r = stats->root();
		CPPUNIT_ASSERT(stats->type(r) == Potassco::Statistics_t::Map);
		Key_t lp = stats->get(r, "problem.lp");
		Key_t s = stats->get(r, "solving");
		Key_t m = stats->get(r, "summary.models");
		CPPUNIT_ASSERT(stats->type(lp) == Potassco::Statistics_t::Map);
		CPPUNIT_ASSERT(stats->value(stats->get(lp, "rules")) == double(asp.stats.rules[0].sum()));
		CPPUNIT_ASSERT(stats->value(stats->get(m, "enumerated")) == double(libclasp.summary().numEnum));
		Key_t solvers = stats->get(s, "solvers");
		CPPUNIT_ASSERT(stats->value(stats->get(solvers, "choices")) == double(libclasp.ctx.master()->stats.choices));
		Key_t costs = stats->get(r, "summary.costs");
		CPPUNIT_ASSERT(stats->type(costs) == Potassco::Statistics_t::Array);
		CPPUNIT_ASSERT(stats->value(stats->at(costs, 0)) == double(libclasp.summary().costs()->at(0)));
		Key_t solver = stats->get(s, "solver");
		CPPUNIT_ASSERT(stats->type(solver) == Potassco::Statistics_t::Array);
		Key_t s0 = stats->at(solver, 0);
		CPPUNIT_ASSERT(stats->type(s0) == Potassco::Statistics_t::Map);
		CPPUNIT_ASSERT(stats->value(stats->get(s0, "choices")) == double(libclasp.ctx.master()->stats.choices));
		std::vector keys;
		getKeys(*stats, r, keys, "");
		CPPUNIT_ASSERT(!keys.empty());
		for (std::vector::const_iterator it = keys.begin(), end = keys.end(); it != end; ++it) {
			CPPUNIT_ASSERT(stats->type(stats->get(r, it->c_str())) == Potassco::Statistics_t::Value);
		}
		CPPUNIT_ASSERT_MESSAGE("unexpected number of statistics", keys.size() == 237);
	}
	void testClingoStatsKeyIntegrity() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.stats = 2;
		config.addTesterConfig()->stats = 2;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2;x3}. #minimize{x1, x2}.");
		libclasp.prepare();
		libclasp.solve();
		typedef Potassco::AbstractStatistics::Key_t Key_t;
		Potassco::AbstractStatistics* stats = libclasp.getStats();
		Key_t lp = stats->get(stats->root(), "problem.lp");
		Key_t sccs = stats->get(lp, "sccs");
		Key_t m0 = stats->get(stats->root(), "summary.costs.0");
		CPPUNIT_ASSERT_THROW(stats->get(stats->root(), "hcc"), std::logic_error);
		CPPUNIT_ASSERT(stats->value(m0) == (double)libclasp.summary().costs()->at(0));
		libclasp.update();
		lpAdd(asp,
			"x4 | x5 :- x6, not x1."
			"x6 :- x4, x5, not x2."
			"x6 :- not x1."
		);
		libclasp.prepare();
		libclasp.solve();
		CPPUNIT_ASSERT(asp.stats.sccs == 1);
		CPPUNIT_ASSERT(asp.stats.nonHcfs == 1);
		CPPUNIT_ASSERT(lp == stats->get(stats->root(), "problem.lp"));
		CPPUNIT_ASSERT(sccs == stats->get(lp, "sccs"));
		CPPUNIT_ASSERT(m0 == stats->get(stats->root(), "summary.costs.0"));
		CPPUNIT_ASSERT(stats->value(sccs) == asp.stats.sccs);
		CPPUNIT_ASSERT(stats->value(m0) == (double)libclasp.summary().costs()->at(0));
		Key_t hcc0 = stats->get(stats->root(), "problem.hcc.0");
		Key_t hcc0Vars = stats->get(hcc0, "vars");
		CPPUNIT_ASSERT(stats->value(hcc0Vars) != 0.0);
		libclasp.update();
		libclasp.ctx.removeMinimize();
		lpAdd(asp,
			"x7 | x8 :- x9, not x1."
			"x9 :- x7, x8, not x2."
			"x9 :- not x1."
		);
		libclasp.prepare();
		libclasp.solve();
		CPPUNIT_ASSERT(libclasp.summary().lpStats()->sccs == 2);
		CPPUNIT_ASSERT(libclasp.summary().lpStats()->nonHcfs == 2);
		CPPUNIT_ASSERT(lp == stats->get(stats->root(), "problem.lp"));
		CPPUNIT_ASSERT(sccs == stats->get(lp, "sccs"));
		CPPUNIT_ASSERT_THROW(stats->value(m0), std::logic_error);
		CPPUNIT_ASSERT(stats->value(hcc0Vars) != 0.0);
		CPPUNIT_ASSERT(stats->value(stats->get(stats->root(), "problem.hcc.1.vars")) != 0.0);
	}
	void testClingoStatsWithoutStats() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp,
			"{x1,x2,x3}."
			"x3 | x4 :- x5, not x1."
			"x5 :- x4, x3, not x2."
			"x5 :- not x1."
		);
		libclasp.solve();
		typedef Potassco::AbstractStatistics::Key_t Key_t;
		Potassco::AbstractStatistics* stats = libclasp.getStats();
		Key_t root = stats->root();
		CPPUNIT_ASSERT(stats->size(root) == 3);
		CPPUNIT_ASSERT(stats->get(root, "solving") != root);
		CPPUNIT_ASSERT(stats->get(root, "problem") != root);
		CPPUNIT_ASSERT(stats->get(root, "summary") != root);
		CPPUNIT_ASSERT_THROW_MESSAGE("accu requires stats", stats->get(root, "solving.accu"), std::out_of_range);
	}
	void getKeys(const Potassco::AbstractStatistics& stats, Potassco::AbstractStatistics::Key_t k, std::vector& out, const std::string& p) {
		if (stats.type(k) == Potassco::Statistics_t::Map) {
			for (uint32 i = 0, end = stats.size(k); i != end; ++i) {
				const char* sk = stats.key(k, i);
				getKeys(stats, stats.get(k, sk), out, p.empty() ? sk : std::string(p).append(".").append(sk));
			}
		}
		else if (stats.type(k) == Potassco::Statistics_t::Array) {
			char buf[12];
			for (uint32 i = 0, end = stats.size(k); i != end; ++i) {
				getKeys(stats, stats.at(k, i), out, std::string(p).append(".").append(clasp_format(buf, 12, "%d", i)));
			}
		}
		else {
			out.push_back(p);
		}
	}
#if WITH_THREADS
	void testClingoSolverStatsRemainValid() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.stats = 2;
		config.solve.algorithm.threads = 2;
		config.solve.numModels = 0;
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1,x2,x3}.");
		libclasp.prepare();
		libclasp.solve();
		typedef Potassco::AbstractStatistics::Key_t Key_t;
		Potassco::AbstractStatistics* stats = libclasp.getStats();
		Key_t s = stats->get(stats->root(), "solving.solver");
		Key_t s1 = stats->at(s, 1);
		Key_t s1c = stats->get(stats->at(s, 1), "choices");
		Key_t s0c = stats->get(stats->at(s, 0), "choices");
		CPPUNIT_ASSERT(stats->size(s) == 2);
		CPPUNIT_ASSERT(stats->value(s1c) + stats->value(s0c) == stats->value(stats->get(stats->root(), "solving.solvers.choices")));
		config.solve.algorithm.threads = 1;
		libclasp.update(true);
		libclasp.solve();
		CPPUNIT_ASSERT_MESSAGE("solver stats are not removed", stats->size(s) == 2);
		CPPUNIT_ASSERT_MESSAGE("solver stats remain valid", stats->at(s, 1) == s1);
		CPPUNIT_ASSERT(stats->value(s1c) == 0.0);
		CPPUNIT_ASSERT(stats->value(s0c) == stats->value(stats->get(stats->root(), "solving.solvers.choices")));
		config.solve.algorithm.threads = 2;
		libclasp.update(true);
		libclasp.solve();
		CPPUNIT_ASSERT(stats->value(s1c) + stats->value(s0c) == stats->value(stats->get(stats->root(), "solving.solvers.choices")));
	}
	void testShareModeRegression() {
		Clasp::ClaspFacade libclasp;
		Clasp::ClaspConfig config;
		config.shareMode = ContextParams::share_auto;
		config.solve.algorithm.threads = 2;
		libclasp.startSat(config).prepareProblem(2);
		libclasp.prepare();
		CPPUNIT_ASSERT_EQUAL(true, libclasp.ctx.physicalShare(Constraint_t::Static));
		CPPUNIT_ASSERT_EQUAL(true, libclasp.ctx.physicalShare(Constraint_t::Conflict));
	}
	typedef ClaspFacade::AsyncResult AsyncResult;
	void testAsyncSolveTrivialUnsat() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true), "x1 :- not x1.");
		libclasp.prepare();
		AsyncResult it = libclasp.startSolveAsync();
		CPPUNIT_ASSERT(it.end());
		CPPUNIT_ASSERT(it.get().unsat());
	}
	void testInterruptBeforeSolve() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		libclasp.interrupt(2);
		AsyncResult it = libclasp.startSolveAsync();
		CPPUNIT_ASSERT(it.end());
		CPPUNIT_ASSERT(it.get().interrupted());
	}
	void testCancelAsyncOperation() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		AsyncResult it = libclasp.startSolveAsync();
		while (!it.end()) {
			CPPUNIT_ASSERT(it.model().num == 1);
			if (it.cancel()){ break; }
		}
		CPPUNIT_ASSERT(it.end() && !libclasp.solving() && it.interrupted());
		libclasp.update();
		libclasp.prepare();
		it = libclasp.startSolveAsync();
		int mod = 0;
		while (!it.end()) { ++mod; it.next(); }
		CPPUNIT_ASSERT(!libclasp.solving() && mod == 2);
	}
	void testAsyncResultDtorCancelsOp() {
		ClaspConfig config;
		ClaspFacade libclasp;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		{ AsyncResult it = libclasp.startSolveAsync(); }
		CPPUNIT_ASSERT(!libclasp.solving() && libclasp.result().interrupted());
	}
	void testDestroyAsyncResultNoFacade() {
		{
			ClaspConfig  config;
			ClaspFacade* libclasp = new ClaspFacade();
			lpAdd(libclasp->startAsp(config, true), "{x1}.");
			libclasp->prepare();
			AsyncResult res( libclasp->startSolveAsync() );
			delete libclasp;
			CPPUNIT_ASSERT(res.interrupted());
		}
	}
	void testDestroyDanglingAsyncResult() {
		ClaspConfig  config;
		ClaspFacade  libclasp;
		AsyncResult* handle = 0;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		handle = new AsyncResult( libclasp.solveAsync() );
		handle->wait();
		libclasp.update();
		libclasp.prepare();
		AsyncResult* it = new AsyncResult(libclasp.startSolveAsync());
		delete handle;
		CPPUNIT_ASSERT(!it->interrupted() && libclasp.solving());
		CPPUNIT_ASSERT_NO_THROW(delete it);
		CPPUNIT_ASSERT(!libclasp.solving());
	}
	void testCancelDanglingAsyncOperation() {
		ClaspConfig config;
		ClaspFacade libclasp;

		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		AsyncResult step0 = libclasp.solveAsync();
		step0.wait();
		libclasp.update();
		libclasp.prepare();
		AsyncResult step1 = libclasp.startSolveAsync();

		CPPUNIT_ASSERT_EQUAL(false, step0.cancel());
		CPPUNIT_ASSERT(libclasp.solving());
		CPPUNIT_ASSERT_EQUAL(true, step1.cancel());
		CPPUNIT_ASSERT(!libclasp.solving());
	}
#endif
	void testGenSolveTrivialUnsat() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true), "x1 :- not x1.");
		libclasp.prepare();
		ClaspFacade::ModelGenerator it = libclasp.startSolve();
		CPPUNIT_ASSERT(!it.next());
		CPPUNIT_ASSERT(it.result().exhausted());
	}
	void testInterruptBeforeGenSolve() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		libclasp.interrupt(2);
		ClaspFacade::ModelGenerator it = libclasp.startSolve();
		CPPUNIT_ASSERT(!it.next());
		CPPUNIT_ASSERT(it.result().interrupted());
	}
	void testGenSolveWithLimit() {
		ClaspConfig config;
		ClaspFacade libclasp;
		lpAdd(libclasp.startAsp(config, true), "{x1;x2;x3}.");
		libclasp.prepare();
		for (int i = 1; i != 9; ++i) {
			unsigned got = 0, exp = i;
			config.solve.numModels = i % 8;
			libclasp.update(true);
			ClaspFacade::ModelGenerator it = libclasp.startSolve();
			while (it.next()) {
				CPPUNIT_ASSERT(got != exp);
				++got;
			}
			CPPUNIT_ASSERT_EQUAL(exp, got);
		}
	}

	void testCancelGenSolve() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		ClaspFacade::ModelGenerator it = libclasp.startSolve();
		unsigned mod = 0;
		while (it.next()) {
			CPPUNIT_ASSERT(it.model().num == ++mod);
			it.stop();
			break;
		}
		CPPUNIT_ASSERT(!libclasp.solving() && !it.result().exhausted() && mod == 1);
		libclasp.update();
		libclasp.prepare();
		mod = 0;
		for (ClaspFacade::ModelGenerator j = libclasp.startSolve(); j.next(); ++mod) {
			;
		}
		CPPUNIT_ASSERT(!libclasp.solving() && mod == 2);
	}
	void testGenDtorCancelsSolve() {
		ClaspConfig config;
		ClaspFacade libclasp;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		{ libclasp.startSolve(); }
		CPPUNIT_ASSERT(!libclasp.solving() && !libclasp.result().exhausted());
	}
	void testGenStopFromHandler() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		struct Handler : EventHandler {
			virtual bool onModel(const Solver&, const Model&) {
				return false;
			}
		} h;
		libclasp.ctx.setEventHandler(&h);
		int mod = 0;
		for (ClaspFacade::ModelGenerator g = libclasp.startSolve(); g.next(); ++mod) {
			;
		}
		CPPUNIT_ASSERT(mod == 1);
	}
#if WITH_THREADS
	void testGenSolveMt() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.solve.numModels = 0;
		config.solve.algorithm.threads = 2;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		int mod = 0;
		for (ClaspFacade::ModelGenerator it = libclasp.startSolve(); it.next(); ++mod) {
			;
		}
		CPPUNIT_ASSERT(!libclasp.solving() && mod == 2);
	}
#endif
	void testUserConfigurator() {
		ClaspConfig config;
		struct MyAddPost : public ClaspConfig::Configurator {
			MyAddPost() : called(false) {}
			virtual bool addPost(Solver&) { return called = true; }
			bool called;
		} myAddPost;
		config.addConfigurator(&myAddPost);
		ClaspFacade libclasp;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		libclasp.prepare();
		CPPUNIT_ASSERT_EQUAL(true, myAddPost.called);
	}
	void testUserHeuristic() {
		struct MyHeu {
			static DecisionHeuristic* creator(Heuristic_t::Type, const HeuParams&) { throw MyHeu(); }
		};
		ClaspConfig config;
		config.setHeuristicCreator(&MyHeu::creator);
		ClaspFacade libclasp;
		lpAdd(libclasp.startAsp(config, true), "{x1}.");
		CPPUNIT_ASSERT_THROW(libclasp.prepare(), MyHeu);
	}
};
CPPUNIT_TEST_SUITE_REGISTRATION(FacadeTest);

class MyProp : public Potassco::AbstractPropagator {
public:
	MyProp() : fire(lit_false()), clProp(Potassco::Clause_t::Learnt) {}
	virtual void propagate(Potassco::AbstractSolver& s, const ChangeList& changes) {
		map(changes);
		addClause(s);
	}
	virtual void undo(const Potassco::AbstractSolver&, const ChangeList& changes) {
		map(changes);
	}
	virtual void check(Potassco::AbstractSolver& s) {
		const Potassco::AbstractAssignment& assign = s.assignment();
		for (Potassco::LitVec::const_iterator it = clause.begin(), end = clause.end(); it != end; ++it) {
			if (assign.isTrue(*it)) { return; }
		}
		if (!clause.empty()) { s.addClause(Potassco::toSpan(clause)); }
	}
	void map(const ChangeList& changes) {
		change.clear();
		for (const Potassco::Lit_t* x = Potassco::begin(changes); x != Potassco::end(changes); ++x) {
			change.push_back(decodeLit(*x));
		}
	}
	bool addClause(Potassco::AbstractSolver& s) {
		if (!s.assignment().isTrue(encodeLit(fire))) {
			return true;
		}
		return s.addClause(Potassco::toSpan(clause), clProp) && s.propagate();
	}
	void addToClause(Literal x) {
		clause.push_back(encodeLit(x));
	}
	Literal  fire;
	LitVec change;
	Potassco::LitVec   clause;
	Potassco::Clause_t clProp;
};
class ClingoPropagatorTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(ClingoPropagatorTest);
	CPPUNIT_TEST(testAssignment);
	CPPUNIT_TEST(testPropagateChange);
	CPPUNIT_TEST(testAddClause);
	CPPUNIT_TEST(testAddUnitClause);
	CPPUNIT_TEST(testAddUnitClauseWithUndo);
	CPPUNIT_TEST(testAddUnsatClause);
	CPPUNIT_TEST(testAddEmptyClause);
	CPPUNIT_TEST(testAttachToSolver);
	CPPUNIT_TEST(testAddClauseOnModel);
	CPPUNIT_TEST(testAddConflictOnModel);
	CPPUNIT_TEST(testAddStatic);
	CPPUNIT_TEST(testAddVolatile);
	CPPUNIT_TEST(testAddVolatileStatic);
	CPPUNIT_TEST(testPushVariable);
	CPPUNIT_TEST(testAuxVarMakesClauseVolatile);
	CPPUNIT_TEST(testRootLevelBug);
	CPPUNIT_TEST(testLookaheadBug);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
		tp = new Clasp::ClingoPropagatorInit(prop);
	}
	void tearDown() {
		delete tp;
	}
	void testAssignment() {
		class Prop : public Potassco::AbstractPropagator {
		public:
			Prop() {}
			virtual void propagate(Potassco::AbstractSolver&, const ChangeList&)  {}
			virtual void undo(const Potassco::AbstractSolver&, const ChangeList&) {}
			virtual void check(Potassco::AbstractSolver& s) {
				const Potassco::AbstractAssignment& a = s.assignment();
				CPPUNIT_ASSERT(!a.hasConflict());
				CPPUNIT_ASSERT(a.level() == 2);
				CPPUNIT_ASSERT(a.value(v1) == Potassco::Value_t::True);
				CPPUNIT_ASSERT(a.value(v2) == Potassco::Value_t::False);
				CPPUNIT_ASSERT(a.isTrue(v1));
				CPPUNIT_ASSERT(a.isFalse(v2));
				CPPUNIT_ASSERT(a.isTrue(Potassco::neg(v2)));
				CPPUNIT_ASSERT(a.level(v1) == 1);
				CPPUNIT_ASSERT(a.level(v2) == 2);
				CPPUNIT_ASSERT(!a.hasLit(v2+1));
				CPPUNIT_ASSERT(a.decision(0) == encodeLit(lit_true()));
				CPPUNIT_ASSERT(a.decision(1) == v1);
				CPPUNIT_ASSERT(a.decision(2) == Potassco::neg(v2));
			}
			Potassco::Lit_t v1, v2;
		} prop;
		addVars(2);
		prop.v1 = encodeLit(posLit(v[1]));
		prop.v2 = encodeLit(posLit(v[2]));
		MyInit pp(prop);
		pp.addPost(*ctx.master());
		ctx.endInit();
		ctx.master()->assume(posLit(v[1])) && ctx.master()->propagate();
		ctx.master()->assume(negLit(v[2])) && ctx.master()->propagate();
		ctx.master()->search(0, 0);
	}

	void testPropagateChange() {
		addVars(5);
		tp->addWatch(posLit(v[1]));
		tp->addWatch(posLit(v[1])); // ignore duplicates
		tp->addWatch(posLit(v[2]));
		tp->addWatch(posLit(v[3]));
		tp->addWatch(negLit(v[3]));
		tp->addWatch(negLit(v[4]));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		s.assume(posLit(v[1])) && s.propagate();
		CPPUNIT_ASSERT(prop.change.size() == 1 && prop.change[0] == posLit(v[1]));

		s.assume(negLit(v[4])) && s.force(posLit(v[2]), 0) && s.propagate();
		CPPUNIT_ASSERT(prop.change.size() == 2 && prop.change[0] == negLit(v[4]) && prop.change[1] == posLit(v[2]));
		prop.change.clear();
		s.undoUntil(s.decisionLevel()-1);
		CPPUNIT_ASSERT(prop.change.size() == 2 && prop.change[0] == negLit(v[4]) && prop.change[1] == posLit(v[2]));
		s.undoUntil(s.decisionLevel()-1);
		CPPUNIT_ASSERT(prop.change.size() == 1 && prop.change[0] == posLit(v[1]));
		prop.change.clear();
		s.assume(negLit(v[2])) && s.propagate();
		CPPUNIT_ASSERT(prop.change.empty());
	}
	void testAddClause() {
		addVars(3);
		tp->addWatch(prop.fire = negLit(v[3]));
		prop.addToClause(posLit(v[1]));
		prop.addToClause(posLit(v[2]));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		s.assume(negLit(v[3])) && s.propagate();
		CPPUNIT_ASSERT(ctx.numLearntShort() == 1);
	}
	void testAddUnitClause() {
		addVars(3);
		tp->addWatch(prop.fire = negLit(v[3]));
		prop.addToClause(posLit(v[1]));
		prop.addToClause(posLit(v[2]));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		s.assume(negLit(v[2])) && s.propagate();
		s.assume(negLit(v[3])) && s.propagate();
		CPPUNIT_ASSERT(ctx.numLearntShort() == 1);
		CPPUNIT_ASSERT(s.isTrue(posLit(v[1])));
		CPPUNIT_ASSERT(prop.change.size() == 1 && prop.change[0] == negLit(v[3]));
	}
	void testAddUnitClauseWithUndo() {
		addVars(5);
		prop.fire = posLit(v[5]);
		tp->addWatch(posLit(v[3]));
		tp->addWatch(posLit(v[5]));
		prop.addToClause(posLit(v[1]));
		prop.addToClause(posLit(v[2]));
		prop.addToClause(posLit(v[3]));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		s.assume(negLit(v[1])) && s.propagate();
		s.assume(posLit(v[4])) && s.propagate();
		s.assume(negLit(v[2])) && s.propagate();
		s.assume(posLit(v[5])) && s.propagate();
		CPPUNIT_ASSERT(ctx.numLearntShort() == 1);
		CPPUNIT_ASSERT(s.decisionLevel() == 3);
		s.undoUntil(2);
		CPPUNIT_ASSERT(std::find(prop.change.begin(), prop.change.end(), posLit(v[3])) != prop.change.end());
	}
	void testAddUnsatClause() {
		addVars(3);
		tp->addWatch(prop.fire = negLit(v[3]));
		prop.addToClause(posLit(v[1]));
		prop.addToClause(posLit(v[2]));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		s.assume(negLit(v[2])) && s.propagate();
		s.assume(negLit(v[1])) && s.propagate();
		s.assume(negLit(v[3]));
		s.pushRootLevel(2);
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
		CPPUNIT_ASSERT_MESSAGE("do not add conflicting constraint", ctx.numLearntShort() == 0);
		s.popRootLevel(1);
		CPPUNIT_ASSERT(s.decisionLevel() == 1);
		prop.clause.clear();
		prop.addToClause(negLit(v[2]));
		prop.addToClause(posLit(v[3]));
		s.assume(negLit(v[3]));
		CPPUNIT_ASSERT_EQUAL(true, s.propagate());
		CPPUNIT_ASSERT_MESSAGE("do not add sat constraint", ctx.numLearntShort() == 0);
	}
	void testAddEmptyClause() {
		addVars(1);
		tp->addWatch(prop.fire = negLit(v[1]));
		prop.addToClause(negLit(0));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		s.assume(negLit(v[1]));
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
	}
	void testAttachToSolver() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.addConfigurator(tp);
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		asp.endProgram();
		for (Var v = 1; v <= libclasp.ctx.numVars(); ++v) {
			tp->addWatch(posLit(v));
			tp->addWatch(negLit(v));
		}
		CPPUNIT_ASSERT(prop.change.empty());
		libclasp.prepare();
		libclasp.solve();
		CPPUNIT_ASSERT(!prop.change.empty());
#if WITH_THREADS
		config.solve.setSolvers(2);
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.concurrency() == 2 && libclasp.ctx.hasSolver(1));
		libclasp.solve();
		CPPUNIT_ASSERT(libclasp.ctx.solver(1)->getPost(PostPropagator::priority_class_general) != 0);
		config.solve.setSolvers(1);
		libclasp.update(true);
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.concurrency() == 1);
		config.solve.setSolvers(2);
		libclasp.update(true);
		libclasp.solve();
		CPPUNIT_ASSERT(libclasp.ctx.solver(1)->getPost(PostPropagator::priority_class_general) != 0);
#endif
	}
	void testAddClauseOnModel() {
		addVars(3);
		prop.addToClause(posLit(v[1]));
		prop.addToClause(posLit(v[3]));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		ValueRep v = s.search(-1, -1);
		CPPUNIT_ASSERT(v == value_true && s.numFreeVars() == 0);
		CPPUNIT_ASSERT(ctx.shortImplications().numLearnt() == 1);
	}
	void testAddConflictOnModel() {
		addVars(3);
		prop.addToClause(negLit(v[1]));
		prop.addToClause(negLit(v[2]));
		tp->addPost(*ctx.master());
		ctx.endInit();
		Solver& s = *ctx.master();
		s.assume(posLit(v[1]));
		s.force(posLit(v[2]), posLit(v[1]));
		s.propagate();
		s.assume(posLit(v[3])) && s.propagate();
		CPPUNIT_ASSERT(!s.hasConflict() && s.numFreeVars() == 0);
		CPPUNIT_ASSERT(!s.getPost(PostPropagator::priority_class_general)->isModel(s));
		CPPUNIT_ASSERT(s.hasConflict());
		CPPUNIT_ASSERT(s.decisionLevel() == 1 && s.resolveConflict());
	}

	void testAddStatic() {
		addVars(2);
		prop.addToClause(posLit(v[1]));
		prop.addToClause(posLit(v[2]));
		prop.fire   = lit_true();
		prop.clProp = Potassco::Clause_t::Static;
		tp->addWatch(negLit(v[1]));
		tp->addPost(*ctx.master());
		ctx.endInit();

		Solver& s = *ctx.master();
		CPPUNIT_ASSERT(s.numWatches(negLit(v[2])) == 0);
		s.assume(negLit(v[1])) && s.propagate();
		CPPUNIT_ASSERT(s.numWatches(negLit(v[2])) == 1);
		s.reduceLearnts(1.0);
		CPPUNIT_ASSERT(s.numWatches(negLit(v[2])) == 1);
	}

	void testAddVolatile() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.addConfigurator(tp);
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		asp.endProgram();
		tp->addWatch(negLit(1));
		prop.addToClause(posLit(1));
		prop.addToClause(posLit(2));
		libclasp.prepare();
		prop.fire = libclasp.ctx.stepLiteral();
		prop.clProp = Potassco::Clause_t::Volatile;
		libclasp.solve();
		CPPUNIT_ASSERT(libclasp.ctx.numLearntShort() == 1);
		libclasp.update();
		CPPUNIT_ASSERT(libclasp.ctx.numLearntShort() == 0);
	}
	void testAddVolatileStatic() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.addConfigurator(tp);
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		asp.endProgram();
		tp->addWatch(negLit(1));
		prop.addToClause(posLit(1));
		prop.addToClause(posLit(2));
		libclasp.prepare();
		prop.fire = libclasp.ctx.stepLiteral();
		prop.clProp = Potassco::Clause_t::VolatileStatic;
		libclasp.solve();
		CPPUNIT_ASSERT(libclasp.ctx.master()->numWatches(negLit(2)) == 1);
		libclasp.update();
		CPPUNIT_ASSERT(libclasp.ctx.master()->numWatches(negLit(2)) == 0);
	}
	void testPushVariable() {
		class AddVar : public Potassco::AbstractPropagator {
		public:
			typedef Potassco::Lit_t Lit_t;
			explicit AddVar(uint32 nAux) : aux_(nAux), next_(1) {}
			virtual void propagate(Potassco::AbstractSolver& s, const ChangeList&) {
				if (aux_) {
					const Potassco::AbstractAssignment& as = s.assignment();
					while (as.hasLit(next_)) { ++next_; }
					Lit_t x = s.addVariable();
					CPPUNIT_ASSERT(x == next_);
					CPPUNIT_ASSERT(!s.hasWatch(x) && !s.hasWatch(-x));
					s.addWatch(x);
					CPPUNIT_ASSERT(s.hasWatch(x) && !s.hasWatch(-x));
					s.addWatch(-x);
					CPPUNIT_ASSERT(s.hasWatch(x) && s.hasWatch(-x));
					s.removeWatch(x);
					CPPUNIT_ASSERT(!s.hasWatch(x) && s.hasWatch(-x));
					s.removeWatch(-x);
					CPPUNIT_ASSERT(!s.hasWatch(x) && !s.hasWatch(-x));
					s.addWatch(x); s.addWatch(-x);
					--aux_;
				}
			}
			virtual void undo(const Potassco::AbstractSolver&, const ChangeList&) {}
			virtual void check(Potassco::AbstractSolver&) {}
			uint32 aux_;
			Lit_t  next_;
		} prop(2);
		MyInit pp(prop);
		ClaspConfig config;
		ClaspFacade libclasp;
		config.addConfigurator(&pp);
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		asp.endProgram();
		pp.addWatch(posLit(1));
		pp.addWatch(negLit(1));
		pp.addWatch(posLit(2));
		pp.addWatch(negLit(2));
		libclasp.prepare();
		uint32 nv = libclasp.ctx.numVars();
		uint32 sv = libclasp.ctx.master()->numVars();
		libclasp.solve();
		CPPUNIT_ASSERT(nv == libclasp.ctx.numVars());
		CPPUNIT_ASSERT(sv == libclasp.ctx.master()->numVars());
	}
	void testAuxVarMakesClauseVolatile() {
		class AddAuxClause : public Potassco::AbstractPropagator {
		public:
			typedef Potassco::Lit_t Lit_t;
			explicit AddAuxClause() { aux = 0;  nextStep = false; }
			virtual void propagate(Potassco::AbstractSolver& s, const ChangeList&) {
				if (!aux) {
					aux = s.addVariable();
					Potassco::LitVec clause;
					for (Lit_t i = 1; i < aux; ++i) {
						if (s.hasWatch(i)) {
							clause.push_back(-i);
						}
					}
					clause.push_back(-aux);
					s.addClause(Potassco::toSpan(clause), Potassco::Clause_t::Static);
				}
				CPPUNIT_ASSERT(!nextStep || !s.assignment().hasLit(aux));
			}
			virtual void undo(const Potassco::AbstractSolver&, const ChangeList&) {}
			virtual void check(Potassco::AbstractSolver&) {}
			Lit_t aux;
			bool  nextStep;
		} prop;
		MyInit pp(prop);
		ClaspConfig config;
		ClaspFacade libclasp;
		config.addConfigurator(&pp);
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		asp.endProgram();
		pp.addWatch(posLit(1));
		pp.addWatch(posLit(2));
		LitVec assume;
		libclasp.prepare();
		assume.push_back(posLit(1));
		assume.push_back(posLit(2));
		libclasp.solve(0, assume);
		libclasp.update();
		prop.nextStep = true;
		libclasp.solve(0, assume);
	}

	void testRootLevelBug() {
		class Prop : public Potassco::AbstractPropagator {
		public:
			Prop() {}
			virtual void propagate(Potassco::AbstractSolver& s, const ChangeList&) {
				CPPUNIT_ASSERT(s.assignment().level() != 0);
				for (Potassco::Atom_t a = 2; a != 4; ++a) {
					Potassco::Lit_t pos = a;
					Potassco::Lit_t neg = -pos;
					if (!s.addClause(Potassco::toSpan(&pos, 1))) { return; }
					if (!s.addClause(Potassco::toSpan(&neg, 1))) { return; }
				}
			}
			virtual void undo(const Potassco::AbstractSolver&, const ChangeList&) {}
			virtual void check(Potassco::AbstractSolver&) {}
		} prop;
		MyInit pp(prop);
		ClaspConfig config;
		ClaspFacade libclasp;
		config.addConfigurator(&pp);
		Clasp::Asp::LogicProgram& asp = libclasp.startAsp(config, true);
		lpAdd(asp, "{x1;x2}.");
		asp.endProgram();
		pp.addWatch(posLit(1));
		pp.addWatch(negLit(1));
		pp.addWatch(posLit(2));
		pp.addWatch(negLit(2));
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.solve().unsat());
	}
	void testLookaheadBug() {
		ClaspConfig config;
		ClaspFacade libclasp;
		config.addConfigurator(tp);
		config.addSolver(0).lookType = Var_t::Atom;
		SatBuilder& sat = libclasp.startSat(config);
		sat.prepareProblem(2);
		LitVec clause;
		clause.push_back(negLit(1));
		clause.push_back(negLit(2));
		sat.addClause(clause);
		clause.pop_back();
		clause.push_back(posLit(2));
		sat.addClause(clause);
		tp->addWatch(negLit(1));
		libclasp.prepare();
		CPPUNIT_ASSERT(libclasp.ctx.master()->isTrue(negLit(1)));
		CPPUNIT_ASSERT(prop.change.size() == 1);
		CPPUNIT_ASSERT(prop.change[0] == negLit(1));
	}
private:
	void addVars(int num) {
		v.resize(num + 1);
		v[0] = 0;
		for (int i = 1; i <= num; ++i) {
			v[i] = ctx.addVar(Var_t::Atom);
		}
		ctx.startAddConstraints();
	}
	typedef ClingoPropagatorInit MyInit;
	SharedContext ctx;
	MyProp        prop;
	MyInit*       tp;
	VarVec v;
};
CPPUNIT_TEST_SUITE_REGISTRATION(ClingoPropagatorTest);
} }
clasp-3.2.2/libclasp/tests/literal_test.cpp000066400000000000000000000155621304134206100207550ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 

namespace Clasp { namespace Test {

class LiteralTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(LiteralTest);
	CPPUNIT_TEST(testCtor);
	CPPUNIT_TEST(testId);
	CPPUNIT_TEST(testIdIgnoresFlag);
	CPPUNIT_TEST(testFromId);
	CPPUNIT_TEST(testFlag);
	CPPUNIT_TEST(testFlagCopy);
	CPPUNIT_TEST(testComplement);
	CPPUNIT_TEST(testComplementIsNotFlagged);
	CPPUNIT_TEST(testEquality);
	CPPUNIT_TEST(testValue);
	CPPUNIT_TEST(testLess);

	CPPUNIT_TEST(testAntecedentNullPointer);
	CPPUNIT_TEST(testAntecedentPointer);
	CPPUNIT_TEST(testAntecedentBin);
	CPPUNIT_TEST(testAntecedentTern);
	CPPUNIT_TEST_SUITE_END();
public:
	LiteralTest() {
		min = lit_true(), mid = posLit(varMax / 2),  max = posLit(varMax - 1);
	}
	void testCtor() {
		Literal p, q(42, true);
		CPPUNIT_ASSERT_EQUAL(Var(0), p.var());
		CPPUNIT_ASSERT_EQUAL(false, p.sign());
		CPPUNIT_ASSERT_EQUAL(false, p.flagged());

		CPPUNIT_ASSERT_EQUAL(Var(42), q.var());
		CPPUNIT_ASSERT_EQUAL(true, q.sign());
		CPPUNIT_ASSERT_EQUAL(false, q.flagged());

		Literal x = posLit(7);
		Literal y = negLit(7);
		CPPUNIT_ASSERT(x.var() == y.var() && y.var() == Var(7));
		CPPUNIT_ASSERT_EQUAL(false, x.sign());
		CPPUNIT_ASSERT_EQUAL(true, y.sign());
	}
	void testId() {
		uint32 minIdx	= min.id();
		uint32 maxIdx	= max.id();
		uint32 midIdx	= mid.id();

		CPPUNIT_ASSERT_EQUAL(uint32(0), minIdx);
		CPPUNIT_ASSERT_EQUAL(uint32(1), (~min).id());

		CPPUNIT_ASSERT_EQUAL(uint32((max.var()*2)), maxIdx);
		CPPUNIT_ASSERT_EQUAL(uint32((max.var()*2)+1), (~max).id());

		CPPUNIT_ASSERT_EQUAL(uint32((mid.var()*2)), midIdx);
		CPPUNIT_ASSERT_EQUAL(uint32((mid.var()*2)+1), (~mid).id());

	}
	void testIdIgnoresFlag() {
		Literal maxW = max;
		maxW.flag();
		CPPUNIT_ASSERT_EQUAL(max.id(), maxW.id());
	}
	void testFromId() {
		CPPUNIT_ASSERT(min == Literal::fromId(min.id()));
		CPPUNIT_ASSERT(max == Literal::fromId(max.id()));
		CPPUNIT_ASSERT(mid == Literal::fromId(mid.id()));
	}
	void testFlag() {
		Literal p = posLit(42);
		p.flag();
		CPPUNIT_ASSERT_EQUAL(true, p.flagged());
		p.unflag();
		CPPUNIT_ASSERT_EQUAL(false, p.flagged());
	}
	void testFlagCopy() {
		Literal p = posLit(42);
		p.flag();
		Literal q = p;
		CPPUNIT_ASSERT_EQUAL(true, q.flagged());
	}
	void testComplement() {
		Literal lit = posLit(7);
		Literal cLit = ~lit;
		CPPUNIT_ASSERT_EQUAL(lit.var(), cLit.var());
		CPPUNIT_ASSERT_EQUAL(false, lit.sign());
		CPPUNIT_ASSERT_EQUAL(true, cLit.sign());
		CPPUNIT_ASSERT_EQUAL(true, lit == ~~lit);
	}
	void testComplementIsNotFlagged() {
		Literal lit = posLit(7);
		lit.flag();
		Literal cLit = ~lit;
		CPPUNIT_ASSERT_EQUAL(false, cLit.flagged());
	}

	void testEquality() {
		Literal p = posLit(42);
		Literal q = negLit(42);
		CPPUNIT_ASSERT_EQUAL(p, p);
		CPPUNIT_ASSERT_EQUAL(p, ~q);
		CPPUNIT_ASSERT_EQUAL(false, p == q);
		CPPUNIT_ASSERT_EQUAL(Literal(), Literal());
	}

	void testValue() {
		CPPUNIT_ASSERT_EQUAL(value_true, trueValue(lit_true()));
		CPPUNIT_ASSERT_EQUAL(value_false, trueValue(lit_false()));
		CPPUNIT_ASSERT_EQUAL(value_false, falseValue(lit_true()));
		CPPUNIT_ASSERT_EQUAL(value_true, falseValue(lit_false()));
	}

	void testLess() {
		Literal p = posLit(42), q = negLit(42);
		CPPUNIT_ASSERT_EQUAL(false, p < p);
		CPPUNIT_ASSERT_EQUAL(false, q < q);
		CPPUNIT_ASSERT_EQUAL(true, p < q);
		CPPUNIT_ASSERT_EQUAL(false, q < p);

		Literal one(1, false);
		Literal two(2, true);
		Literal negOne = ~one;
		CPPUNIT_ASSERT_EQUAL(true, one < two);
		CPPUNIT_ASSERT_EQUAL(true, negOne < two);
		CPPUNIT_ASSERT_EQUAL(false, two < negOne);
	}

	void testAntecedentNullPointer() {
		Antecedent a;
		Antecedent b( (Constraint*) 0 );
		CPPUNIT_ASSERT_EQUAL(true, a.isNull());
		CPPUNIT_ASSERT_EQUAL(true, b.isNull());
	}

	void testAntecedentPointer() {
		struct Con : Constraint {
			PropResult propagate(Solver&, Literal, uint32&) { return PropResult(true, true); }
			void reason(Solver&, Literal, LitVec&) {}
			Constraint* cloneAttach(Solver&) { return 0; }
		};

		Constraint* c = new Con;
		Antecedent a(c);
		CPPUNIT_ASSERT_EQUAL(false, a.isNull());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Generic, a.type());
		CPPUNIT_ASSERT_EQUAL(c, a.constraint());
		c->destroy();
	}

	void testAntecedentBin() {
		CPPUNIT_ASSERT_EQUAL(true, testBin(max));
		CPPUNIT_ASSERT_EQUAL(true, testBin(min));
		CPPUNIT_ASSERT_EQUAL(true, testBin(mid));
	}

	void testAntecedentTern() {
		CPPUNIT_ASSERT_EQUAL(true, testTern(max, max));
		CPPUNIT_ASSERT_EQUAL(true, testTern(max, mid));
		CPPUNIT_ASSERT_EQUAL(true, testTern(max, min));
		CPPUNIT_ASSERT_EQUAL(true, testTern(mid, max));
		CPPUNIT_ASSERT_EQUAL(true, testTern(mid, mid));
		CPPUNIT_ASSERT_EQUAL(true, testTern(mid, min));
		CPPUNIT_ASSERT_EQUAL(true, testTern(min, max));
		CPPUNIT_ASSERT_EQUAL(true, testTern(min, mid));
		CPPUNIT_ASSERT_EQUAL(true, testTern(min, min));
	}
private:
	Literal min, mid, max;
	bool testBin(const Literal& p) {
		Antecedent ap(p);
		Antecedent aNotp(~p);
		CPPUNIT_ASSERT_EQUAL(false, ap.isNull());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Binary, ap.type());
		CPPUNIT_ASSERT(p == ap.firstLiteral());

		CPPUNIT_ASSERT_EQUAL(false, aNotp.isNull());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Binary, aNotp.type());
		CPPUNIT_ASSERT(~p == aNotp.firstLiteral());
		return true;
	}
	bool testTern(const Literal& p, const Literal& q) {
		Antecedent app(p, q);
		Antecedent apn(p, ~q);
		Antecedent anp(~p, q);
		Antecedent ann(~p, ~q);

		CPPUNIT_ASSERT_EQUAL(false, app.isNull());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Ternary, app.type());
		CPPUNIT_ASSERT_EQUAL(false, apn.isNull());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Ternary, apn.type());
		CPPUNIT_ASSERT_EQUAL(false, anp.isNull());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Ternary, anp.type());
		CPPUNIT_ASSERT_EQUAL(false, ann.isNull());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Ternary, ann.type());

		CPPUNIT_ASSERT(p == app.firstLiteral() && q == app.secondLiteral());
		CPPUNIT_ASSERT(p == apn.firstLiteral() && ~q == apn.secondLiteral());
		CPPUNIT_ASSERT(~p == anp.firstLiteral() && q == anp.secondLiteral());
		CPPUNIT_ASSERT(~p == ann.firstLiteral() && ~q == ann.secondLiteral());
		return true;
	}
};

CPPUNIT_TEST_SUITE_REGISTRATION(LiteralTest);
} }
clasp-3.2.2/libclasp/tests/lpcompare.h000066400000000000000000000057571304134206100177160ustar00rootroot00000000000000// 
// Copyright (c) Benjamin Kaufmann
// 
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef TEST_LPCOMPARE_H_INCLUDED
#define TEST_LPCOMPARE_H_INCLUDED

#include 
#include 
#include 
#include 
#include 
#include 
#include 

namespace Clasp { namespace Test {
inline std::string& trimR(std::string& r) {
	std::string::size_type p = r.find_last_not_of(" ");
	if (p != r.size() - 1) {
		r.erase(p+1);
	}
	return r;
}
inline bool compareProgram(std::stringstream& exp, std::stringstream& actual) {
	std::vector lines;
	if (!exp) return !actual;
	while (exp) {
		for (std::string r; std::getline(exp, r) && r != "0";) {
			lines.push_back(trimR(r));
		}
		for (std::string r; std::getline(actual, r) && r != "0";) {
			std::vector::iterator it = std::find(lines.begin(), lines.end(), trimR(r));
			if (it == lines.end()) { return false; }
			lines.erase(it);
		}
		if (!lines.empty()) { return false; }
	}
	return true;
}
inline bool findProgram(std::stringstream& what, std::stringstream& actual) {
	std::vector lines;
	for (std::string r; std::getline(what, r);) {
		if (r != "0") { lines.push_back(trimR(r)); }
	}
	for (std::string r; std::getline(actual, r) && !lines.empty();) {
		std::vector::iterator it;
		if (r != "0" && (it = std::find(lines.begin(), lines.end(), trimR(r))) != lines.end()) {
			lines.erase(it);
		}
	}
	return lines.empty();
}
inline bool compareSmodels(std::stringstream& exp, Asp::LogicProgram& prg) {
	std::stringstream str;
	AspParser::write(prg, str, AspParser::format_smodels);
	return compareProgram(exp, str);
}
inline bool findSmodels(std::stringstream& exp, Asp::LogicProgram& prg) {
	std::stringstream str;
	AspParser::write(prg, str, AspParser::format_smodels);
	return findProgram(exp, str);
}
struct NoStep : Asp::LogicProgramAdapter {
	NoStep(Asp::LogicProgram& p) : Asp::LogicProgramAdapter(p) {}
	void initProgram(bool) {}
	void beginStep()       {}
	void endStep()         {}
};
inline void lpAdd(Asp::LogicProgram& lp, const char* prg) {
	NoStep adapt(lp);
	Potassco::AspifTextInput input(&adapt);
	std::stringstream str;
	str << prg << "\n";
	CLASP_FAIL_IF(!input.accept(str) || !input.parse(), "invalid program");
}

}}
#endif
clasp-3.2.2/libclasp/tests/minimize_test.cpp000066400000000000000000001253571304134206100211460ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifdef _MSC_VER
#pragma warning (disable : 4996) // std::equal may be unsafe
#endif
#include "test.h"
#include 
#include 
#include 
#include 
namespace Clasp { namespace Test {
class DefaultMinimizeTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(DefaultMinimizeTest);
	CPPUNIT_TEST(testEmpty);
	CPPUNIT_TEST(testEmptyMultiLevel);
	CPPUNIT_TEST(testOneLevelLits);
	CPPUNIT_TEST(testMultiLevelLits);
	CPPUNIT_TEST(testMultiLevelWeightsAreReused);
	CPPUNIT_TEST(testMergeComplementaryLits);
	CPPUNIT_TEST(testMergeComplementaryLits2);
	CPPUNIT_TEST(testMergeComplementaryLits3);
	CPPUNIT_TEST(testInitFromOther);
	CPPUNIT_TEST(testNegativeLowerInit);
	CPPUNIT_TEST(testNegativeLower);

	CPPUNIT_TEST(testOrder);
	CPPUNIT_TEST(testSkipLevel);
	CPPUNIT_TEST(testReassertAfterBacktrack);
	CPPUNIT_TEST(testConflict);
	CPPUNIT_TEST(testOptimize);
	CPPUNIT_TEST(testEnumerate);
	CPPUNIT_TEST(testComputeImplicationLevel);
	CPPUNIT_TEST(testSetModelMayBacktrackMultiLevels);
	CPPUNIT_TEST(testPriorityBug);
	CPPUNIT_TEST(testStrengthenImplication);
	CPPUNIT_TEST(testRootLevelMadness);
	CPPUNIT_TEST(testIntegrateOptimum);
	CPPUNIT_TEST(testIntegrateOptimumConflict);
	CPPUNIT_TEST(testIntegrateBug);

	CPPUNIT_TEST(testReasonBug);
	CPPUNIT_TEST(testSmartBacktrack);
	CPPUNIT_TEST(testBacktrackToTrue);
	CPPUNIT_TEST(testMultiAssignment);
	CPPUNIT_TEST(testBugBacktrackFromFalse);
	CPPUNIT_TEST(testBugBacktrackToTrue);
	CPPUNIT_TEST(testBugInitOptHierarch);
	CPPUNIT_TEST(testBugAdjustSum);
	CPPUNIT_TEST(testWeightNullBug);
	CPPUNIT_TEST(testAdjust);
	CPPUNIT_TEST(testAdjustFact);
	CPPUNIT_TEST(testAssumption);

	CPPUNIT_TEST(testHierarchicalSetModel);
	CPPUNIT_TEST(testHierarchical);
	CPPUNIT_TEST(testInconsistent);
	CPPUNIT_TEST_SUITE_END();
public:
	DefaultMinimizeTest() {
		a = posLit(ctx.addVar(Var_t::Atom));
		b = posLit(ctx.addVar(Var_t::Atom));
		c = posLit(ctx.addVar(Var_t::Atom));
		d = posLit(ctx.addVar(Var_t::Atom));
		e = posLit(ctx.addVar(Var_t::Atom));
		f = posLit(ctx.addVar(Var_t::Atom));
		x = posLit(ctx.addVar(Var_t::Atom));
		y = posLit(ctx.addVar(Var_t::Atom));
		ctx.startAddConstraints();
	}
	void setUp()    { newMin = 0; data = 0; }
	void tearDown() {
		if (newMin) { newMin->destroy(ctx.master(), true);  }
		if (data)   { data->release(); }
	}
	void testEmpty() {
		MinimizeBuilder b;
		CPPUNIT_ASSERT(!b.build(ctx));
	}
	void testEmptyMultiLevel() {
		MinimizeBuilder x;
		x.add(0, WeightLiteral(posLit(0), 1));
		x.add(1, WeightLiteral(posLit(0), 1));
		data = x.build(ctx);
		CPPUNIT_ASSERT(isSentinel(data->lits[0].first));
		CPPUNIT_ASSERT(data->lits[0].second == 0);
		CPPUNIT_ASSERT(data->weights.size() == 1);
	}

	void testOneLevelLits() {
		WeightLitVec min;
		ctx.addUnary(c);
		ctx.addUnary(~e);
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(b, 2) );
		min.push_back( WeightLiteral(c, 1) ); // true lit
		min.push_back( WeightLiteral(a, 2) ); // duplicate lit
		min.push_back( WeightLiteral(d, 1) );
		min.push_back( WeightLiteral(e, 2) ); // false lit
		newMin = buildAndAttach(MinimizeBuilder().add(0, min));
		CPPUNIT_ASSERT(newMin->numRules() == 1);
		CPPUNIT_ASSERT(countMinLits() == 3);
		CPPUNIT_ASSERT(newMin->shared()->adjust(0) == 1);
		const SharedMinimizeData* data = newMin->shared();
		CPPUNIT_ASSERT(data->lits[0].first == a && data->lits[0].second == 3);
		for (const WeightLiteral* it = data->lits; !isSentinel(it->first); ++it) {
			CPPUNIT_ASSERT_MESSAGE("Minimize lits not sorted!", it->second >= (it+1)->second);
			CPPUNIT_ASSERT(ctx.master()->hasWatch(it->first, newMin));
			CPPUNIT_ASSERT(ctx.varInfo(it->first.var()).frozen());
		}
		newMin->destroy(ctx.master(), true);
		newMin = 0;
		CPPUNIT_ASSERT(!ctx.master()->hasWatch(a, newMin));
	}

	void testMultiLevelLits() {
		MinimizeBuilder builder;
		WeightLitVec min;
		ctx.addUnary(c);
		ctx.addUnary(~e);
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(b, 1) );
		min.push_back( WeightLiteral(c, 1) ); // true lit
		min.push_back( WeightLiteral(b, 2) ); // duplicate lit
		min.push_back( WeightLiteral(d, 1) );
		min.push_back( WeightLiteral(b, 1) ); // duplicate lit

		builder.add(3, min);
		min.clear();
		min.push_back( WeightLiteral(e, 2) ); // false lit
		min.push_back( WeightLiteral(f, 1) );
		min.push_back( WeightLiteral(x, 2) );
		min.push_back( WeightLiteral(y, 3) );
		min.push_back( WeightLiteral(b, 1) ); // duplicate lit
		builder.add(2, min);
		min.clear();
		min.push_back( WeightLiteral(b, 2) ); // duplicate lit
		min.push_back( WeightLiteral(a, 1) ); // duplicate lit
		min.push_back( WeightLiteral(a, 2) ); // duplicate lit
		min.push_back( WeightLiteral(c, 2) ); // true lit
		min.push_back( WeightLiteral(d, 1) ); // duplicate lit
		builder.add(1, min);

		newMin = buildAndAttach(builder);
		CPPUNIT_ASSERT(newMin->numRules() == 3);
		CPPUNIT_ASSERT(countMinLits() == 6);
		const SharedMinimizeData* data = newMin->shared();
		CPPUNIT_ASSERT(data->adjust(0) == 1 && data->adjust(1) == 0 && data->adjust(2) == 2);
		CPPUNIT_ASSERT(data->lits[0].first == b);
		CPPUNIT_ASSERT(data->weights.size() == 11);
		for (const WeightLiteral* it = data->lits; !isSentinel(it->first); ++it) {
			CPPUNIT_ASSERT(ctx.master()->hasWatch(it->first, newMin));
		}
	}

	void testMultiLevelWeightsAreReused() {
		MinimizeBuilder builder;
		WeightLitVec min;
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(b, 1) );
		min.push_back( WeightLiteral(b, 2) );
		min.push_back( WeightLiteral(c, 1) );
		min.push_back( WeightLiteral(d, 3) );
		builder.add(3, min);

		min.clear();
		min.push_back( WeightLiteral(b, 1) );
		min.push_back( WeightLiteral(d, 1) );
		builder.add(2, min);

		newMin = buildAndAttach(builder);
		// b = 0
		// d = 0
		// a = 2
		// c = 2
		// weights: [(0,3)(1,1)][(0,1)] + [(1,0)] for sentinel
		CPPUNIT_ASSERT(newMin->shared()->weights.size() == 4);
	}

	void testMergeComplementaryLits() {
		MinimizeBuilder builder;
		WeightLitVec min;
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(b, 1) );
		min.push_back( WeightLiteral(c, 2) );
		min.push_back( WeightLiteral(d, 1) );
		min.push_back( WeightLiteral(~d, 2) );
		builder.add(2, min);
		min.clear();
		min.push_back( WeightLiteral(~c, 1) );
		min.push_back( WeightLiteral(e, 1) );
		builder.add(1, min);
		newMin = buildAndAttach(builder);
		CPPUNIT_ASSERT(countMinLits() == 5);
		CPPUNIT_ASSERT(newMin->shared()->adjust(0) == 1 && newMin->shared()->adjust(1) == 1);

		ctx.master()->assume(c) && ctx.master()->propagate();
		CPPUNIT_ASSERT(newMin->sum(1, true) == 0);

	}

	void testMergeComplementaryLits2() {
		MinimizeBuilder builder;
		WeightLitVec min;
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(~a, 1) );
		builder.add(2, min);
		min.clear();
		min.push_back( WeightLiteral(a, 1) );
		builder.add(1, min);
		newMin = buildAndAttach(builder);
		CPPUNIT_ASSERT(countMinLits() == 1);
		CPPUNIT_ASSERT(newMin->shared()->adjust(0) == 1 && newMin->shared()->adjust(1) == 0);
	}
	void testMergeComplementaryLits3() {
		MinimizeBuilder builder;
		WeightLitVec min;
		min.push_back( WeightLiteral(~a, 2) );
		min.push_back( WeightLiteral(~a, -3));
		builder.add(1, min);
		min.clear();
		min.push_back(WeightLiteral(~a, 1) );
		min.push_back(WeightLiteral(a, -4) );
		builder.add(0, min);
		newMin = buildAndAttach(builder);
		CPPUNIT_ASSERT(countMinLits() == 1);
		CPPUNIT_ASSERT(newMin->shared()->lits[0].first == a);
		CPPUNIT_ASSERT(newMin->shared()->adjust(0) == -1 && newMin->shared()->adjust(1) == 1);
		CPPUNIT_ASSERT(newMin->shared()->weights[0].weight == 1);
		CPPUNIT_ASSERT(newMin->shared()->weights[1].weight == -5);
	}
	void testInitFromOther() {
		MinimizeBuilder builder;
		WeightLitVec min;
		min.push_back( WeightLiteral(~a, 2) );
		min.push_back( WeightLiteral(~a, -3));
		builder.add(1, min);
		builder.add(1, CLASP_WEIGHT_T_MIN);
		min.clear();
		min.push_back(WeightLiteral(~a, 1) );
		min.push_back(WeightLiteral(a, -4) );
		builder.add(0, min);
		builder.add(0, CLASP_WEIGHT_T_MAX);
		SharedMinimizeData* d1 = builder.build(ctx);
		builder.clear();
		builder.add(*d1);
		SharedMinimizeData* d2 = builder.build(ctx);
		CPPUNIT_ASSERT(d1->numRules() == d2->numRules());
		CPPUNIT_ASSERT(std::equal(d1->adjust(), d1->adjust() + d1->numRules(), d2->adjust()));
		CPPUNIT_ASSERT(d1->weights.size() == d2->weights.size());
		for (uint32 i = 0, end = (uint32)d1->weights.size(); i != end; ++i) {
			CPPUNIT_ASSERT(d1->weights[i].level == d2->weights[i].level && d1->weights[i].weight == d2->weights[i].weight && d1->weights[i].next == d2->weights[i].next);
		}
		for (const WeightLiteral* it = d1->lits, *oit = d2->lits; !isSentinel(it->first); ++it, ++oit) {
			CPPUNIT_ASSERT(*it == *oit);
		}
		d1->release();
		d2->release();
	}
	void testNegativeLowerInit() {
		WeightLitVec aMin, bMin, cMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(~a, 1) );
		bMin.push_back( WeightLiteral(~b, 1) );
		cMin.push_back( WeightLiteral(a, 1) );
		cMin.push_back( WeightLiteral(b, 1) );
		data = MinimizeBuilder()
			.add(3, aMin)
			.add(2, bMin)
			.add(1, cMin)
			.build(ctx);
		CPPUNIT_ASSERT(data->lower(0) == 0);
		CPPUNIT_ASSERT(data->lower(1) == -2);
		CPPUNIT_ASSERT(data->lower(2) == 0);
	}
	void testNegativeLower() {
		ctx.addBinary(a, b);
		WeightLitVec aMin, bMin, cMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(~a, 1) );
		cMin.push_back( WeightLiteral(a, 1) );
		data = MinimizeBuilder()
			.add(3, aMin)
			.add(2, bMin)
			.add(1, cMin)
			.build(ctx);
		newMin = createMin(ctx, *ctx.master(), data, MinimizeMode_t::bb_step_hier);
		newMin->integrateBound(*ctx.master());

		Solver& s = *ctx.master();
		s.assume(b) && s.propagate();
		s.assume(~a) && s.propagate();
		newMin->handleModel(s);
		s.undoUntil(0);
		CPPUNIT_ASSERT(!newMin->integrate(s) || !s.propagate());
		LitVec ignore;
		CPPUNIT_ASSERT(newMin->handleUnsat(s, true, ignore));
		CPPUNIT_ASSERT(newMin->integrate(s) && s.propagate());

		CPPUNIT_ASSERT(s.isFalse(b));
		CPPUNIT_ASSERT(s.assume(a) && s.propagate());
		newMin->handleModel(s);
	}

	void testOrder() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		bMin.push_back( WeightLiteral(b, 1) );
		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin));

		Solver& solver = *ctx.master();
		solver.assume(b);
		CPPUNIT_ASSERT_EQUAL(true, solver.propagate());
		solver.assume(~a);
		CPPUNIT_ASSERT_EQUAL(true, solver.propagate());
		CPPUNIT_ASSERT(newMin->sum(0, true) == 0 && newMin->sum(1, true) == 1);
		newMin->commitUpperBound(solver);
		CPPUNIT_ASSERT(newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.isFalse(a));
		CPPUNIT_ASSERT(solver.isFalse(b));
		CPPUNIT_ASSERT(solver.decisionLevel() == 0);
	}

	void testSkipLevel() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(c, 2) );
		aMin.push_back( WeightLiteral(d, 1) );
		aMin.push_back( WeightLiteral(e, 2) );

		bMin.push_back( WeightLiteral(a, 1) );
		bMin.push_back( WeightLiteral(b, 1) );

		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~d) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());
		solver.force(~e, 0); solver.propagate();
		newMin->commitUpperBound(solver);
		solver.backtrack();
		solver.force(e, 0);
		CPPUNIT_ASSERT_EQUAL(true, newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.decisionLevel() == 2 && solver.backtrackLevel() == 2);
		CPPUNIT_ASSERT(solver.isFalse(c) && solver.isFalse(e));
		solver.backtrack();
	}

	void testReassertAfterBacktrack() {
		WeightLitVec aMin;
		aMin.push_back( WeightLiteral(x, 1) );
		aMin.push_back( WeightLiteral(y, 1) );
		newMin = buildAndAttach(MinimizeBuilder().add(0, aMin));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~x) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(y) && solver.propagate());
		newMin->commitUpperBound(solver);
		solver.undoUntil(1);
		// disable backjumping
		solver.setBacktrackLevel(1, Solver::undo_pop_proj_level);
		CPPUNIT_ASSERT_EQUAL(true, newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.decisionLevel() == 1 && solver.isTrue(~x));
		solver.backtrack();
		CPPUNIT_ASSERT(solver.decisionLevel() == 0 && solver.isTrue(~x));
	}

	void testConflict() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(c, 2) );
		aMin.push_back( WeightLiteral(d, 1) );
		aMin.push_back( WeightLiteral(e, 2) );

		bMin.push_back( WeightLiteral(a, 1) );
		bMin.push_back( WeightLiteral(b, 1) );

		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin));
		Solver& solver = *ctx.master();

		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~d) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());
		solver.force(~e, 0); solver.propagate();
		newMin->commitUpperBound(solver);
		solver.undoUntil(0);
		CPPUNIT_ASSERT_EQUAL(true, newMin->integrateBound(solver));
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		solver.force(c, 0);
		solver.force(d, 0);
		CPPUNIT_ASSERT_EQUAL(false, solver.propagate());
		const LitVec& cfl = solver.conflict();
		CPPUNIT_ASSERT(cfl.size() == 3);
		CPPUNIT_ASSERT(std::find(cfl.begin(), cfl.end(), a) != cfl.end());
		CPPUNIT_ASSERT(std::find(cfl.begin(), cfl.end(), c) != cfl.end());
		CPPUNIT_ASSERT(std::find(cfl.begin(), cfl.end(), d) != cfl.end());
	}

	void testOptimize() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(c, 1) );
		bMin.push_back( WeightLiteral(d, 1) );
		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());
		CPPUNIT_ASSERT(newMin->shared()->optimum(0) == SharedMinimizeData::maxBound());
		newMin->commitUpperBound(solver);
		CPPUNIT_ASSERT(newMin->shared()->optimum(0) != SharedMinimizeData::maxBound());
		solver.undoUntil(0);
		CPPUNIT_ASSERT_EQUAL(true, newMin->integrateBound(solver));
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(d) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~a));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~b));
		CPPUNIT_ASSERT_EQUAL(value_free, solver.value(c.var()));
	}

	void testEnumerate() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(c, 1) );
		bMin.push_back( WeightLiteral(d, 1) );
		wsum_t bound[2] = {1,1};
		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin)
			, MinimizeMode_t::enumerate, bound, 2);

		CPPUNIT_ASSERT(newMin->shared()->optimum(0) == SharedMinimizeData::maxBound());
		CPPUNIT_ASSERT(newMin->shared()->sum(0) == SharedMinimizeData::maxBound());
		CPPUNIT_ASSERT(newMin->shared()->upper(0) == 1);
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.propagate());

		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());

		newMin->commitUpperBound(solver);
		solver.undoUntil(0);
		newMin->relaxBound();
		newMin->integrateBound(solver);
		CPPUNIT_ASSERT(solver.queueSize() == 0);

		CPPUNIT_ASSERT_EQUAL(true, solver.assume(d) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT(solver.isTrue(~c));
		CPPUNIT_ASSERT(solver.isTrue(~a));
	}

	void testComputeImplicationLevel() {
		WeightLitVec aMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		aMin.push_back( WeightLiteral(c, 1) );
		aMin.push_back( WeightLiteral(d, 2) );
		newMin = buildAndAttach(MinimizeBuilder()
			.add(0, aMin));
		Solver& solver = *ctx.master();
		solver.assume(a) && solver.propagate();
		solver.force(b,0)&& solver.propagate();
		solver.assume(c) && solver.propagate();
		solver.force(~d,0) && solver.propagate();
		newMin->commitUpperBound(solver);
		solver.undoUntil(1u);
		CPPUNIT_ASSERT(newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.isFalse(d));
		LitVec r1, r2;
		solver.reason(~d, r1);
		solver.undoUntil(0);
		solver.assume(a) && solver.propagate();
		solver.reason(~d, r2);
		CPPUNIT_ASSERT(r2.size() <= r1.size() && r2.size() == 1);
		CPPUNIT_ASSERT(r1[0] == r2[0]);
		CPPUNIT_ASSERT(r1.size() == 1 || b == r1[1]);
		CPPUNIT_ASSERT_MESSAGE("TODO: REASON CORRECT BUT NOT MINIMAL!", r1.size() == r2.size());
	}

	void testSetModelMayBacktrackMultiLevels() {
		WeightLitVec aMin;
		aMin.push_back( WeightLiteral(a, 1) );
		newMin = buildAndAttach(MinimizeBuilder().add(0, aMin));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());
		newMin->commitUpperBound(solver);
		newMin->integrateBound(solver);
		CPPUNIT_ASSERT(solver.decisionLevel() == 0);
	}

	void testPriorityBug() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		aMin.push_back( WeightLiteral(c, 1) );
		bMin.push_back( WeightLiteral(d, 1) );
		bMin.push_back( WeightLiteral(e, 1) );
		bMin.push_back( WeightLiteral(f, 1) );
		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(e) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(f) && solver.propagate());
		newMin->commitUpperBound(solver);
		solver.backtrack();
		// disbale backjumping
		solver.setBacktrackLevel(2, Solver::undo_pop_proj_level);
		CPPUNIT_ASSERT_EQUAL(true, newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.decisionLevel() == 2);
		solver.backtrack();
		CPPUNIT_ASSERT_EQUAL(true, solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(d) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~b));
		LitVec r;
		solver.reason(~b, r);
		CPPUNIT_ASSERT(LitVec::size_type(1) == r.size());
		CPPUNIT_ASSERT(a == r[0]);
	}

	void testStrengthenImplication() {
		WeightLitVec aMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 2) );
		aMin.push_back( WeightLiteral(c, 1) );
		wsum_t bound   = 2;
		newMin         = buildAndAttach(MinimizeBuilder().add(0, aMin), MinimizeMode_t::optimize, &bound, 1);
		Solver& solver = *ctx.master();
		solver.assume(a) && solver.propagate();
		solver.setBacktrackLevel(1, Solver::undo_pop_proj_level);
		CPPUNIT_ASSERT(solver.isTrue(~b));
		LitVec r;
		solver.reason(~b, r);
		CPPUNIT_ASSERT(r.size() == 1 && r[0] == a);
		solver.assume(x) && solver.propagate();
		solver.assume(y) && solver.propagate();
		solver.assume(c) && solver.propagate();
		solver.assume(e) && solver.propagate();
		newMin->commitUpperBound(solver);
		solver.undoUntil(3);
		CPPUNIT_ASSERT(newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.decisionLevel() == 1 && solver.isTrue(~b));
		r.clear();
		solver.reason(~b, r);
		CPPUNIT_ASSERT(r.empty() || (r.size() == 1 && r[0] == lit_true()));
	}

	void testRootLevelMadness() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 2) );
		aMin.push_back( WeightLiteral(c, 1) );
		bMin.push_back( WeightLiteral(d, 1) );
		bMin.push_back( WeightLiteral(e, 2) );
		bMin.push_back( WeightLiteral(f, 1) );
		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin));
		Solver& solver = *ctx.master();
		solver.assume(a) && solver.propagate();
		solver.assume(c) && solver.propagate();
		solver.pushRootLevel(2);
		SumVec opt(newMin->numRules());
		opt[0] = 2;
		opt[1] = 3;
		setOptimum(solver, opt, false);
		LitVec r;
		CPPUNIT_ASSERT(solver.isFalse(b));
		solver.reason(~b, r);
		CPPUNIT_ASSERT(r.size() == 1 && r[0] == a);
		solver.clearAssumptions();
		solver.assume(d) && solver.propagate();
		solver.assume(e) && solver.propagate();
		solver.assume(f) && solver.propagate();
		solver.pushRootLevel(3);
		opt[0] = 2;
		opt[1] = 2;
		setOptimum(solver, opt, false);
		CPPUNIT_ASSERT(solver.isFalse(b));
		r.clear();
		solver.reason(~b, r);
		CPPUNIT_ASSERT(r.size() == 2 && r[0] == d && r[1] == e);
	}

	void testIntegrateOptimum() {
		WeightLitVec aMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		aMin.push_back( WeightLiteral(c, 1) );
		aMin.push_back( WeightLiteral(d, 1) );
		Solver& solver = *ctx.master();
		data   = MinimizeBuilder().add(0, aMin).build(ctx);
		newMin = createMin(ctx, solver, data);
		newMin->integrateBound(solver);
		solver.assume(a) && solver.propagate();
		solver.assume(e) && solver.propagate();
		solver.assume(b) && solver.propagate();
		solver.assume(f) && solver.propagate();
		solver.assume(c) && solver.propagate();

		SumVec opt(data->numRules());
		opt[0] = 2;
		CPPUNIT_ASSERT(setOptimum(solver, opt, true));
		CPPUNIT_ASSERT(solver.decisionLevel() == 1 && solver.queueSize() == 3);
		newMin->destroy(&solver, true);
		newMin = 0;
	}

	void testIntegrateOptimumConflict() {
		WeightLitVec aMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		aMin.push_back( WeightLiteral(c, 1) );
		aMin.push_back( WeightLiteral(d, 1) );
		Solver& solver = *ctx.master();
		data = MinimizeBuilder().add(0, aMin).build(ctx);
		SumVec opt(data->numRules());
		newMin = createMin(ctx, solver, data);
		newMin->integrateBound(solver);
		solver.assume(a) && solver.propagate();
		solver.assume(e) && solver.propagate();
		solver.assume(b) && solver.propagate();
		solver.assume(f) && solver.propagate();
		solver.assume(c) && solver.propagate();
		solver.setBacktrackLevel(1, Solver::undo_pop_proj_level);
		opt[0] = 2;
		CPPUNIT_ASSERT(setOptimum(solver, opt, true));
		CPPUNIT_ASSERT(solver.decisionLevel() == 1 && solver.queueSize() >= 3);
		solver.propagate();
		opt[0] = 0;
		CPPUNIT_ASSERT(!setOptimum(solver, opt, true));
		CPPUNIT_ASSERT(solver.hasConflict());
		CPPUNIT_ASSERT(solver.clearAssumptions());
		CPPUNIT_ASSERT(newMin->integrateBound(solver) == false && solver.hasConflict());
		CPPUNIT_ASSERT(!solver.resolveConflict());
		newMin->destroy(&solver, true);
		newMin = 0;
	}
	void testIntegrateBug() {
		WeightLitVec min;
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(b, 1) );
		min.push_back( WeightLiteral(c, 1) );
		data   = MinimizeBuilder().add(0, min).build(ctx);
		wsum_t bound = 2;
		Solver& s = *ctx.master();
		newMin = createMin(ctx, s, data, MinimizeMode_t::bb_step_dec);
		data->setMode(MinimizeMode_t::optimize, &bound, 1);
		s.pushRoot(s.tagLiteral());
		s.pushRoot(a);
		s.pushRoot(b);
		s.pushRoot(c);
		CPPUNIT_ASSERT(!newMin->integrateBound(s));
	}
	void testReasonBug() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(d, 2) );
		bMin.push_back( WeightLiteral(e, 1) );
		bMin.push_back( WeightLiteral(f, 3) );

		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(d) && solver.propagate());
		newMin->commitUpperBound(solver);
		solver.backtrack();
		CPPUNIT_ASSERT_EQUAL(true, newMin->integrateBound(solver));
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(e) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~f));
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());
		solver.backtrack();
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~f));
		LitVec r;
		solver.reason(~f, r);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), e) == r.end());
	}

	void testSmartBacktrack() {
		WeightLitVec aMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		aMin.push_back( WeightLiteral(c, 1) );
		newMin = buildAndAttach(MinimizeBuilder().add(0, aMin));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~c) && solver.propagate());

		newMin->commitUpperBound(solver);
		CPPUNIT_ASSERT_EQUAL(true, newMin->integrateBound(solver));

		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~b));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~c));
	}

	void testBacktrackToTrue() {
		WeightLitVec min1, min2;
		min1.push_back( WeightLiteral(a, 1) );
		min2.push_back( WeightLiteral(b, 1) );
		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, min1)
			.add(1, min2));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.force(b, 0) && solver.propagate());

		newMin->commitUpperBound(solver);
		solver.backtrack();
		CPPUNIT_ASSERT_EQUAL(false, newMin->integrateBound(solver));
	}

	void testMultiAssignment() {
		WeightLitVec min1, min2;
		min1.push_back( WeightLiteral(a, 1) );
		min1.push_back( WeightLiteral(b, 1) );
		min1.push_back( WeightLiteral(c, 1) );
		min1.push_back( WeightLiteral(d, 1) );
		min1.push_back( WeightLiteral(e, 1) );

		min2.push_back( WeightLiteral(f, 1) );

		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, min1)
			.add(1, min2));
		Solver& solver = *ctx.master();
		SumVec opt(newMin->numRules());
		opt[0] = 3;
		opt[1] = 0;
		CPPUNIT_ASSERT_EQUAL(true, setOptimum(solver, opt, false));

		solver.assume(f);
		solver.force(a, 0);
		solver.force(b, 0);
		solver.force(c, 0);

		CPPUNIT_ASSERT_EQUAL(false, solver.propagate());
	}

	void testBugBacktrackFromFalse() {
		WeightLitVec min1, min2;
		min1.push_back( WeightLiteral(a, 1) );
		min1.push_back( WeightLiteral(b, 1) );
		min1.push_back( WeightLiteral(c, 1) );
		min2.push_back( WeightLiteral(d, 1) );
		min2.push_back( WeightLiteral(e, 1) );
		min2.push_back( WeightLiteral(f, 1) );

		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, min1)
			.add(1, min2));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(x) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.force(~c,0) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(y) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.force(d,0) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.force(e,0) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.force(~f,0) && solver.propagate());

		newMin->commitUpperBound(solver);
		solver.undoUntil(3);
		solver.setBacktrackLevel(3, Solver::undo_pop_proj_level);
		CPPUNIT_ASSERT(newMin->integrateBound(solver));
		CPPUNIT_ASSERT_EQUAL(true, solver.force(f,0) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~d));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~e));

		newMin->commitUpperBound(solver);
		solver.undoUntil(2);
		solver.backtrack();
		CPPUNIT_ASSERT(newMin->integrateBound(solver));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~x));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~f));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~d));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~e));
		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue(~c));
	}

	void testBugBacktrackToTrue() {
		WeightLitVec min1, min2;
		min1.push_back( WeightLiteral(a, 1) );
		min1.push_back( WeightLiteral(b, 1) );
		min1.push_back( WeightLiteral(~b, 2) );
		min2.push_back( WeightLiteral(a, 1) );
		min2.push_back( WeightLiteral(b, 1) );
		min2.push_back( WeightLiteral(c, 1) );

		newMin = buildAndAttach(MinimizeBuilder()
			.add(2, min1)
			.add(1, min2));
		Solver& solver = *ctx.master();

		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());

		newMin->commitUpperBound(solver);
		CPPUNIT_ASSERT(newMin->integrateBound(solver) && 1 == solver.decisionLevel());
		CPPUNIT_ASSERT(solver.propagate());

		newMin->commitUpperBound(solver);
		solver.undoUntil(0);
		CPPUNIT_ASSERT(newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.isTrue(~a));
		CPPUNIT_ASSERT(solver.value(b.var()) == value_free);
	}

	void testBugInitOptHierarch() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(c, 1) );
		bMin.push_back( WeightLiteral(d, 1) );
		data = MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin)
			.build(ctx);
		wsum_t bound[2] = {wsum_t(1),wsum_t(1)};
		data->setMode(MinimizeMode_t::optimize, bound, 2);
		newMin = createMin(ctx, *ctx.master(), data, MinimizeMode_t::bb_step_hier);
		newMin->integrateBound(*ctx.master());
		CPPUNIT_ASSERT(ctx.master()->value(a.var()) == value_free);
		ctx.master()->assume(a) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(b));
		CPPUNIT_ASSERT(ctx.master()->value(c.var()) == value_free);
		ctx.master()->assume(c) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(d));
	}

	void testBugAdjustSum() {
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(~a, 1) );
		bMin.push_back( WeightLiteral(d, 1) );
		data = MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin)
			.build(ctx);
		newMin = static_cast(data->attach(*ctx.master(), MinimizeMode_t::opt_bb));
		SumVec opt;
		opt.push_back(1);
		opt.push_back(1);
		setOptimum(*ctx.master(), opt, true);
		// a ~b ~d is a valid model!
		CPPUNIT_ASSERT(ctx.master()->value(a.var()) == value_free);
		CPPUNIT_ASSERT(ctx.master()->assume(a) && ctx.master()->propagate());
		CPPUNIT_ASSERT(ctx.master()->assume(~b) && ctx.master()->propagate());
		CPPUNIT_ASSERT(ctx.master()->assume(~d) && ctx.master()->propagate());
	}

	void testWeightNullBug() {
		WeightLitVec min1;
		min1.push_back( WeightLiteral(a, 1) );
		min1.push_back( WeightLiteral(b, 0) );
		newMin = buildAndAttach(MinimizeBuilder().add(0, min1));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.force(~c,0) && solver.propagate());
		newMin->commitUpperBound(solver);
		newMin->integrateBound(solver);
		CPPUNIT_ASSERT(0u == solver.decisionLevel() && solver.isFalse(a));
	}

	void testAdjust() {
		WeightLitVec min1;
		min1.push_back( WeightLiteral(a, 1) );
		min1.push_back( WeightLiteral(b, 1) );
		newMin = buildAndAttach(MinimizeBuilder().add(0, min1).add(0, -2));
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		newMin->commitUpperBound(solver);
		CPPUNIT_ASSERT(0 == newMin->shared()->optimum(0));

		solver.clearAssumptions();
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~a) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(~b) && solver.propagate());
		newMin->commitUpperBound(solver);
		CPPUNIT_ASSERT(-2 == newMin->shared()->optimum(0));
	}

	void testAdjustFact() {
		WeightLitVec min1;
		min1.push_back( WeightLiteral(a, 2) );
		min1.push_back( WeightLiteral(b, 1) );
		min1.push_back( WeightLiteral(c, 1) );
		min1.push_back( WeightLiteral(d, 1) );
		data = MinimizeBuilder().add(0, min1).add(0, -2).build(ctx);
		Solver& solver = *ctx.master();
		ctx.addUnary(a);
		solver.propagate();
		newMin = createMin(ctx, solver, data);
		newMin->integrateBound(solver);
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(b) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(c) && solver.propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver.assume(d) && solver.propagate());
		newMin->commitUpperBound(solver);
		newMin->integrateBound(solver);
		CPPUNIT_ASSERT(2 == solver.decisionLevel());
	}

	void testAssumption() {
		SharedContext ctx;
		a = posLit(ctx.addVar(Var_t::Atom));
		b = posLit(ctx.addVar(Var_t::Atom));
		c = posLit(ctx.addVar(Var_t::Atom));
		ctx.startAddConstraints();
		WeightLitVec min1;
		min1.push_back( WeightLiteral(a, 1) );
		min1.push_back( WeightLiteral(b, 1) );
		min1.push_back( WeightLiteral(c, 1) );
		Solver& solver = *ctx.master();
		data   = MinimizeBuilder().add(0, min1).build(ctx);
		newMin = createMin(ctx, solver, data, MinimizeMode_t::bb_step_inc);
		Literal minAssume = posLit(solver.pushTagVar(true));
		SumVec opt(1, 0);
		setOptimum(solver, opt, false);
		CPPUNIT_ASSERT(solver.isFalse(a) && solver.reason(~a).constraint() == newMin);
		CPPUNIT_ASSERT(solver.isFalse(b) && solver.reason(~b).constraint() == newMin);
		CPPUNIT_ASSERT(solver.isFalse(c) && solver.reason(~c).constraint() == newMin);

		LitVec r;
		solver.reason(~a, r);
		CPPUNIT_ASSERT(r.size() == 1 && r[0] == minAssume);

		solver.clearAssumptions();
		CPPUNIT_ASSERT(solver.numAssignedVars() == 0);
	}

	void testHierarchicalSetModel() {
		WeightLitVec min;
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(b, 1) );
		min.push_back( WeightLiteral(c, 1) );
		MinimizeBuilder builder;
		builder.add(2, min);
		min.clear();
		min.push_back( WeightLiteral(d, 1) );
		min.push_back( WeightLiteral(e, 1) );
		min.push_back( WeightLiteral(f, 1) );
		builder.add(0, min);
		Solver& solver = *ctx.master();
		data   = builder.build(ctx);
		newMin = createMin(ctx, solver, data, MinimizeMode_t::bb_step_hier);
		newMin->integrateBound(solver);
		solver.assume(a); solver.propagate();
		solver.assume(b); solver.propagate();
		solver.assume(c); solver.propagate();
		solver.assume(d); solver.propagate();
		solver.assume(e); solver.propagate();
		solver.assume(f); solver.propagate();
		newMin->commitUpperBound(solver);
		solver.undoUntil(solver.level(b.var()));
		newMin->integrateBound(solver);
		CPPUNIT_ASSERT(solver.isFalse(c));
		CPPUNIT_ASSERT(solver.numAssignedVars() == 4);
	}

	void testHierarchical() {
		MinimizeBuilder builder;
		WeightLitVec min;
		min.push_back( WeightLiteral(a, 1) );
		builder.add(2, min);
		min.clear();
		min.push_back( WeightLiteral(~b, 1) );
		builder.add(1, min);

		ctx.addBinary(~a, b);
		ctx.addBinary(a, ~b);
		Solver& solver = *ctx.master();
		data   = builder.build(ctx);
		newMin = createMin(ctx, solver, data, MinimizeMode_t::bb_step_hier);
		newMin->integrateBound(solver);
		solver.assume(a);
		solver.propagate();
		newMin->commitUpperBound(solver);
		solver.backtrack();
		CPPUNIT_ASSERT(newMin->integrateBound(solver));
		CPPUNIT_ASSERT(solver.propagate() == true);
		newMin->commitUpperBound(solver);
		CPPUNIT_ASSERT(!newMin->integrateBound(solver));
	}
	void testInconsistent() {
		MinimizeBuilder builder;
		WeightLitVec min;
		min.push_back( WeightLiteral(a, 1) );
		min.push_back( WeightLiteral(b, 1) );
		min.push_back( WeightLiteral(c, 1) );
		builder.add(0, min);
		wsum_t bound = 1;
		ctx.addUnary(a);
		ctx.addUnary(b);
		CPPUNIT_ASSERT(buildAndAttach(builder, MinimizeMode_t::optimize, &bound, 1) == 0);
	}
private:
	uint32 countMinLits() const {
		uint32 lits = 0;
		const WeightLiteral* it = newMin->shared()->lits;
		for (; !isSentinel(it->first); ++it, ++lits) { ; }
		return lits;
	}

	bool setOptimum(Solver& s, SumVec& vec, bool less) {
		SharedMinimizeData* data = const_cast(newMin->shared());
		if (!less) {
			vec.back() += 1;
		}
		data->setOptimum(&vec[0]);
		while (!newMin->integrateBound(s)) {
			if (!s.resolveConflict()) { return false; }
		}
		return true;
	}
	DefaultMinimize* createMin(SharedContext& ctx, Solver& s, SharedMinimizeData* data, MinimizeMode_t::BBOption param = MinimizeMode_t::bb_step_def) {
		ctx.endInit();
		return static_cast(data->attach(s, MinimizeMode_t::opt_bb, param));
	}
	DefaultMinimize* buildAndAttach(MinimizeBuilder& x, MinimizeMode m = MinimizeMode_t::optimize, const wsum_t* b = 0, uint32 bs = 0) {
		DefaultMinimize* con = 0;
		if ( (data = x.build(ctx)) != 0 && data->setMode(m, b, bs) ) {
			con = createMin(ctx, *ctx.master(), data);
			con->integrateBound(*ctx.master());
		}
		return con;
	}
	SharedContext ctx;
	DefaultMinimize* newMin;
	SharedMinimizeData*   data;
	Literal a, b, c, d, e, f, x, y;
};

class UncoreMinimizeTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(UncoreMinimizeTest);
	CPPUNIT_TEST(testEmpty);
	CPPUNIT_TEST(testEnumerate);
	CPPUNIT_TEST(testOptimize);
	CPPUNIT_TEST(testOptimizeGP);
	CPPUNIT_TEST(testMtBug1);
	CPPUNIT_TEST(testNegativeLower);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
		data = 0;
		min  = 0;
	}
	void tearDown() {
		if (min) {
			min->destroy(0,false);
		}
		if (data) {
			data->release();
		}
	}
	void testEmpty() {
		MinimizeBuilder b;
		ctx.startAddConstraints();
		data = b.build(ctx);
		CPPUNIT_ASSERT(data == 0);
	}
	void testEnumerate() {
		Var a = ctx.addVar(Var_t::Atom);
		Var b = ctx.addVar(Var_t::Atom);
		Var c = ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		WeightLitVec lits;
		MinimizeBuilder builder;
		lits.push_back(WeightLiteral(posLit(a), 1));
		lits.push_back(WeightLiteral(posLit(b), 1));
		lits.push_back(WeightLiteral(posLit(c), 1));
		builder.add(0, lits);
		data = builder.build(ctx);
		ctx.endInit();
		wsum_t bound = 1;
		data->setMode(MinimizeMode_t::enumerate, &bound, 1);
		min = data->attach(*ctx.master(), MinimizeMode_t::opt_usc);
		CPPUNIT_ASSERT(min->integrate(*ctx.master()));

		ctx.master()->assume(posLit(a));
		ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(posLit(b)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(posLit(c)));
	}
	void testOptimize() {
		Var a = ctx.addVar(Var_t::Atom);
		Var b = ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		WeightLitVec lits;
		MinimizeBuilder builder;
		lits.push_back(WeightLiteral(posLit(a), 1));
		lits.push_back(WeightLiteral(posLit(b), 1));
		builder.add(0, lits);
		data = builder.build(ctx);
		ctx.endInit();
		data->setMode(MinimizeMode_t::optimize);
		min = data->attach(s, MinimizeMode_t::opt_usc, MinimizeMode_t::usc_preprocess);
		BasicSolve solve(s);
		LitVec gp;
		while (min->integrate(s) || min->handleUnsat(s, true, gp)) {
			ValueRep v = solve.solve();
			CPPUNIT_ASSERT(v == value_true);
			min->handleModel(s);
		}
		CPPUNIT_ASSERT(gp.empty());
		CPPUNIT_ASSERT(s.isFalse(lits[0].first) && s.isFalse(lits[1].first));
	}
	void testOptimizeGP() {
		Var a = ctx.addVar(Var_t::Atom);
		Var b = ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		WeightLitVec lits;
		MinimizeBuilder builder;
		lits.push_back(WeightLiteral(posLit(a), 1));
		lits.push_back(WeightLiteral(posLit(b), 1));
		builder.add(0, lits);
		data = builder.build(ctx);
		ctx.endInit();
		data->setMode(MinimizeMode_t::optimize);
		min = data->attach(s, MinimizeMode_t::opt_usc, MinimizeMode_t::usc_preprocess);
		BasicSolve solve(s);
		LitVec gp; gp.push_back(posLit(a));
		solve.assume(gp);
		gp.clear();
		while (min->integrate(s) || min->handleUnsat(s, true, gp)) {
			ValueRep v = solve.solve();
			CPPUNIT_ASSERT(v == value_true);
			min->handleModel(s);
		}
		CPPUNIT_ASSERT(s.rootLevel() == 1 && s.decision(1) == posLit(a));
		CPPUNIT_ASSERT(s.isTrue(lits[0].first) && s.isFalse(lits[1].first));
	}

	void testMtBug1() {
		WeightLitVec lits;
		lits.push_back(WeightLiteral(posLit(ctx.addVar(Var_t::Atom)), 1));
		lits.push_back(WeightLiteral(posLit(ctx.addVar(Var_t::Atom)), 1));
		Solver& s1 = ctx.startAddConstraints();
		data       = MinimizeBuilder().add(0, lits).build(ctx);
		ctx.setConcurrency(2, SharedContext::resize_reserve);
		ctx.endInit(true);
		Solver& s2 = *ctx.solver(1);
		data->setMode(MinimizeMode_t::enumOpt);
		MinimizeConstraint* m1 = data->attach(s1, MinimizeMode_t::opt_usc, MinimizeMode_t::usc_preprocess);
		MinimizeConstraint* m2 = data->attach(s2, MinimizeMode_t::opt_usc, MinimizeMode_t::usc_preprocess);
		s1.setEnumerationConstraint(m1);
		s2.setEnumerationConstraint(m2);
		BasicSolve solve(s1);
		LitVec gp;
		while (m1->integrate(s1) || m1->handleUnsat(s1, true, gp)) {
			ValueRep v = solve.solve();
			CPPUNIT_ASSERT(v == value_true);
			m1->handleModel(s1);
		}
		data->markOptimal();
		m1->relax(s1, true);
		m2->relax(s2, true);
		solve.reset(s2, s2.searchConfig());
		uint32 numModels = 0;
		s2.setPref(1, ValueSet::user_value, value_true);
		for (;;) {
			ValueRep v = m2->integrate(s2) ? solve.solve() : value_false;
			if (v == value_true) {
				++numModels;
				CPPUNIT_ASSERT(s2.isFalse(lits[0].first));
				CPPUNIT_ASSERT(s2.isFalse(lits[1].first));
				if (!s2.backtrack()) { break; }
			}
			else if (v == value_false) {
				break;
			}
		}
		CPPUNIT_ASSERT(numModels == 1);
	}
	void testNegativeLower() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(a, b);
		WeightLitVec aMin, bMin;
		aMin.push_back( WeightLiteral(a, 1) );
		aMin.push_back( WeightLiteral(b, 1) );
		bMin.push_back( WeightLiteral(~a, 1) );
		data = MinimizeBuilder()
			.add(2, aMin)
			.add(1, bMin)
			.build(ctx);
		ctx.endInit();
		data->setMode(MinimizeMode_t::optimize);
		min = data->attach(s, MinimizeMode_t::opt_usc, MinimizeMode_t::usc_preprocess);

		LitVec ignore;
		while (!min->integrate(*ctx.master()) && min->handleUnsat(s, true, ignore)) { ; }
		CPPUNIT_ASSERT(s.assume(~a) && s.propagate());
		CPPUNIT_ASSERT(s.assume(b) && s.propagate());
		CPPUNIT_ASSERT(min->handleModel(s));
		s.undoUntil(0);
		while (!min->integrate(*ctx.master()) && min->handleUnsat(s, true, ignore)) { ; }
		CPPUNIT_ASSERT(s.assume(a) && s.propagate());
		CPPUNIT_ASSERT(s.isFalse(b));
		min->handleModel(s);
		s.undoUntil(0);
		while (!min->integrate(*ctx.master()) && min->handleUnsat(s, true, ignore)) { ; }
		CPPUNIT_ASSERT(s.hasConflict());
	}
private:
	SharedContext       ctx;
	SharedMinimizeData* data;
	MinimizeConstraint* min;
};
CPPUNIT_TEST_SUITE_REGISTRATION(DefaultMinimizeTest);
CPPUNIT_TEST_SUITE_REGISTRATION(UncoreMinimizeTest);
} }
clasp-3.2.2/libclasp/tests/parser_test.cpp000066400000000000000000001152571304134206100206170ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
#include 
#include 
#include 
#include 
namespace Clasp { namespace Test {

template 
static bool parse(Api& api, std::istream& str, const ParserOptions& opts = ParserOptions()) {
	ProgramParser& p = api.parser();
	return p.accept(str, opts) && p.parse();
}
VarVec& clear(VarVec& vec) { vec.clear(); return vec; }
static VarVec& operator, (VarVec& vec, int val) {
	vec.push_back(val);
	return vec;
}
static struct Empty {
	template 
	operator Potassco::Span () const { return Potassco::toSpan(); }
} empty;

#define NOT_EMPTY(X,...)
#define SPAN(VEC,...)      NOT_EMPTY(__VA_ARGS__) Potassco::toSpan((clear(VEC) , __VA_ARGS__))

using Potassco::SmodelsOutput;
using Potassco::AspifOutput;
class SmodelsParserTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(SmodelsParserTest);
	CPPUNIT_TEST(testEmptySmodels);
	CPPUNIT_TEST(testSingleFact);
	CPPUNIT_TEST(testComputeStatementAssumptions);
	CPPUNIT_TEST(testTransformSimpleConstraintRule);
	CPPUNIT_TEST(testTransformSimpleWeightRule);
	CPPUNIT_TEST(testTransformSimpleChoiceRule);
	CPPUNIT_TEST(testSimpleConstraintRule);
	CPPUNIT_TEST(testSimpleWeightRule);
	CPPUNIT_TEST(testSimpleChoiceRule);
	CPPUNIT_TEST(testMinimizePriority);
	CPPUNIT_TEST(testEdgeDirectives);
	CPPUNIT_TEST(testHeuristicDirectives);
	CPPUNIT_TEST(testSimpleIncremental);
	CPPUNIT_TEST(testIncrementalMinimize);
	CPPUNIT_TEST_SUITE_END();

	std::stringstream prg;
	SharedContext     ctx;
	Asp::LogicProgram api;
public:
	void setUp() {
		api.start(ctx, Asp::LogicProgram::AspOptions().noScc());
	}
	void toSmodels(const char* txt, Var falseAt = 0) {
		prg.clear();
		prg.str("");
		SmodelsOutput sm(prg, true, falseAt);
		Potassco::AspifTextInput x(&sm);
		std::stringstream temp; temp << txt;
		CPPUNIT_ASSERT(Potassco::readProgram(temp, x, 0) == 0);
	}
	bool parseProgram() {
		return parse(api, prg);
	}
	void testEmptySmodels() {
		toSmodels("");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		api.endProgram();
		std::stringstream empty;
		CPPUNIT_ASSERT(compareSmodels(empty, api));
	}
	void testSingleFact() {
		toSmodels("x1.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		api.endProgram();
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numVars());
	}
	void testComputeStatementAssumptions() {
		toSmodels(
			"x1 :- not x2.\n"
			"x2 :- not x3.\n"
			"x3 :- not x4.\n"
			"x4 :- not x3.\n"
			":- x2.\n", 2);
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		api.endProgram() && ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(api.getLiteral(3)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(api.getLiteral(1)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(api.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(api.getLiteral(4)));
	}
	void testTransformSimpleConstraintRule() {
		toSmodels(
			"x1 :- 2{not x3, x2, x4}.\n"
			"x2 :- not x3.\n"
			"x3 :- not x2.\n"
			"x4 :- not x3.\n");
		api.setExtendedRuleMode(Asp::LogicProgram::mode_transform_weight);
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		CPPUNIT_ASSERT(api.getLiteral(2) == api.getLiteral(1));
		CPPUNIT_ASSERT(api.getLiteral(4) == api.getLiteral(1));
		toSmodels(
			"x1 :- not x3.\n"
			"x3 :-not x1.\n"
			"x2 :- x1.\n"
			"x4 :- x1.\n");
		CPPUNIT_ASSERT(compareSmodels(prg, api));
	}
	void testTransformSimpleWeightRule() {
		toSmodels(
			"x1 :- 2 {x2=1, not x3=2, x4=3}.\n"
			"x2 :- not x3.\n"
			"x3 :- not x2.\n"
			"x4 :-not x3.");
		api.setExtendedRuleMode(Asp::LogicProgram::mode_transform_weight);
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numVars());
		toSmodels(
			"x1 :- not x3.\n"
			"x3 :- not x1.\n"
			"x2 :- x1.\n"
			"x4 :- x1.\n");
		CPPUNIT_ASSERT(compareSmodels(prg, api));
	}
	void testTransformSimpleChoiceRule() {
		toSmodels("{x1;x2;x3} :- x2, not x3.\n"
			"x2 :- not x1.\n"
			"x3 :- not x2.");
		api.setExtendedRuleMode(Asp::LogicProgram::mode_transform_choice);
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		toSmodels("x2. x4.");
		CPPUNIT_ASSERT(compareSmodels(prg, api));
	}
	void testSimpleConstraintRule() {
		toSmodels("x1 :- 2 {x3, x2, x4}.\n"
			"x2 :- not x3.\n"
			"x3 :- not x2.\n"
			"x4 :- not x3.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		CPPUNIT_ASSERT_EQUAL(2u, ctx.numVars());
		toSmodels("x1 :- 2 {x3, x2 = 2}.\n"
			"x2 :- not x3.\n"
			"x3 :- not x2.\n"
			"x4 :- x2.");
		CPPUNIT_ASSERT(compareSmodels(prg, api));
	}
	void testSimpleWeightRule() {
		toSmodels("x1 :- 2 {x3 = 2, x2 = 1, x4 = 3}. % but (x4 = 3 -> x4 = 2).\n"
			"x2 :- not x3.\n"
			"x3 :- not x2.\n"
			"x4 :- not x3.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		CPPUNIT_ASSERT_EQUAL(2u, ctx.numVars());
		toSmodels("x1 :- 2 {x3 = 2, x2 = 3}.\n"
			"x2 :- not x3.\n"
			"x3 :- not x2.\n"
			"x4 :- x2.");
		CPPUNIT_ASSERT(compareSmodels(prg, api));
	}
	void testSimpleChoiceRule() {
		toSmodels("{x1;x2;x3} :- x2, not x3.\n"
			"x2 :- not x1.\n"
			"x3 :- not x2.\n");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		toSmodels("x2.");
		CPPUNIT_ASSERT(compareSmodels(prg, api));
	}
	void testMinimizePriority() {
		toSmodels("{x1;x2;x3;x4}.\n"
			"#minimize{not x1, not x2}.\n"
			"#minimize{x3, x4}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		SharedMinimizeData* m1 = ctx.minimize();
		CPPUNIT_ASSERT(m1->numRules() == 2);
		CPPUNIT_ASSERT(std::find(m1->lits, m1->lits + 2, WeightLiteral(api.getLiteral(3), 0)) != m1->lits + 2);
		CPPUNIT_ASSERT(std::find(m1->lits, m1->lits + 2, WeightLiteral(api.getLiteral(4), 0)) != m1->lits + 2);
		CPPUNIT_ASSERT(std::find(m1->lits + 2, m1->lits + 4, WeightLiteral(~api.getLiteral(1), 1)) != m1->lits + 4);
		CPPUNIT_ASSERT(std::find(m1->lits + 2, m1->lits + 4, WeightLiteral(~api.getLiteral(2), 1)) != m1->lits + 4);
	}
	void testEdgeDirectives() {
		toSmodels("{x1;x2}.\n"
			"#output _edge(0,1)  : x1.\n"
			"#output _acyc_1_1_0 : x2.");
		CPPUNIT_ASSERT_EQUAL(true, parse(api, prg, ParserOptions().enableAcycEdges()));
		CPPUNIT_ASSERT(api.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(uint32(2), ctx.stats().acycEdges);
	}
	void testHeuristicDirectives() {
		toSmodels("{x1;x2;x3}.\n"
			"#output _heuristic(a,true,1) : x1.\n"
			"#output _heuristic(_heuristic(a,true,1),true,1) : x2.\n"
			"#output a : x3.");
		CPPUNIT_ASSERT_EQUAL(true, parse(api, prg, ParserOptions().enableHeuristic()));
		CPPUNIT_ASSERT(api.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.heuristic.size() == 2);
	}
	void testSimpleIncremental() {
		toSmodels(
			"#incremental.\n"
			"{x1;x2} :-x3.\n"
			"#external x3.\n"
			"#step.\n"
			"#external x3.[release]\n"
			"{x3}.");
		api.updateProgram();
		ProgramParser& p = api.parser();
		CPPUNIT_ASSERT_EQUAL(true, p.accept(prg));
		CPPUNIT_ASSERT_EQUAL(true, p.parse());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		CPPUNIT_ASSERT(p.more());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.isExternal(3));
		api.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, p.parse());
		CPPUNIT_ASSERT(!p.more());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(!api.isExternal(3));
	}
	void testIncrementalMinimize() {
		toSmodels(
			"#incremental.\n"
			"{x1; x2}.\n"
			"#minimize{not x1, not x2}.\n"
			"#step."
			"#minimize{x1, x2}.\n");
		api.updateProgram();
		ProgramParser& p = api.parser();
		CPPUNIT_ASSERT_EQUAL(true, p.accept(prg));
		CPPUNIT_ASSERT_EQUAL(true, p.parse());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		SharedMinimizeData* m1 = ctx.minimize();
		m1->share();
		CPPUNIT_ASSERT(std::find(m1->lits, m1->lits + 2, WeightLiteral(~api.getLiteral(1), 1)) != m1->lits + 2);
		CPPUNIT_ASSERT(std::find(m1->lits, m1->lits + 2, WeightLiteral(~api.getLiteral(2), 1)) != m1->lits + 2);

		CPPUNIT_ASSERT(p.more());
		api.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, p.parse());
		CPPUNIT_ASSERT(!p.more());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		SharedMinimizeData* m2 = ctx.minimize();
		CPPUNIT_ASSERT(m1 != m2);
		CPPUNIT_ASSERT(isSentinel(m2->lits[2].first));
		CPPUNIT_ASSERT(std::find(m2->lits, m2->lits + 2, WeightLiteral(api.getLiteral(1), 1)) != m2->lits + 2);
		CPPUNIT_ASSERT(std::find(m2->lits, m2->lits + 2, WeightLiteral(api.getLiteral(2), 1)) != m2->lits + 2);
		m1->release();
	}
};
class ClaspParserTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(ClaspParserTest);
	CPPUNIT_TEST(testEmptyProgram);
	CPPUNIT_TEST(testSingleFact);
	CPPUNIT_TEST(testSimpleRule);
	CPPUNIT_TEST(testInvalidAtom);
	CPPUNIT_TEST(testInvalidLiteral);
	CPPUNIT_TEST(testIntegrityConstraint);
	CPPUNIT_TEST(testDisjunctiveRule);
	CPPUNIT_TEST(testChoiceRule);
	CPPUNIT_TEST(testWeightRule);
	CPPUNIT_TEST(testDisjunctiveWeightRule);
	CPPUNIT_TEST(testChoiceWeightRule);
	CPPUNIT_TEST(testInvalidNegativeWeightInWeightRule);
	CPPUNIT_TEST(testInvalidHeadInWeightRule);
	CPPUNIT_TEST(testNegativeBoundInWeightRule);
	CPPUNIT_TEST(testMinimizeRule);
	CPPUNIT_TEST(testMinimizeRuleMergePriority);
	CPPUNIT_TEST(testMinimizeRuleWithNegativeWeights);
	CPPUNIT_TEST(testIncremental);
	CPPUNIT_TEST(testIncrementalExternal);
	CPPUNIT_TEST(testSimpleEdgeDirective);
	CPPUNIT_TEST(testComplexEdgeDirective);
	CPPUNIT_TEST(testHeuristicDirective);
	CPPUNIT_TEST(testOutputDirective);
	CPPUNIT_TEST(testAssumptionDirective);
	CPPUNIT_TEST(testProjectionDirective);
	CPPUNIT_TEST(testEmptyProjectionDirective);
	CPPUNIT_TEST(testIgnoreCommentDirective);
	CPPUNIT_TEST(testReadTheoryAtoms);
	CPPUNIT_TEST(testWriteTheoryAtoms);
	CPPUNIT_TEST(testTheoryElementWithCondition);
	CPPUNIT_TEST_SUITE_END();

	std::stringstream prg;
	SharedContext     ctx;
	Asp::LogicProgram api;
public:
	void setUp() {
		api.start(ctx, Asp::LogicProgram::AspOptions().noScc());
	}
	bool sameProgram(Asp::LogicProgram& a, std::stringstream& prg) {
		std::stringstream out;
		AspParser::write(a, out, AspParser::format_aspif);
		prg.clear();
		prg.seekg(0);
		return compareProgram(prg, out);
	}
	void toAspif(const char* txt) {
		prg.clear();
		prg.str("");
		AspifOutput aspif(prg);
		Potassco::AspifTextInput x(&aspif);
		std::stringstream temp; temp << txt;
		CPPUNIT_ASSERT(Potassco::readProgram(temp, x, 0) == 0);
	}
	bool parseProgram() {
		return parse(api, prg);
	}
	void testEmptyProgram() {
		toAspif("");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 0);
	}
	void testSingleFact() {
		toAspif("x1.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT_EQUAL(true, api.endProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.getLiteral(1) == lit_true());
	}
	void testSimpleRule() {
		toAspif("x1 :- x3, not x2.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.numAtoms() == 3);
		CPPUNIT_ASSERT(api.numBodies() == 1);
		CPPUNIT_ASSERT(api.getBody(0)->size() == 2);
		CPPUNIT_ASSERT(api.getBody(0)->goal(0) == posLit(3));
		CPPUNIT_ASSERT(api.getBody(0)->goal(1) == negLit(2));
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testInvalidAtom() {
		char buf[100];
		toAspif(clasp_format(buf, 100, "x%u :- not x2, x3.", varMax));
		CPPUNIT_ASSERT_THROW(parseProgram(), std::logic_error);
	}
	void testInvalidLiteral() {
		char buf[100];
		toAspif(clasp_format(buf, 100, "x1 :- not x%u, x3.", varMax));
		CPPUNIT_ASSERT_THROW(parseProgram(), std::logic_error);
	}
	void testIntegrityConstraint() {
		toAspif(":- not x1, x2.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.numAtoms() == 2);
		CPPUNIT_ASSERT(api.numBodies() == 1);
		CPPUNIT_ASSERT(api.getBody(0)->size() == 2);
		CPPUNIT_ASSERT(api.getBody(0)->goal(0) == posLit(2));
		CPPUNIT_ASSERT(api.getBody(0)->goal(1) == negLit(1));
		CPPUNIT_ASSERT(api.getBody(0)->value() == value_false);
	}
	void testDisjunctiveRule() {
		toAspif("x1|x2.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.stats.disjunctions[0] == 1);
		CPPUNIT_ASSERT(api.numAtoms() == 2);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testChoiceRule() {
		toAspif("{x1;x2;x3}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.stats.rules[0][Asp::RuleStats::Choice] == 1);
		CPPUNIT_ASSERT(api.numAtoms() == 3);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testWeightRule() {
		toAspif(
			"x1 :- 2{x2, x3, not x4}.\n"
			"x5 :- 4{x2 = 2, x3, not x4 = 3}.\n");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 2);
		CPPUNIT_ASSERT(api.stats.bodies[0][Asp::Body_t::Sum] == 1);
		CPPUNIT_ASSERT(api.stats.bodies[0][Asp::Body_t::Count] == 1);
		CPPUNIT_ASSERT(api.numBodies() == 2);
		CPPUNIT_ASSERT(api.getBody(0)->bound() == 2 && !api.getBody(0)->hasWeights());
		CPPUNIT_ASSERT(api.getBody(1)->bound() == 4 && api.getBody(1)->hasWeights());
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testDisjunctiveWeightRule() {
		toAspif("x1|x2 :- 2{x3, x4, not x5}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testChoiceWeightRule() {
		toAspif("{x1;x2} :- 2{x3, x4, not x5}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testInvalidNegativeWeightInWeightRule() {
		toAspif("x1 :- 2 {x2 = -1, not x3 = 1, x4}.");
		CPPUNIT_ASSERT_THROW(parseProgram(), std::logic_error);
	}
	void testInvalidHeadInWeightRule() {
		prg
			<< "asp 1 0 0"
			<< "\n1 0 1 0 1 2 3 2 1 -3 1 4 1"
			<< "\n0\n";
		CPPUNIT_ASSERT_THROW(parseProgram(), std::logic_error);
	}
	void testNegativeBoundInWeightRule() {
		toAspif("x1 :- -1 {x2, not x3, x4}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.stats.bodies[0][Asp::Body_t::Sum] == 0);
	}
	void testMinimizeRule() {
		toAspif(
			"{x1;x2;x3}.\n"
			"#minimize{x1 = 2, x2, not x3 = 4}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0][Asp::RuleStats::Minimize] == 1);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testMinimizeRuleMergePriority() {
		toAspif(
			"#minimize{x1 = 2, x2, not x3 = 4}@1.\n"
			"#minimize{x4 = 2, x2 = 2, x3 = 4}@1.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.stats.rules[0][Asp::RuleStats::Minimize] == 1);
	}
	void testMinimizeRuleWithNegativeWeights() {
		toAspif("#minimize{x4 = -2, x2 = -1, x3 = 4}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 1);
		CPPUNIT_ASSERT(api.endProgram());
		std::stringstream exp("6 0 2 2 4 2 2 1 ");
		CPPUNIT_ASSERT(findSmodels(exp, api));
	}
	void testIncremental() {
		toAspif("#incremental.\n"
			"{x1;x2}.\n"
			"#minimize{x1=2, x2}.\n"
			"#step.\n"
			"{x3}.\n"
			"#minimize{x3=4}.\n");

		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() == 2);
		CPPUNIT_ASSERT(api.endProgram());

		ProgramParser& p = api.parser();
		CPPUNIT_ASSERT(p.more());
		api.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true , p.parse());
		CPPUNIT_ASSERT_EQUAL(false, p.more());
		CPPUNIT_ASSERT(api.stats.rules[0].sum() > 0);
		// minimize rule was merged
		CPPUNIT_ASSERT(ctx.minimize()->numRules() == 1);
	}
	void testIncrementalExternal() {
		toAspif("#incremental."
			"x1 :- x2.\n"
			"#external x2. [true]\n"
			"#step.\n"
			"#external x2. [false]\n"
			"#step.\n"
			"#external x2. [release]\n");

		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram());
		LitVec assume;
		api.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 1 && assume[0] == api.getLiteral(2));

		ProgramParser& p = api.parser();
		CPPUNIT_ASSERT(p.more());
		api.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, p.parse());

		CPPUNIT_ASSERT(api.endProgram());
		assume.clear();
		api.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 1 && assume[0] == ~api.getLiteral(2));

		CPPUNIT_ASSERT(p.more());
		api.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, p.parse());
		CPPUNIT_ASSERT(!p.more());
		CPPUNIT_ASSERT(api.endProgram());
		assume.clear();
		api.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.empty());
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->isFalse(api.getLiteral(2)));
	}
	void testSimpleEdgeDirective() {
		toAspif("{x1;x2}."
			"#edge (0,1) : x1.\n"
			"#edge (1,0) : x2.\n");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.stats().acycEdges == 2);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testComplexEdgeDirective() {
		toAspif("{x1;x2;x3;x4}."
			"#edge (0,1) : x1, not x2.\n"
			"#edge (1,0) : x3, not x4.\n");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.stats().acycEdges == 2);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testHeuristicDirective() {
		toAspif("{x1;x2;x3;x4}."
			"#heuristic x1. [-1@1,sign]\n"
			"#heuristic x1 : x3, not x4. [1@1,factor]");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.heuristic.size() == 2);
		CPPUNIT_ASSERT(ctx.heuristic.begin()->type() == DomModType::Sign);
		CPPUNIT_ASSERT((ctx.heuristic.begin() + 1)->type() == DomModType::Factor);
		CPPUNIT_ASSERT(ctx.heuristic.begin()->var() == (ctx.heuristic.begin() + 1)->var());
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}

	void testOutputDirective() {
		toAspif("{x1;x2}."
			"#output fact.\n"
			"#output conj : x1, x2.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.output.size() == 2);
		CPPUNIT_ASSERT(ctx.output.numFacts() == 1);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testAssumptionDirective() {
		toAspif("{x1;x2}."
			"#assume{not x2, x1}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram());
		LitVec assume;
		api.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 2);
		CPPUNIT_ASSERT(std::find(assume.begin(), assume.end(), ~api.getLiteral(2)) != assume.end());
		CPPUNIT_ASSERT(std::find(assume.begin(), assume.end(), api.getLiteral(1)) != assume.end());
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testProjectionDirective() {
		toAspif("{x1;x2;x3;x4}."
			"#output a : x1.\n"
			"#output b : x2.\n"
			"#output c : x3.\n"
			"#output d : x4.\n"
			"#project{x1, x3}.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram());
		CPPUNIT_ASSERT(ctx.output.size() == 4);
		Literal a = api.getLiteral(1);
		Literal b = api.getLiteral(2);
		Literal c = api.getLiteral(3);
		Literal d = api.getLiteral(4);
		OutputTable::lit_iterator proj_begin = ctx.output.proj_begin(), proj_end = ctx.output.proj_end();
		CPPUNIT_ASSERT_EQUAL(true , std::find(proj_begin, proj_end, a) != proj_end);
		CPPUNIT_ASSERT_EQUAL(false, std::find(proj_begin, proj_end, b) != proj_end);
		CPPUNIT_ASSERT_EQUAL(true , std::find(proj_begin, proj_end, c) != proj_end);
		CPPUNIT_ASSERT_EQUAL(false, std::find(proj_begin, proj_end, d) != proj_end);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testEmptyProjectionDirective() {
		toAspif("{x1;x2;x3;x4}."
			"#project.");
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram());
		CPPUNIT_ASSERT(ctx.output.projectMode() == OutputTable::project_explicit);
		CPPUNIT_ASSERT(sameProgram(api, prg));
	}
	void testIgnoreCommentDirective() {
		prg
			<< "asp 1 0 0"
			<< "\n" << Potassco::Directive_t::Comment << " Ignore me!"
			<< "\n0\n";
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
	}
	void testReadTheoryAtoms() {
		AspifOutput aspif(prg);
		aspif.initProgram(false);
		aspif.beginStep();
		aspif.theoryTerm(0, 1);                     // (number 1)
		aspif.theoryTerm(1, 2);                     // (number 2)
		aspif.theoryTerm(2, 3);                     // (number 3)
		aspif.theoryTerm(3, 4);                     // (number 4)
		aspif.theoryTerm(4, Potassco::toSpan("x")); // (string x)
		aspif.theoryTerm(5, Potassco::toSpan("z")); // (string z)
		aspif.theoryTerm(6, Potassco::toSpan("+")); // (string +)
		aspif.theoryTerm(7, Potassco::toSpan("*")); // (string *)
		VarVec ids;
		aspif.theoryTerm(8,  4, SPAN(ids, 0));         // (function x(1))
		aspif.theoryTerm(9,  4, SPAN(ids, 1));         // (function x(2))
		aspif.theoryTerm(10, 4, SPAN(ids, 2));         // (function x(3))
		aspif.theoryTerm(11, 7, SPAN(ids, 0, 8));      // (term 1*x(1))
		aspif.theoryTerm(12, 7, SPAN(ids, 1, 9));      // (term 2*x(2))
		aspif.theoryTerm(13, 7, SPAN(ids, 2, 10));     // (term 3*x(3))
		aspif.theoryTerm(14, 7, SPAN(ids, 3, 5));      // (term 3*x(3))

		aspif.theoryElement(0, SPAN(ids, 11), empty);      // (element 1*x(1):)
		aspif.theoryElement(1, SPAN(ids, 12), empty);      // (element 2*x(2):)
		aspif.theoryElement(2, SPAN(ids, 13), empty);      // (element 3*x(3):)
		aspif.theoryElement(3, SPAN(ids, 14), empty);      // (element 4*z:)
		aspif.theoryTerm(15, Potassco::toSpan("sum"));    // (string sum)
		aspif.theoryTerm(16, Potassco::toSpan(">="));     // (string >=)
		aspif.theoryTerm(17, 42);                         // (number 42)
		aspif.theoryAtom(1, 15, SPAN(ids, 0, 1, 2, 3), 16, 17); // (&sum { 1*x(1); 2*x(2); 3*x(3); 4*z     } >= 42)
		aspif.endStep();
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());

		Potassco::TheoryData& t = api.theoryData();
		CPPUNIT_ASSERT(t.numAtoms() == 1);

		const Potassco::TheoryAtom& a = **t.begin();
		CPPUNIT_ASSERT(a.atom() == 1);
		CPPUNIT_ASSERT(std::strcmp(t.getTerm(a.term()).symbol(), "sum") == 0);
		CPPUNIT_ASSERT(a.size() == 4);
		for (Potassco::TheoryAtom::iterator it = a.begin(), end = a.end(); it != end; ++it) {
			const Potassco::TheoryElement& e = t.getElement(*it);
			CPPUNIT_ASSERT(e.size() == 1);
			CPPUNIT_ASSERT(Literal::fromId(e.condition()) == lit_true());
			CPPUNIT_ASSERT(t.getTerm(*e.begin()).type() == Potassco::Theory_t::Compound);
		}
		CPPUNIT_ASSERT(std::strcmp(t.getTerm(*a.guard()).symbol(), ">=") == 0);
		CPPUNIT_ASSERT(t.getTerm(*a.rhs()).number() == 42);

		struct BuildStr : public Potassco::TheoryData::Visitor {
			virtual void visit(const Potassco::TheoryData& data, const Potassco::TheoryAtom& a) {
				std::string rhs, op, at("&");
				data.accept(a, *this);
				if (a.guard()) { rhs = popStack(1 + (a.rhs() != 0), " "); }
				if (a.size())  { op  = popStack(a.size(), "; "); }
				at.append(popStack(1, "")).append("{").append(op).append("} ").append(rhs);
				exp.push_back(at);
			}
			virtual void visit(const Potassco::TheoryData& data, Potassco::Id_t, const Potassco::TheoryElement& e) {
				data.accept(e, *this);
				if (e.size() > 1) { exp.push_back(popStack(e.size(), ", ")); }
			}
			virtual void visit(const Potassco::TheoryData& data, Potassco::Id_t, const Potassco::TheoryTerm& t) {
				std::stringstream n;
				switch (t.type()) {
					case Potassco::Theory_t::Number: n << t.number(); exp.push_back(n.str()); break;
					case Potassco::Theory_t::Symbol: exp.push_back(t.symbol()); break;
					case Potassco::Theory_t::Compound: {
						data.accept(t, *this);
						const char* parens = Potassco::toString(t.isTuple() ? t.tuple() : Potassco::Tuple_t::Paren);
						std::string op = popStack((uint32)t.isFunction(), "");
						op.append(1, parens[0]).append(popStack(t.size(), ", ")).append(1, parens[1]);
						exp.push_back(op);
					}
				}
			}
			std::string popStack(uint32 n, const char* delim) {
				assert(n <= exp.size());
				std::string op;
				for (std::vector::size_type i = exp.size() - n; i != exp.size(); ++i) {
					if (!op.empty()) { op += delim; }
					op += exp[i];
				}
				exp.erase(exp.end() - n, exp.end());
				return op;
			}
			std::vector exp;
		} toStr;
		t.accept(toStr);
		CPPUNIT_ASSERT(toStr.exp[0] == "&sum{*(1, x(1)); *(2, x(2)); *(3, x(3)); *(4, z)} >= 42");
	}

	void testWriteTheoryAtoms() {
		VarVec ids;
		AspifOutput aspif(prg);
		aspif.initProgram(true);
		aspif.beginStep();
		aspif.rule(Potassco::Head_t::Choice, SPAN(ids, 1), empty);
		aspif.theoryTerm(0, 1);                      // (number 1)
		aspif.theoryTerm(1, Potassco::toSpan("x"));  // (string x)
		aspif.theoryTerm(3, Potassco::toSpan("foo"));// (string foo)
		aspif.theoryTerm(2, 1, SPAN(ids, 0));         // (function x(1))
		aspif.theoryElement(0, SPAN(ids, 2), empty);  // (element x(1):)
		aspif.theoryAtom(1, 3, SPAN(ids, 0));         // (&foo { x(1); })
		aspif.endStep();
		std::stringstream step1;
		step1 << prg.str();
		aspif.beginStep();
		aspif.rule(Potassco::Head_t::Choice, SPAN(ids, 2), empty);
		aspif.theoryAtom(2, 3, SPAN(ids, 0));              // (&foo { x(1); })
		aspif.endStep();
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		CPPUNIT_ASSERT(api.endProgram() && api.theoryData().numAtoms() == 1);
		std::stringstream out;
		AspParser::write(api, out);
		CPPUNIT_ASSERT(findProgram(step1, out));
		ProgramParser& p = api.parser();
		CPPUNIT_ASSERT(p.more());
		api.updateProgram();
		CPPUNIT_ASSERT(api.theoryData().numAtoms() == 0);
		CPPUNIT_ASSERT_EQUAL(true, p.parse());
		CPPUNIT_ASSERT(api.endProgram() && api.theoryData().numAtoms() == 1);
		AspParser::write(api, out);
	}
	void testTheoryElementWithCondition() {
		VarVec ids;
		AspifOutput aspif(prg);
		aspif.initProgram(false);
		aspif.beginStep();
		aspif.rule(Potassco::Head_t::Choice, SPAN(ids, 1, 2), empty);
		aspif.theoryTerm(0, 1); // (number 1)
		aspif.theoryTerm(1, Potassco::toSpan("foo"));
		Potassco::Lit_t lits[2] = {1, -2};
		aspif.theoryElement(0, SPAN(ids, 0), Potassco::toSpan(lits, 2));
		aspif.theoryAtom(0, 1, SPAN(ids, 0));
		aspif.endStep();
		CPPUNIT_ASSERT_EQUAL(true, parseProgram());
		prg.clear();
		prg.seekg(0);
		Potassco::TheoryData& t = api.theoryData();
		CPPUNIT_ASSERT(t.numAtoms() == 1);
		const Potassco::TheoryAtom& a = **t.begin();
		CPPUNIT_ASSERT(a.size() == 1);
		const Potassco::TheoryElement& e = t.getElement(*a.begin());
		CPPUNIT_ASSERT(e.condition() != 0);
		Potassco::LitVec cond;
		api.extractCondition(e.condition(), cond);
		CPPUNIT_ASSERT(cond.size() == 2);
		std::stringstream out;
		CPPUNIT_ASSERT(api.endProgram());
		AspParser::write(api, out);
		CPPUNIT_ASSERT(findProgram(out, prg));
	}
};

class DimacsParserTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(DimacsParserTest);
	CPPUNIT_TEST(testDimacs);
	CPPUNIT_TEST(testDimacsDontAddTaut);
	CPPUNIT_TEST(testDimacsDontAddDupLit);
	CPPUNIT_TEST(testDimacsBadVars);

	CPPUNIT_TEST(testWcnf);
	CPPUNIT_TEST(testPartialWcnf);

	CPPUNIT_TEST(testDimacsExtSupportsGraph);
	CPPUNIT_TEST(testDimacsExtSupportsCostFunc);
	CPPUNIT_TEST(testDimacsExtSupportsProject);
	CPPUNIT_TEST(testDimacsExtSupportsHeuristic);
	CPPUNIT_TEST(testDimacsExtSupportsAssumptions);
	CPPUNIT_TEST(testDimacsExtSupportsOutputRange);
	CPPUNIT_TEST(testDimacsExtSupportsOutputTable);
	CPPUNIT_TEST_SUITE_END();

public:
	void setUp() {
		api.startProgram(ctx);
	}
	void testDimacs() {
		std::stringstream prg;
		prg << "c simple test case\n"
		    << "p cnf 4 3\n"
		    << "1 2 0\n"
		    << "3 4 0\n"
		    << "-1 -2 -3 -4 0\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 4);
		CPPUNIT_ASSERT(ctx.numConstraints() == 3);
	}

	void testDimacsDontAddTaut() {
		std::stringstream prg;
		prg << "c simple test case\n"
		    << "p cnf 4 4\n"
		    << "1 2 0\n"
		    << "3 4 0\n"
		    << "-1 -2 -3 -4 0\n"
		    << "1 -2 -3 2 0\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 4);
		CPPUNIT_ASSERT(ctx.numConstraints() == 3);
	}

	void testDimacsDontAddDupLit() {
		std::stringstream prg;
		prg << "c simple test case\n"
		    << "p cnf 2 4\n"
		    << "1 2 2 1 0\n"
		    << "1 2 1 2 0\n"
		    << "-1 -2 -1 0\n"
		    << "-2 -1 -2 0\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 2);
		CPPUNIT_ASSERT(ctx.numConstraints() == 4);
		CPPUNIT_ASSERT(ctx.numBinary() == 4);
	}

	void testDimacsBadVars() {
		std::stringstream prg;
		prg << "p cnf 1 1\n"
		    << "1 2 0\n";
		CPPUNIT_ASSERT_THROW(parse(api, prg), std::logic_error);
	}

	void testWcnf() {
		std::stringstream prg;
		prg << "c comments Weighted Max-SAT\n"
		    << "p wcnf 3 5\n"
		    << "10 1 -2 0\n"
		    << "3 -1 2 -3 0\n"
		    << "8 -3 2 0\n"
		    << "5 1 3 0\n"
		    << "2 3 0\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 7);
		CPPUNIT_ASSERT(ctx.output.size() == 3);
		CPPUNIT_ASSERT(ctx.numConstraints() == 4);

		SharedMinimizeData* wLits = ctx.minimize();
		CPPUNIT_ASSERT(wLits->numRules() == 1);
		CPPUNIT_ASSERT(wLits->lits[0].second == 10);
		CPPUNIT_ASSERT(wLits->lits[1].second == 8);
		CPPUNIT_ASSERT(wLits->lits[2].second == 5);
		CPPUNIT_ASSERT(wLits->lits[3].second == 3);
	}

	void testPartialWcnf() {
		std::stringstream prg;
		prg << "c comments Weigthed Partial Max-SAT\n"
		    << "p wcnf 4 5 16\n"
		    << "16 1 -2 4 0\n"
		    << "16 -1 -2 3 0\n"
		    << "8 -2 -4 0\n"
		    << "4 -3 2 0\n"
		    << "1 1 3 0\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 7);
		CPPUNIT_ASSERT(ctx.output.size() == 4);
		CPPUNIT_ASSERT(ctx.numConstraints() == 5);
		SharedMinimizeData* wLits = ctx.minimize();;
		CPPUNIT_ASSERT(wLits->numRules() == 1);
		CPPUNIT_ASSERT(wLits->lits[0].second == 8);
		CPPUNIT_ASSERT(wLits->lits[1].second == 4);
		CPPUNIT_ASSERT(wLits->lits[2].second == 1);
	}
	void testDimacsExtSupportsGraph() {
		std::stringstream prg;
		prg
			<< "p cnf 4 3\n"
			<< "c graph 2\n"
			<< "c node 1 1\n"
			<< "c node 2 1\n"
			<< "c arc 1 1 2\n"
			<< "c arc 2 2 1\n"
			<< "c endgraph\n"
			<< "1 2 0\n"
			<< "3 4 0\n"
			<< "-1 -2 -3 -4 0\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableAcycEdges()) && api.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(uint32(2), ctx.stats().acycEdges);
	}
	void testDimacsExtSupportsCostFunc() {
		std::stringstream prg;
		prg
			<< "p cnf 4 3\n"
			<< "c minweight 1 2 2 4 -3 1 -4 2 0\n"
			<< "1 2 0\n"
			<< "3 4 0\n"
			<< "-1 -2 -3 -4 0\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableMinimize()) && api.endProgram());
		CPPUNIT_ASSERT(ctx.hasMinimize());
		SharedMinimizeData* wLits = ctx.minimize();;
		CPPUNIT_ASSERT(wLits->numRules() == 1);
		CPPUNIT_ASSERT(wLits->lits[0] == WeightLiteral(posLit(2), 4));
		CPPUNIT_ASSERT(wLits->lits[1] == WeightLiteral(posLit(1), 2));
		CPPUNIT_ASSERT(wLits->lits[2] == WeightLiteral(negLit(4), 2));
		CPPUNIT_ASSERT(wLits->lits[3] == WeightLiteral(negLit(3), 1));
	}
	void testDimacsExtSupportsProject() {
		std::stringstream prg;
		prg
			<< "p cnf 4 3\n"
			<< "c project 1 4\n"
			<< "1 2 0\n"
			<< "3 4 0\n"
			<< "-1 -2 -3 -4 0\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableProject()) && api.endProgram());
		CPPUNIT_ASSERT(ctx.output.projectMode() == OutputTable::project_explicit);
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), posLit(1)) != ctx.output.proj_end());
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), posLit(4)) != ctx.output.proj_end());
	}
	void testDimacsExtSupportsHeuristic() {
		std::stringstream prg;
		prg
			<< "p cnf 4 0\n"
			<< "c heuristic 4 1 1 0 0\n"
			<< "c heuristic 5 2 1 0 0\n"
			<< "c heuristic 5 3 1 0 -1\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableHeuristic()) && api.endProgram());
		CPPUNIT_ASSERT(ctx.heuristic.size() == 3);
		DomainTable::iterator it, end = ctx.heuristic.end();
		for (it = ctx.heuristic.begin(); it != end && it->var() != 3; ++it) { ;  }
		CPPUNIT_ASSERT_MESSAGE("'_heuristic(3,false,1,0) : -1' not found", it != end);
		CPPUNIT_ASSERT(it->bias() == 1);
		CPPUNIT_ASSERT(it->prio() == 0);
		CPPUNIT_ASSERT(it->type() == Potassco::Heuristic_t::False);
		CPPUNIT_ASSERT(it->cond() == negLit(1));
	}
	void testDimacsExtSupportsAssumptions() {
		std::stringstream prg;
		prg
			<< "p cnf 4 0\n"
			<< "c assume 1 -2 3\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableAssume()) && api.endProgram());
		LitVec ass;
		api.getAssumptions(ass);
		CPPUNIT_ASSERT(ass.size() == 3);
		CPPUNIT_ASSERT(ass[0] == posLit(1));
		CPPUNIT_ASSERT(ass[1] == negLit(2));
		CPPUNIT_ASSERT(ass[2] == posLit(3));
	}
	void testDimacsExtSupportsOutputRange() {
		std::stringstream prg;
		prg
			<< "p cnf 4 0\n"
			<< "c output range 2 3\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableOutput()) && api.endProgram());
		CPPUNIT_ASSERT(*ctx.output.vars_begin()   == 2);
		CPPUNIT_ASSERT(*(ctx.output.vars_end()-1) == 3);
	}
	void testDimacsExtSupportsOutputTable() {
		std::stringstream prg;
		prg
			<< "p cnf 4 0\n"
			<< "c output 1  var(1)      \n"
			<< "c output -2 not_var(2)  \n"
			<< "c 0\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableOutput()) && api.endProgram());
		CPPUNIT_ASSERT(ctx.output.vars_begin() == ctx.output.vars_end());
		CPPUNIT_ASSERT(ctx.output.size() == 2);
		for (OutputTable::pred_iterator it = ctx.output.pred_begin(), end = ctx.output.pred_end(); it != end; ++it) {
			CPPUNIT_ASSERT(
				(it->name.c_str() == std::string("var(1)") && it->cond == posLit(1))
				||
				(it->name.c_str() == std::string("not_var(2)") && it->cond == negLit(2))
				);
		}
	}
private:
	SharedContext ctx;
	SatBuilder    api;
};

class OPBParserTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(OPBParserTest);
	CPPUNIT_TEST(testBadVar);
	CPPUNIT_TEST(testBadVarInGraph);
	CPPUNIT_TEST(testWBO);
	CPPUNIT_TEST(testNLC);
	CPPUNIT_TEST(testNLCUnsorted);
	CPPUNIT_TEST(testPBEqualityBug);
	CPPUNIT_TEST(testPBProject);
	CPPUNIT_TEST(testPBAssume);
	CPPUNIT_TEST(testPBOutput);
	CPPUNIT_TEST(testPBOutputTable);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
		api.startProgram(ctx);
	}
	void testBadVar() {
		std::stringstream prg;
		prg << "* #variable= 1 #constraint= 1\n+1 x2 >= 1;\n";
		CPPUNIT_ASSERT_THROW(parse(api, prg), std::logic_error);
	}
	void testBadVarInGraph() {
		std::stringstream prg;
		prg << "* #variable= 1 #constraint= 1\n"
		    << "* graph 2\n"
		    << "* arc 1 1 2\n"
		    << "* arc 2 2 1\n"
		    << "* endgraph\n";
		CPPUNIT_ASSERT_THROW(parse(api, prg, ParserOptions().enableAcycEdges()), std::logic_error);
	}
	void testWBO() {
		std::stringstream prg;
		prg << "* #variable= 1 #constraint= 2 #soft= 2 mincost= 2 maxcost= 3 sumcost= 5\n"
		    << "soft: 6 ;\n"
		    << "[2] +1 x1 >= 1 ;\n"
		    << "[3] -1 x1 >= 0 ;\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 3);
		CPPUNIT_ASSERT(ctx.numConstraints() == 0 || ctx.numConstraints() == 2);
		CPPUNIT_ASSERT(ctx.output.size() == 1);
		SumVec bound;
		api.getWeakBounds(bound);
		CPPUNIT_ASSERT(bound.size() == 1 && bound[0] == 5);
		SharedMinimizeData* wLits = ctx.minimize();
		CPPUNIT_ASSERT(wLits && wLits->numRules() == 1);
		CPPUNIT_ASSERT(wLits->adjust(0) == 2);
	}

	void testNLC() {
		std::stringstream prg;
		prg << "* #variable= 5 #constraint= 4 #product= 5 sizeproduct= 13\n"
		    << "1 x1 +4 x1 ~x2 -2 x5 >=1;\n"
		    << "-1 x1 +4 x2 -2 x5 >= 3;\n"
		    << "10 x4 +4 x3 >= 10;\n"
		    << "2 x2 x3 +3 x4 ~x5 +2 ~x1 x2 +3 ~x1 x2 x3 ~x4 ~x5 >= 1 ;\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 10);
		CPPUNIT_ASSERT(ctx.numConstraints() >= 4);
		CPPUNIT_ASSERT(ctx.output.size() == 5);
	}

	void testNLCUnsorted() {
		std::stringstream prg;
		prg << "* #variable= 4 #constraint= 2 #product= 2 sizeproduct= 8\n"
		    << "1 x1 +1 x2 x1 >=1;\n"
		    << "1 x1 +1 x2 x3 x4 ~x4 x2 x3 >=1;\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 6);
		CPPUNIT_ASSERT(ctx.master()->isTrue(posLit(1)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(posLit(6)));
	}

	void testPBEqualityBug() {
		std::stringstream prg;
		prg << "* #variable= 4 #constraint= 2\n"
		    << "+1 x1 = 1;\n"
		    << "+1 x1 +1 x2 +1 x3 +1 x4 = 1;\n";
		CPPUNIT_ASSERT(parse(api, prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx.master()->isTrue(posLit(1)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(posLit(2)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(posLit(3)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(posLit(4)));
	}
	void testPBProject() {
		std::stringstream prg;
		prg << "* #variable= 6 #constraint= 0\n"
			<< "* project x1 x2\n"
			<< "* project x4\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableProject()) && api.endProgram());
		CPPUNIT_ASSERT(ctx.output.projectMode() == OutputTable::project_explicit);
		CPPUNIT_ASSERT(std::distance(ctx.output.proj_begin(), ctx.output.proj_end()) == 3u);
	}
	void testPBAssume() {
		std::stringstream prg;
		prg << "* #variable= 6 #constraint= 0\n"
			  << "* assume x1 -x5\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableAssume()) && api.endProgram());
		LitVec ass;
		api.getAssumptions(ass);
		CPPUNIT_ASSERT(ass.size() == 2);
		CPPUNIT_ASSERT(ass[0] == posLit(1));
		CPPUNIT_ASSERT(ass[1] == negLit(5));
	}
	void testPBOutput() {
		std::stringstream prg;
		prg << "* #variable= 6 #constraint= 0\n"
			<< "* output range x2 x4\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableOutput()) && api.endProgram());
		CPPUNIT_ASSERT(*ctx.output.vars_begin()  == 2);
		CPPUNIT_ASSERT(*(ctx.output.vars_end()-1)== 4);
	}
	void testPBOutputTable() {
		std::stringstream prg;
		prg << "* #variable= 6 #constraint= 0\n"
		  << "* output x1 var(1)\n"
		  << "* output -x2 not_var(2)\n"
		  << "* 0\n";
		CPPUNIT_ASSERT(parse(api, prg, ParserOptions().enableOutput()) && api.endProgram());
		CPPUNIT_ASSERT(ctx.output.vars_begin() == ctx.output.vars_end());
		CPPUNIT_ASSERT(ctx.output.size() == 2);
		for (OutputTable::pred_iterator it = ctx.output.pred_begin(), end = ctx.output.pred_end(); it != end; ++it) {
			CPPUNIT_ASSERT(
				(it->name.c_str() == std::string("var(1)") && it->cond == posLit(1))
				||
				(it->name.c_str() == std::string("not_var(2)") && it->cond == negLit(2))
				);
		}
	}
private:
	SharedContext ctx;
	PBBuilder     api;
};

CPPUNIT_TEST_SUITE_REGISTRATION(SmodelsParserTest);
CPPUNIT_TEST_SUITE_REGISTRATION(ClaspParserTest);
CPPUNIT_TEST_SUITE_REGISTRATION(DimacsParserTest);
CPPUNIT_TEST_SUITE_REGISTRATION(OPBParserTest);

} }
clasp-3.2.2/libclasp/tests/program_builder_test.cpp000066400000000000000000002233511304134206100224730ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
#include 
#include 
#include 
using namespace std;
namespace Clasp { namespace Test {
using namespace Clasp::Asp;
struct ClauseObserver : public DecisionHeuristic {
	Literal doSelect(Solver&){return Literal();}
	void updateVar(const Solver&, Var, uint32) {}
	void newConstraint(const Solver&, const Literal* first, LitVec::size_type size, ConstraintType) {
		Clause c;
		for (LitVec::size_type i = 0; i < size; ++i, ++first) {
			c.push_back(*first);
		}
		std::sort(c.begin(), c.end());
		clauses_.push_back(c);
	}
	typedef std::vector Clause;
	typedef std::vector Clauses;
	Clauses clauses_;
};

class LogicProgramTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(LogicProgramTest);
	CPPUNIT_TEST(testInvalidNodeId);
	CPPUNIT_TEST(testMergeValue);
	CPPUNIT_TEST(testIgnoreRules);
	CPPUNIT_TEST(testDuplicateRule);
	CPPUNIT_TEST(testNotAChoice);
	CPPUNIT_TEST(testNotAChoiceMerge);
	CPPUNIT_TEST(testMergeToSelfblocker);
	CPPUNIT_TEST(testMergeToSelfblocker2);
	CPPUNIT_TEST(testMergeToSelfblocker3);
	CPPUNIT_TEST(testDerivedTAUT);
	CPPUNIT_TEST(testOneLoop);
	CPPUNIT_TEST(testZeroLoop);
	CPPUNIT_TEST(testEqSuccs);
	CPPUNIT_TEST(testEqCompute);
	CPPUNIT_TEST(testFactsAreAsserted);
	CPPUNIT_TEST(testSelfblockersAreAsserted);
	CPPUNIT_TEST(testConstraintsAreAsserted);
	CPPUNIT_TEST(testConflictingCompute);
	CPPUNIT_TEST(testForceUnsuppAtomFails);
	CPPUNIT_TEST(testTrivialConflictsAreDeteced);
	CPPUNIT_TEST(testBuildEmpty);
	CPPUNIT_TEST(testBuildUnsat);
	CPPUNIT_TEST(testAddOneFact);
	CPPUNIT_TEST(testTwoFactsOnlyOneVar);
	CPPUNIT_TEST(testDontAddOnePredsThatAreNotHeads);
	CPPUNIT_TEST(testDontAddDuplicateBodies);
	CPPUNIT_TEST(testDontAddDuplicateSumBodies);
	CPPUNIT_TEST(testAddLargeSumBody);
	CPPUNIT_TEST(testDontAddDuplicateSimpBodies);
	CPPUNIT_TEST(testDontAddUnsupported);
	CPPUNIT_TEST(testDontAddUnsupportedNoEq);
	CPPUNIT_TEST(testDontAddUnsupportedExtNoEq);
	CPPUNIT_TEST(testAssertSelfblockers);

	CPPUNIT_TEST(testRegressionR1);
	CPPUNIT_TEST(testRegressionR2);
	CPPUNIT_TEST(testFuzzBug);
	CPPUNIT_TEST(testBackpropNoEqBug);

	CPPUNIT_TEST(testCloneProgram);

	CPPUNIT_TEST(testBug);
	CPPUNIT_TEST(testSatBodyBug);
	CPPUNIT_TEST(testDepBodyBug);
	CPPUNIT_TEST(testAddUnknownAtomToMinimize);
	CPPUNIT_TEST(testWriteWeakTrue);
	CPPUNIT_TEST(testSimplifyBodyEqBug);
	CPPUNIT_TEST(testNoEqSameLitBug);

	CPPUNIT_TEST(testAssertEqSelfblocker);
	CPPUNIT_TEST(testAddClauses);
	CPPUNIT_TEST(testAddCardConstraint);
	CPPUNIT_TEST(testAddWeightConstraint);
	CPPUNIT_TEST(testAddMinimizeConstraint);
	CPPUNIT_TEST(testAddEmptyMinimizeConstraint);
	CPPUNIT_TEST(testNonTight);

	CPPUNIT_TEST(testIgnoreCondFactsInLoops);
	CPPUNIT_TEST(testCrEqBug);
	CPPUNIT_TEST(testEqOverChoiceRule);
	CPPUNIT_TEST(testEqOverBodiesOfDiffType);
	CPPUNIT_TEST(testEqOverComp);
	CPPUNIT_TEST(testNoBodyUnification);
	CPPUNIT_TEST(testNoEqAtomReplacement);
	CPPUNIT_TEST(testAllBodiesSameLit);
	CPPUNIT_TEST(testAllBodiesSameLit2);

	CPPUNIT_TEST(testCompLit);
	CPPUNIT_TEST(testFunnySelfblockerOverEqByTwo);

	CPPUNIT_TEST(testRemoveKnownAtomFromWeightRule);
	CPPUNIT_TEST(testMergeEquivalentAtomsInConstraintRule);
	CPPUNIT_TEST(testMergeEquivalentAtomsInWeightRule);
	CPPUNIT_TEST(testBothLitsInConstraintRule);
	CPPUNIT_TEST(testBothLitsInWeightRule);
	CPPUNIT_TEST(testWeightlessAtomsInWeightRule);
	CPPUNIT_TEST(testSimplifyToNormal);
	CPPUNIT_TEST(testSimplifyToCardBug);
	CPPUNIT_TEST(testSimplifyCompBug);
	CPPUNIT_TEST(testSimplifyToTrue);

	CPPUNIT_TEST(testBPWeight);

	CPPUNIT_TEST(testExtLitsAreFrozen);
	CPPUNIT_TEST(writeIntegrityConstraint);
	CPPUNIT_TEST(testComputeTrueBug);
	CPPUNIT_TEST(testBackprop);
	CPPUNIT_TEST(testBackpropTrueCon);
	CPPUNIT_TEST(testBackpropWrite);
	CPPUNIT_TEST(testStatisticsObject);

	CPPUNIT_TEST(testSimpleIncremental);
	CPPUNIT_TEST(testIncrementalFreeze);
	CPPUNIT_TEST(testIncrementalFreezeValue);
	CPPUNIT_TEST(testIncrementalFreezeOpen);
	CPPUNIT_TEST(testIncrementalKeepFrozen);
	CPPUNIT_TEST(testIncrementalFreezeCompute);
	CPPUNIT_TEST(testIncrementalUnfreezeUnsupp);
	CPPUNIT_TEST(testIncrementalUnfreezeCompute);
	CPPUNIT_TEST(testIncrementalCompute);
	CPPUNIT_TEST(testIncrementalComputeBackprop);
	CPPUNIT_TEST(testIncrementalBackpropStep);
	CPPUNIT_TEST(testIncrementalEq);
	CPPUNIT_TEST(testIncrementalEqUnfreeze);
	CPPUNIT_TEST(testIncrementalEqComplement);
	CPPUNIT_TEST(testIncrementalEqUpdateAssigned);
	CPPUNIT_TEST(testIncrementalEqResetState);
	CPPUNIT_TEST(testIncrementalUnfreezeUnsuppEq);
	CPPUNIT_TEST(testIncrementalUnfreezeEq);
	CPPUNIT_TEST(testIncrementalStats);
	CPPUNIT_TEST(testIncrementalTransform);
	CPPUNIT_TEST(testIncrementalBackpropCompute);
	CPPUNIT_TEST(testIncrementalFreezeUnfreeze);
	CPPUNIT_TEST(testIncrementalSymbolUpdate);
	CPPUNIT_TEST(testIncrementalBackpropSolver);
	CPPUNIT_TEST(testIncrementalFreezeDefined);
	CPPUNIT_TEST(testIncrementalUnfreezeDefined);
	CPPUNIT_TEST(testIncrementalUnfreezeAsFact);
	CPPUNIT_TEST(testIncrementalImplicitUnfreeze);
	CPPUNIT_TEST(testIncrementalRedefine);
	CPPUNIT_TEST(testIncrementalGetAssumptions);
	CPPUNIT_TEST(testIncrementalSimplifyCard);
	CPPUNIT_TEST(testIncrementalSimplifyMinimize);
	CPPUNIT_TEST(testIncrementalEqOverNeg);

	CPPUNIT_TEST(testIncrementalKeepExternalValue);
	CPPUNIT_TEST(testIncrementalWriteMinimize);
	CPPUNIT_TEST(testIncrementalWriteExternal);
	CPPUNIT_TEST(testIncrementalWriteUnfreeze);
	CPPUNIT_TEST(testIncrementalSetInputAtoms);

	CPPUNIT_TEST(testFreezeIsExternal);
	CPPUNIT_TEST(testUnfreezeIsNotExternal);
	CPPUNIT_TEST(testFreezeStaysExternal);
	CPPUNIT_TEST(testDefinedIsNotExternal);
	CPPUNIT_TEST(testFactIsNotExternal);
	CPPUNIT_TEST(testFactIsDefined);
	CPPUNIT_TEST(testBogusAtomIsNotDefined);
	CPPUNIT_TEST(testMakeAtomicCondition);
	CPPUNIT_TEST(testMakeComplexCondition);
	CPPUNIT_TEST(testMakeFalseCondition);
	CPPUNIT_TEST(testMakeInvalidCondition);
	CPPUNIT_TEST(testExtractCondition);
	CPPUNIT_TEST(testGetConditionAfterDispose);
	CPPUNIT_TEST(testAssumptionsAreVolatile);
	CPPUNIT_TEST(testProjectionIsExplicitAndCumulative);

	CPPUNIT_TEST(testTheoryAtomsAreFrozen);
	CPPUNIT_TEST(testTheoryAtomsAreFrozenIncremental);
	CPPUNIT_TEST(testAcceptIgnoresAuxChoicesFromTheoryAtoms);
	CPPUNIT_TEST(testFalseHeadTheoryAtomsAreRemoved);
	CPPUNIT_TEST(testFalseBodyTheoryAtomsAreKept);
	CPPUNIT_TEST(testFactTheoryAtomsAreNotExternal);
	CPPUNIT_TEST(testTheoryAtomsAreAdded);

	CPPUNIT_TEST(testOutputFactsNotSupportedInSmodels);

	CPPUNIT_TEST(testDisposeBug);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
		a = 1, b = 2, c = 3, d = 4, e = 5, f = 6;
	}
	void tearDown(){
		ctx.reset();
	}
	void testInvalidNodeId() {
		CPPUNIT_ASSERT_THROW(PrgNode(PrgNode::noNode + 1), std::logic_error);
	}
	void testMergeValue() {
		PrgAtom lhs(0), rhs(1);
		ValueRep ok[15] = {
			value_free, value_free, value_free,
			value_free, value_true, value_true,
			value_free, value_false, value_false,
			value_free, value_weak_true, value_weak_true,
			value_true, value_weak_true, value_true
		};
		ValueRep fail[4] = { value_true, value_false, value_weak_true, value_false };
		for (uint32 x = 0; x != 2; ++x) {
			for (uint32 i = 0; i != 15; i += 3) {
				lhs.clearLiteral(true);
				rhs.clearLiteral(true);
				CPPUNIT_ASSERT(lhs.assignValue(ok[i+x]));
				CPPUNIT_ASSERT(rhs.assignValue(ok[i+(!x)]));
				CPPUNIT_ASSERT(mergeValue(&lhs, &rhs));
				CPPUNIT_ASSERT(lhs.value() == ok[i+2] && rhs.value() == ok[i+2]);
			}
		}
		for (uint32 x = 0; x != 2; ++x) {
			for (uint32 i = 0; i != 4; i+=2) {
				lhs.clearLiteral(true);
				rhs.clearLiteral(true);
				CPPUNIT_ASSERT(lhs.assignValue(fail[i+x]));
				CPPUNIT_ASSERT(rhs.assignValue(fail[i+(!x)]));
				CPPUNIT_ASSERT(!mergeValue(&lhs, &rhs));
			}
		}
	}
	void testIgnoreRules() {
		lpAdd(lp.start(ctx), "a :- a. b :- a.\n");
		CPPUNIT_ASSERT_EQUAL(1u, lp.stats.rules[0].sum());
	}

	void testDuplicateRule() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().iterations(1)),
			"{b}.\n"
			"a :- b.\n"
			"a :- b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.getLiteral(a) == lp.getLiteral(b));
	}

	void testNotAChoice() {
		lpAdd(lp.start(ctx),
			"{b}.\n"
			"{a} :- not b."
			"a :-not b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		ctx.master()->assume(~lp.getLiteral(b)) && ctx.master()->propagate();
		// if b is false, a must be true because a :- not b. is stronger than {a} :- not b.
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(a)));
	}

	void testNotAChoiceMerge() {
		lpAdd(lp.start(ctx),
			"{b}.\n"
			"{a} :- b.\n"
			"a :- b, not c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.getLiteral(a) == lp.getLiteral(b));
	}

	void testMergeToSelfblocker() {
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"b :- a.\n");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
	}

	void testMergeToSelfblocker2() {
		lpAdd(lp.start(ctx),
			"a :- not d.\n"
			"a :- not c.\n"
			"b :- not c.\n"
			"c :- a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT(ctx.numVars() == 0);
	}
	void testMergeToSelfblocker3() {
		lpAdd(lp.start(ctx),
			"b :- a.\n"
			"{c}.\n"
			"d :- 2 {a, b}.\n"
			"e :- 2 {a}.\n"
			"a :- not d, not e.\n");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram());
	}

	void testDerivedTAUT() {
		lpAdd(lp.start(ctx),
			"{x1;x2}.\n"
			"x3 :- not x2.\n"
			"x4 :- x3.\n"
			"x3 :- x1, x4.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.numVars() == 2);
	}

	void testOneLoop() {
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"b :- not a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL( 1u, ctx.numVars() );
		CPPUNIT_ASSERT_EQUAL( 0u, ctx.numConstraints() );
		CPPUNIT_ASSERT( lp.getLiteral(a) == ~lp.getLiteral(b) );
	}

	void testZeroLoop() {
		lpAdd(lp.start(ctx),
			"a :- b.\n"
			"b :- a.\n"
			"a :- not c.\n"
			"c :- not a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL( 1u, ctx.numVars() );
		CPPUNIT_ASSERT_EQUAL( 0u, ctx.numConstraints() );
		CPPUNIT_ASSERT( lp.getLiteral(a) == lp.getLiteral(b) );
	}

	void testEqSuccs() {
		lpAdd(lp.start(ctx),
			"{a;b}.\n"
			"c :- a, b.\n"
			"d :- a, b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL( 3u, ctx.numVars() );
		CPPUNIT_ASSERT_EQUAL( 3u, ctx.numConstraints() );
		CPPUNIT_ASSERT( lp.getLiteral(c) == lp.getLiteral(d) );
	}

	void testEqCompute() {
		lpAdd(lp.start(ctx),
			"{c}.\n"
			"a :- not c.\n"
			"a :- b.\n"
			"b :- a.\n"
			"  :- not b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(a), lp.getLiteral(b));
		CPPUNIT_ASSERT_EQUAL(true, lp.isFact(a));
		CPPUNIT_ASSERT_EQUAL(true, lp.isFact(b));
	}

	void testFactsAreAsserted() {
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(c)));
	}
	void testSelfblockersAreAsserted() {
		lpAdd(lp.start(ctx),
			"x1 :- not x1.\n"
			"x2 :- not x1.\n");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
	}
	void testConstraintsAreAsserted() {
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"b :- not a.\n"
			"  :- a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(a)));
	}

	void testConflictingCompute() {
		lpAdd(lp.start(ctx),
			"  :- a.\n"
			"  :- not a.");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(!ctx.ok());
	}
	void testForceUnsuppAtomFails() {
		lpAdd(lp.start(ctx), "a :- not b. :- not b.");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
	}

	void testTrivialConflictsAreDeteced() {
		lpAdd(lp.start(ctx), "a :- not a. :- not a.");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());

	}
	void testBuildEmpty() {
		lp.start(ctx);
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numVars());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
	}
	void testBuildUnsat() {
		lpAdd(lp.start(ctx), "x1. :- x1.");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram());
		std::stringstream exp("1 2 0 0\n0\n0\nB+\n0\nB-\n2\n0\n1\n");
		CPPUNIT_ASSERT_EQUAL(true, compareSmodels(exp, lp));
	}
	void testAddOneFact() {
		lpAdd(lp.start(ctx), "a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numVars());
		// a fact does not introduce a constraint, it is just a top-level assignment
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
		CPPUNIT_ASSERT_EQUAL(true, lp.isFact(a));
	}

	void testTwoFactsOnlyOneVar() {
		lpAdd(lp.start(ctx), "a. b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numVars());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
		CPPUNIT_ASSERT_EQUAL(true, lp.isFact(a));
		CPPUNIT_ASSERT_EQUAL(true, lp.isFact(b));
	}

	void testDontAddOnePredsThatAreNotHeads() {
		lpAdd(lp.start(ctx),
			"x1 :-not x2, not x3.\n"
			"x3.\n"
			"#output a : x1.\n"
			"#output b : x2.\n"
			"#output c : x3.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numVars());
		std::stringstream exp("1 3 0 0 \n0\n3 c\n0\nB+\n0\nB-\n0\n1\n");
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}

	void testDontAddDuplicateBodies() {
		lpAdd(lp.start(ctx),
			"a :- b, not c.\n"
			"d :- b, not c.\n"
			"b. c.");
		lp.addOutput("a", a).addOutput("b", b).addOutput("c", c);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numVars());
		std::stringstream exp("1 2 0 0 \n1 3 0 0 \n0\n2 b\n3 c\n0\nB+\n0\nB-\n0\n1\n");
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}

	void testDontAddDuplicateSumBodies() {
		lpAdd(lp.start(ctx),
			"{a; b; c}.\n"
			"d :- 2 {a=1, b=2, not c=1}.\n"
			"e :- 2 {a=1, b=2, not c=1}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.numBodies() == 2);
	}

	void testAddLargeSumBody() {
		VarVec atoms;
		Potassco::WLitVec lits;
		lp.start(ctx);
		for (uint32 i = 1; i != 21; ++i) { atoms.push_back(i); }
		lp.addRule(Head_t::Choice, Potassco::toSpan(atoms), Potassco::toSpan());

		atoms.assign(1, 20);
		for (int32 i = 1; i != 20; ++i) {
			Potassco::WeightLit_t wl = {i&1 ? Potassco::lit(i) : Potassco::neg(i), i};
			lits.push_back(wl);
		}
		lp.addRule(Head_t::Disjunctive, Potassco::toSpan(atoms), 10, Potassco::toSpan(lits));
		lits.clear();
		for (int32 i = 20; --i;) {
			Potassco::WeightLit_t wl = {i&1 ? Potassco::lit(i) : Potassco::neg(i), 20 - i};
			lits.push_back(wl);
		}
		lp.addRule(Head_t::Disjunctive, Potassco::toSpan(atoms), 10, Potassco::toSpan(lits));
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.numBodies() == 3u);
	}
	void testDontAddDuplicateSimpBodies() {
		lpAdd(lp.start(ctx),
			"{x1;x2;x3;x4}.\n"
			"x1 :- x2, x3, x4.\n"
			"x1 :- 8 {x3=2, x2=3, x4=4}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.numBodies() == 2);
	}

	void testDontAddUnsupported() {
		lpAdd(lp.start(ctx),
			"x1 :- x3, x2.\n"
			"x3 :- not x4.\n"
			"x2 :- x1.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		std::stringstream exp("1 3 0 0 \n0");
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}

	void testDontAddUnsupportedNoEq() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"x1 :- x3, x2.\n"
			"x3 :- not x4.\n"
			"x2 :- x1.");
		lp.addOutput("a", a).addOutput("b", b).addOutput("c", c);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() <= 2u);
		std::stringstream exp("1 3 0 0 \n0\n3 c\n0\nB+\n0\nB-\n0\n1\n");
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}

	void testDontAddUnsupportedExtNoEq() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"a :- not d.\n"
			"c :- a, d.\n"
			"b :- 2 {a, c, not d}. % -> a\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(c)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(b)));
	}

	void testAssertSelfblockers() {
		lpAdd(lp.start(ctx),
			"a :- b, not c.\n"
			"c :- b, not c.\n"
			"b.");
		// Program is unsat because b must be true and false at the same time.
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
	}

	void testRegressionR1() {
		lpAdd(lp.start(ctx), "b. b :- not c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.getLiteral(b) == lit_true());
		CPPUNIT_ASSERT(lp.getLiteral(c) == lit_false());
		CPPUNIT_ASSERT(ctx.numVars() == 0);
	}

	void testRegressionR2() {
		lpAdd(lp.start(ctx),
			"b :- not c.\n"
			"b :- not d.\n"
			"c :- not b.\n"
			"d :- not b.\n"
			"b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.getLiteral(b) == lit_true());
		CPPUNIT_ASSERT(lp.getLiteral(c) == lit_false());
		CPPUNIT_ASSERT(lp.getLiteral(d) == lit_false());
		CPPUNIT_ASSERT(ctx.numVars() == 0);
	}
	void testFuzzBug() {
		lpAdd(lp.start(ctx), "x1 :- not x1, not x2, not x3, not x2, not x1, not x4.");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
	}
	void testBackpropNoEqBug() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq().backpropagate()),
			"{x2;x3;x4} :- x5.\n"
			"x1 :- x7, x5.\n"
			"x5.\n"
			"x7 :- x2, x3.\n"
			"x7 :- x6.\n"
			"x6 :- x8.\n"
			"x8 :- x4.\n"
			":- x1.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(6)));
	}

	void testCloneProgram() {
		lpAdd(lp.start(ctx),
			"{x1;x2;x3}.\n"
			"x4 :- x1, x2, x3.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT( uint32(4) >= ctx.numVars() );
		CPPUNIT_ASSERT( uint32(4) >= ctx.numConstraints() );

		SharedContext ctx2;
		CPPUNIT_ASSERT_EQUAL(true, lp.clone(ctx2) && ctx2.endInit());
		CPPUNIT_ASSERT_EQUAL( ctx.numVars(), ctx2.numVars() );
		CPPUNIT_ASSERT_EQUAL( ctx.numConstraints(), ctx2.numConstraints() );
		CPPUNIT_ASSERT(!ctx.isShared());
		CPPUNIT_ASSERT(!ctx2.isShared());
		CPPUNIT_ASSERT(ctx.output.size() == ctx2.output.size() );
	}

	void testBug() {
		lpAdd(lp.start(ctx),
			"x1 :- x2.\n"
			"x2 :- x3, x1.\n"
			"x3 :- x4.\n"
			"x4 :-not x3.\n");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
	}

	void testSatBodyBug() {
		lpAdd(lp.start(ctx),
			"{c;b;a}.\n"
			"a.\n"
			"b :- 1 {a, c}.\n"
			"d :- b, c.\n");
		CPPUNIT_ASSERT(std::distance(lp.getAtom(c)->deps_begin(), lp.getAtom(c)->deps_end()) <= 2u);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(std::distance(lp.getAtom(c)->deps_begin(), lp.getAtom(c)->deps_end()) == 1u);
		CPPUNIT_ASSERT(std::distance(lp.getAtom(b)->deps_begin(), lp.getAtom(b)->deps_end()) == 0u);
		CPPUNIT_ASSERT_EQUAL(value_free, ctx.master()->value(lp.getLiteral(c).var()));
	}
	void testDepBodyBug() {
		lpAdd(lp.start(ctx),
			"{d;e;f}.\n"
			"a :- d, e.\n"
			"b :- a."
			"c :- b, f, a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT((lp.getAtom(a)->deps_end() - lp.getAtom(a)->deps_begin()) == 2);
	}

	void testAddUnknownAtomToMinimize() {
		lpAdd(lp.start(ctx), "#minimize{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, lp.hasMinimize());
	}

	void testWriteWeakTrue() {
		lpAdd(lp.start(ctx),
			"{c}.\n"
			"a :- not b, c.\n"
			"b :- not a.\n"
			"  :- not a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		Var a = lp.falseAtom();
		std::stringstream exp;
		exp << "1 " << a << " 1 1 3\n";
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testSimplifyBodyEqBug() {
		lpAdd(lp.start(ctx),
			"{d;e;f}.\n"
			"a :- d,f.\n"
			"b :- d,f.\n"
			"c :- a, e, b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		PrgAtom* na = lp.getAtom(a);
		PrgAtom* nb = lp.getAtom(b);
		CPPUNIT_ASSERT(nb->eq() && nb->id() == a);
		CPPUNIT_ASSERT((na->deps_end() - na->deps_begin()) == 1);
	}

	void testNoEqSameLitBug() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"{x4;x5}.\n"
			"x1 :- x4,x5.\n"
			"x2 :- x4,x5.\n"
			"x3 :- x1, x2.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.numVars() == 5);
	}

	void testAssertEqSelfblocker() {
		lpAdd(lp.start(ctx),
			"a :- not b, not c.\n"
			"a :- not d, not e.\n"
			"b :- not c.\n"
			"c :- not b.\n"
			"d :- not e.\n"
			"e :- not d.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(2u, ctx.numVars());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(a)));
	}

	void testAddClauses() {
		ClauseObserver o;
		ctx.master()->setHeuristic(&o, Ownership_t::Retain);
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"a :- b, c.\n"
			"b :- not a.\n"
			"c :- not b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(3u, ctx.numVars());
		CPPUNIT_ASSERT_EQUAL(0u, ctx.master()->numAssignedVars());

		CPPUNIT_ASSERT_EQUAL(8u, ctx.numConstraints());

		Var bodyNotB = 1;
		Var bodyBC = 3;
		CPPUNIT_ASSERT_EQUAL(Var_t::Body, ctx.varInfo(3).type());
		Literal litA = lp.getLiteral(a);
		CPPUNIT_ASSERT(lp.getLiteral(b) == ~lp.getLiteral(a));

		// a - HeadClauses
		ClauseObserver::Clause ac;
		ac.push_back(~litA);
		ac.push_back(posLit(bodyNotB));
		ac.push_back(posLit(bodyBC));
		std::sort(ac.begin(), ac.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), ac) != o.clauses_.end());

		// bodyNotB - Body clauses
		ClauseObserver::Clause cl;
		cl.push_back(negLit(bodyNotB)); cl.push_back(~lp.getLiteral(b));
		std::sort(cl.begin(), cl.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), cl) != o.clauses_.end());
		cl.clear();
		cl.push_back(posLit(bodyNotB)); cl.push_back(lp.getLiteral(b));
		std::sort(cl.begin(), cl.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), cl) != o.clauses_.end());
		cl.clear();
		cl.push_back(negLit(bodyNotB)); cl.push_back(litA);
		std::sort(cl.begin(), cl.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), cl) != o.clauses_.end());

		// bodyBC - Body clauses
		cl.clear();
		cl.push_back(negLit(bodyBC)); cl.push_back(lp.getLiteral(b));
		std::sort(cl.begin(), cl.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), cl) != o.clauses_.end());
		cl.clear();
		cl.push_back(negLit(bodyBC)); cl.push_back(lp.getLiteral(c));
		std::sort(cl.begin(), cl.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), cl) != o.clauses_.end());
		cl.clear();
		cl.push_back(posLit(bodyBC)); cl.push_back(~lp.getLiteral(b)); cl.push_back(~lp.getLiteral(c));
		std::sort(cl.begin(), cl.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), cl) != o.clauses_.end());
		cl.clear();
		cl.push_back(negLit(bodyBC)); cl.push_back(litA);
		std::sort(cl.begin(), cl.end());
		CPPUNIT_ASSERT(std::find(o.clauses_.begin(), o.clauses_.end(), cl) != o.clauses_.end());
	}

	void testAddCardConstraint() {
		lpAdd(lp.start(ctx),
			"a :- 1 { not b, c, d }.\n"
			"{b;c}.");
		lp.addOutput("a", a).addOutput("b", b).addOutput("c", c);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(3u, ctx.numVars());

		std::stringstream exp("2 1 2 1 1 2 3 \n3 2 2 3 0 0 \n0\n1 a\n2 b\n3 c\n0\nB+\n0\nB-\n0\n1\n");
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}

	void testAddWeightConstraint() {
		lpAdd(lp.start(ctx),
			"a :- 2 {not b=1, c=2, d=2}.\n"
			"{b;c}.");
		lp.addOutput("a", a).addOutput("b", b).addOutput("c", c).addOutput("d", d);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(3u, ctx.numVars());
		std::stringstream exp("5 1 2 2 1 2 3 1 2 \n3 2 2 3 0 0 \n0\n1 a\n2 b\n3 c\n0\nB+\n0\nB-\n0\n1\n");
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}
	void testAddMinimizeConstraint() {
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"b :- not a.\n"
			"#minimize{a}@0.\n"
			"#minimize{b}@1.\n"
			"#output a : a. #output b : b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		std::stringstream exp;
		exp
			<< "6 0 1 0 1 1 \n"
			<< "6 0 1 0 2 1 \n"
			<< "1 1 1 1 2 \n"
			<< "1 2 1 1 1 \n"
			<< "0\n1 a\n2 b\n0\nB+\n0\nB-\n0\n1\n";
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}
	void testAddEmptyMinimizeConstraint() {
		lpAdd(lp.start(ctx), "#minimize{}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.hasMinimize());
	}

	void testNonTight() {
		lpAdd(lp.start(ctx),
			"b :- c.\n"
			"c :- b.\n"
			"b :- not a.\n"
			"c :- not a.\n"
			"a :- not b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT( lp.stats.sccs != 0 );
	}

	void testIgnoreCondFactsInLoops() {
		lpAdd(lp.start(ctx),
			"{a}.\n"
			"b :- a.\n"
			"a :- b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT( lp.stats.sccs == 0);
	}

	void testCrEqBug() {
		lpAdd(lp.start(ctx),
			"a.\n"
			"{b}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numVars());
		CPPUNIT_ASSERT_EQUAL(value_free, ctx.master()->value(lp.getLiteral(b).var()));
	}

	void testEqOverChoiceRule() {
		lpAdd(lp.start(ctx),
			"{a}.\n"
			"b :- a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numVars());
		std::stringstream exp;
		exp
			<< "3 1 1 0 0 \n"
			<< "1 2 1 0 1 \n"
			<< "0\n0\nB+\n0\nB-\n0\n1\n";
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}

	void testEqOverComp() {
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"a :- b.\n"
			"b :- not c.\n"
			"c :- not a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(a), lp.getLiteral(b));
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 0 && ctx.master()->isTrue(lp.getLiteral(a)));
	}

	void testEqOverBodiesOfDiffType() {
		lpAdd(lp.start(ctx),
			"{a;b}.\n"
			"d :- 2{a, b, c}.\n"
			"c :- d.\n"
			"  :- b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(3u >= ctx.numVars());
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(c)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(d)));
	}

	void testNoBodyUnification() {
		Var g = 7;
		lpAdd(lp.start(ctx),
			"{a;b;c}.\n"
			"d :- a, g.\n"
			"d :- b.\n"
			"e :- not d.\n"
			"f :- not e.\n"
			"g :- d.\n"
			"g :- c.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.sccGraph.get());
		ctx.master()->addPost(new DefaultUnfoundedCheck(*ctx.sccGraph));
		CPPUNIT_ASSERT_EQUAL(true, ctx.endInit());
		ctx.master()->assume(~lp.getLiteral(b));
		ctx.master()->propagate();
		ctx.master()->assume(~lp.getLiteral(c));
		ctx.master()->propagate();
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(g)));
	}

	void testNoEqAtomReplacement() {
		lpAdd(lp.start(ctx),
			"{a;b}.\n"
			"c :- a.\n"
			"c :- b.\n"
			"d :- not c.\n"
			"e :- not d.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		ctx.master()->assume(~lp.getLiteral(a));
		ctx.master()->propagate();
		ctx.master()->assume(~lp.getLiteral(b));
		ctx.master()->propagate();
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(c)));
	}

	void testAllBodiesSameLit() {
		lpAdd(lp.start(ctx),
			"{a}.\n"
			"b :- not a.\n"
			"c :- not b.\n"
			"d :- b.\n"
			"d :- not c.\n"
			"b :- d.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(b), lp.getLiteral(d));
		CPPUNIT_ASSERT(lp.getLiteral(a) != lp.getLiteral(c));
		ctx.master()->assume(lp.getLiteral(a)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->value(lp.getLiteral(c).var()) == value_free);
		ctx.master()->assume(~lp.getLiteral(c)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 0 && ctx.master()->isTrue(lp.getLiteral(b)));
	}

	void testAllBodiesSameLit2() {
		lpAdd(lp.start(ctx),
			"{a;e}.\n"
			"b :- not a.\n"
			"c :- not b.\n"
			"d :- b.\n"
			"d :- not c.\n"
			"b :- d, e.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(b), lp.getLiteral(d));
		CPPUNIT_ASSERT(lp.getLiteral(a) != lp.getLiteral(c));
		ctx.master()->assume(lp.getLiteral(a)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->value(lp.getLiteral(c).var()) == value_free);
		ctx.master()->assume(~lp.getLiteral(c)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 0 && ctx.master()->isTrue(lp.getLiteral(b)));
		CPPUNIT_ASSERT(ctx.numVars() == 4);
	}

	void testCompLit() {
		lpAdd(lp.start(ctx),
			"{d}.\n"
			"a :- not c.\n"
			"c :- not a.\n"
			"b :- a, c.\n"
			"e :- a, d, not c. % a == ~c -> {a,c} = F -> {a, not c} = {a, d}\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(3u, ctx.numVars());
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
	}

	void testFunnySelfblockerOverEqByTwo() {
		lpAdd(lp.start(ctx),
			"{a,b,c}.\n"
			"d :- a, b.\n"
			"e :- a, b.\n"
			"f :- b, c.\n"
			"g :- b, c.\n"
			"f :- d, not f.\n"
			"h :- e, not g.\n"
			"i :- a, h.\n"
			"% -> d == e, f == g -> {e, not g} == {d, not f} -> F"
			"% -> h == i are both unsupported!");
		Var h = 8, i = 9;
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(h)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(i)));
	}

	void testRemoveKnownAtomFromWeightRule() {
		lpAdd(lp.start(ctx),
			"{c, d}.\n"
			"a."
			"e :- 5 {a = 2, not b = 2, c = 1, d = 1}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		std::stringstream exp;
		exp << "1 1 0 0 \n"       // a.
		    << "3 2 3 4 0 0 \n"   // {c, d}.
		    << "2 5 2 0 1 3 4 \n" // e :- 1 { c, d }.
		    << "0\n";
		CPPUNIT_ASSERT(compareSmodels(exp, lp));
	}

	void testMergeEquivalentAtomsInConstraintRule() {
		lpAdd(lp.start(ctx),
			"{a, c}.\n"
			"a :- b.\n"
			"b :- a.\n"
			"d :-  2 {a, b, c}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		std::stringstream exp("5 4 2 2 0 1 3 2 1");
		// d :-  2 [a=2, c].
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testMergeEquivalentAtomsInWeightRule() {
		lpAdd(lp.start(ctx),
			"{a, c, e}.\n"
			"a :- b.\n"
			"b :- a.\n"
			"d :-  3 {a = 1, c = 4, b = 2, e=1}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// x :-  3 [a=3, c=3,d=1].
		std::stringstream exp("5 4 3 3 0 1 3 5 3 3 1");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testBothLitsInConstraintRule() {
		lpAdd(lp.start(ctx),
			"{a}.\n"
			"b :- a.\n"
			"c :- b.\n"
			"d :-  1 {a, b, not b, not c}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// d :-  1 [a=2, not a=2].
		std::stringstream exp("5 4 1 2 1 1 1 2 2");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testBothLitsInWeightRule() {
		lpAdd(lp.start(ctx),
			"{a, e}.\n"
			"b :- a.\n"
			"c :- b.\n"
			"d :-  3 {a=3, not b=1, not c=3, e=2}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// d :-  3 [a=3, not a=4, e=2].
		std::stringstream exp("5 4 3 3 1 1 1 5 4 3 2");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testWeightlessAtomsInWeightRule() {
		lpAdd(lp.start(ctx),
			"{a, b, c}.\n"
			"d :-  1 {a=1, b=1, c=0}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// d :-  1 {a, b}.
		std::stringstream exp("2 4 2 0 1 1 2");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testSimplifyToNormal() {
		lpAdd(lp.start(ctx),
			"{a}.\n"
			"b :-  2 {a=2,not c=1}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// b :-  a.
		std::stringstream exp("1 2 1 0 1");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}
	void testSimplifyToTrue() {
		lpAdd(lp.start(ctx),
			"a.\n"
			"b :-  1 {c, a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.numBodies() <= 1);
	}

	void testSimplifyToCardBug() {
		lpAdd(lp.start(ctx),
			"a. b.\n"
			"c :- 168 {not a = 576, not b=381}.\n"
			"  :- c.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 0);
	}

	void testSimplifyCompBug() {
		Var h = 8;
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().iterations(1)),
			"a :- not b.\n"
			"a :- b.\n"
			"b :- not c.\n"
			"c :- not a.\n"
			"d. e. g. {f}.\n"
			"h :- d, e, b, f, g.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		PrgAtom* x = lp.getAtom(h);
		PrgBody* B = lp.getBody(x->supps_begin()->node());
		CPPUNIT_ASSERT(B->size() == 2 && !B->goal(0).sign() && B->goal(1).sign());
		CPPUNIT_ASSERT(B->goal(0).var() == f);
		CPPUNIT_ASSERT(B->goal(1).var() == c);
	}

	void testBPWeight() {
		lpAdd(lp.start(ctx),
			"{a, b, c, d}.\n"
			"e :-  2 {a=1, b=2, not c=2, d=1}.\n"
			"  :- e.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(lp.getLiteral(c)));
	}

	void testExtLitsAreFrozen() {
		Var g = 7, h = 8, i = 9;
		lpAdd(lp.start(ctx),
			"{a, b, c, d, e, f, g}.\n"
			" h :- 2 {b, c, d}.\n"
			"i :- 2 {c=1, d=2, e=1}.\n"
			"#minimize {f, g}.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(false, ctx.varInfo(lp.getLiteral(a).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(b).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(c).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(d).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(e).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(h).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(i).var()).frozen());

		// minimize lits only frozen if constraint is actually used
		CPPUNIT_ASSERT_EQUAL(false, ctx.varInfo(lp.getLiteral(f).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(false, ctx.varInfo(lp.getLiteral(g).var()).frozen());
		ctx.minimize();
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(f).var()).frozen());
		CPPUNIT_ASSERT_EQUAL(true, ctx.varInfo(lp.getLiteral(g).var()).frozen());
	}

	void writeIntegrityConstraint() {
		lpAdd(lp.start(ctx),
			"{a;b;c}."
			"a :- c, not b.\n"
			"b :- c, not b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());

		// falseAtom :- c, not b.
		// compute {not falseAtom}.
		std::stringstream exp("1 4 2 1 2 3\nB-\n4");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testComputeTrueBug() {
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"b :- a.\n"
			"a :- c.\n"
			"c :- a.\n"
			"  :- not a.\n");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram() && ctx.endInit());
	}

	void testBackprop() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().backpropagate()),
			"{e;f;g}.\n"
			"d :- e, a.\n"
			"a :- f, d.\n"
			"b :- e, g.\n"
			"c :- f, g.\n"
			"h :- e, not d.\n"
			"h :- f, not b.\n"
			"h :- g, not c.\n"
			"  :- h.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.numVars() == 0);
	}
	void testBackpropTrueCon() {
		Var x2 = 2, x3 = 3;
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().backpropagate()),
			"x7.\n"
			"{x2;x3}.\n"
			"x4 :- not x6.\n"
			"   :- not x5.\n"
			"x5 :- 1 {not x2, not x3}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		ctx.master()->assume(lp.getLiteral(x2)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(x3)));
		ctx.master()->undoUntil(0);
		ctx.master()->assume(lp.getLiteral(x3)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(x2)));
	}
	void testBackpropWrite() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().backpropagate()),
			"a|b.\n"
			"c :- a.\n"
			"a :- c.\n"
			"d :- not c.\n"
			"e :- a,c.\n"
			"  :- e.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.numVars() == 0);
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(a)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(c)));
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(b)));
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(d)));

		std::stringstream exp("1 2 0 0\n1 4 0 0");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
		CPPUNIT_ASSERT(!lp.isDefined(a));
		CPPUNIT_ASSERT(!lp.isDefined(c));
	}
	void testStatisticsObject() {
		StatisticObject stats = StatisticObject::map(&lp.stats);
		for (uint32 i = 0, end = stats.size(); i != end; ++i) {
			const char* k = stats.key(i);
			StatisticObject x = stats.at(k);
			CPPUNIT_ASSERT(x.value() == 0.0);
		}
		lpAdd(lp.start(ctx),
			"a :- not b.\n"
			"b :- not a.\n");
		lp.endProgram();
		CPPUNIT_ASSERT(stats.at("atoms").value() == (double)lp.stats.atoms);
		CPPUNIT_ASSERT(stats.at("rules").value() == (double)lp.stats.rules[0].sum());
	}
	void testSimpleIncremental() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "a :- not b. b :- not a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.numVars() == 1);
		CPPUNIT_ASSERT(lp.getLiteral(a) == ~lp.getLiteral(b));
		lp.updateProgram();
		lpAdd(lp,
			"c :- a, not d.\n"
			"d :- b, not c.\n"
			"e :- d.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.numVars() == 3);
		CPPUNIT_ASSERT(lp.getLiteral(a) == ~lp.getLiteral(b));
		CPPUNIT_ASSERT(lp.getLiteral(e) == lp.getLiteral(d));
	}

	void testIncrementalFreeze() {
		lp.start(ctx, LogicProgram::AspOptions().noEq());
		lp.updateProgram();
		lpAdd(lp,
			"{d}.\n"
			"a :- not c.\n"
			"b :- a, d.\n"
			"#external c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(lp.getLiteral(c) != lit_false());
		Solver& solver = *ctx.master();
		solver.assume(lp.getLiteral(c));
		solver.propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
		solver.undoUntil(0);

		lp.updateProgram();
		lpAdd(lp,
			"{e}.\n"
			"c :- e.\n"
			"#external c. [release]");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		solver.assume(lp.getLiteral(e));
		solver.propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
		solver.undoUntil(0);
		solver.assume(~lp.getLiteral(e));
		solver.propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(c)));
		solver.assume(lp.getLiteral(d));
		solver.propagate();
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(b)));
	}
	void testIncrementalFreezeValue() {
		lp.start(ctx, LogicProgram::AspOptions().noEq());
		lp.updateProgram();
		lp.freeze(a).freeze(b, value_true).freeze(c, value_false);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		LitVec assume;
		lp.getAssumptions(assume);
		Solver& solver = *ctx.master();
		solver.pushRoot(assume);
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(a)));
		CPPUNIT_ASSERT(solver.isTrue(lp.getLiteral(b)));
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(c)));
		solver.popRootLevel(solver.decisionLevel());

		lp.updateProgram();
		lp.unfreeze(a).freeze(c, value_true).freeze(b, value_true).freeze(b, value_false);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		assume.clear();
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 2 && solver.isFalse(lp.getLiteral(a)));
		solver.pushRoot(assume);
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT(solver.isTrue(lp.getLiteral(c)));
	}

	void testIncrementalFreezeOpen() {
		lp.start(ctx, LogicProgram::AspOptions().noEq());
		// I1:
		// freeze(a, value_free)
		lp.updateProgram();
		lp.freeze(a, value_free);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		LitVec assume;
		lp.getAssumptions(assume);
		Solver& solver = *ctx.master();
		CPPUNIT_ASSERT(assume.empty());
		CPPUNIT_ASSERT(solver.value(lp.getLiteral(a).var()) == value_free);

		// I2:
		lp.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		assume.clear();
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.empty());
		CPPUNIT_ASSERT(solver.value(lp.getLiteral(a).var()) == value_free);

		// I3:
		lp.updateProgram();
		lp.freeze(a, value_true);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		assume.clear();
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 1 && assume[0] == lp.getLiteral(a));
	}
	void testIncrementalKeepFrozen() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lp.freeze(a);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		PrgAtom* x   = lp.getAtom(a);
		Literal xLit = x->literal();
		// I1:
		lp.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(x->literal() == xLit);
		CPPUNIT_ASSERT(x->frozen());
	}
	void testIncrementalFreezeCompute() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"#external a. #external b. #external c. #external d.\n"
			":- not a.\n"
			":- not b.\n"
			":- c.\n"
			":- d.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		PrgAtom* x = lp.getAtom(a);
		PrgAtom* y = lp.getAtom(b);
		CPPUNIT_ASSERT(x->frozen() && y->frozen());
		CPPUNIT_ASSERT(x->literal() != y->literal());
		PrgAtom* z  = lp.getAtom(c);
		PrgAtom* z2 = lp.getAtom(d);
		CPPUNIT_ASSERT(z->frozen() && z2->frozen());
		CPPUNIT_ASSERT(z->literal() == z2->literal());
		// I1:
		lp.updateProgram();
		lpAdd(lp, ":- a.");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram());
	}
	void testIncrementalUnfreezeUnsupp() {
		lp.start(ctx, LogicProgram::AspOptions().noEq());
		lp.updateProgram();
		lpAdd(lp, "a :- not b. #external b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		DefaultUnfoundedCheck* ufsCheck = 0;
		if (ctx.sccGraph.get()) {
			ctx.master()->addPost(ufsCheck = new DefaultUnfoundedCheck(*ctx.sccGraph));
		}
		ctx.endInit();
		lp.updateProgram();
		lpAdd(lp,
			"c :- b.\n"
			"b :- c.\n"
			"#external b. [release]");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		if (ctx.sccGraph.get() && !ufsCheck) {
			ctx.master()->addPost(ufsCheck = new DefaultUnfoundedCheck(*ctx.sccGraph));
		}
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(c)));
	}

	void testIncrementalUnfreezeCompute() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"{d}.\n"
			"a :- b, c.\n"
			"b :- d.\n"
			"#external c.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(3u, ctx.numConstraints());

		lp.updateProgram();
		lpAdd(lp,
			"#external c.[release]\n"
			":- c.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(3u >= ctx.numConstraints());
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 1);
	}

	void testIncrementalCompute() {
		lp.start(ctx, LogicProgram::AspOptions());
		lp.updateProgram();
		Var x2 = 2, x3 = 3, x4 = 4;
		lpAdd(lp,
			"{x2;x3}.\n"
			"x1 :- x2, x3.\n"
			"   :- x1.\n");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		lp.updateProgram();
		lpAdd(lp, "{x4}. :- x2, x4.");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		ctx.master()->assume(lp.getLiteral(x2));
		ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(x3)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(x4)));
	}
	void testIncrementalComputeBackprop() {
		lp.start(ctx, LogicProgram::AspOptions().backpropagate());
		lp.updateProgram();
		lpAdd(lp,
			"a :- not b.\n"
			"b :- not a.\n"
			"  :- not a.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		// I2:
		lp.updateProgram();
		lpAdd(lp, "c :- b. d :- not b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(false, lp.getAtom(c)->hasVar());
		CPPUNIT_ASSERT_EQUAL(lit_true(), lp.getLiteral(d));
	}

	void testIncrementalBackpropStep() {
		lp.start(ctx);
		// I1:
		lp.updateProgram();
		lpAdd(lp, "{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		// I2:
		lp.updateProgram();
		lpAdd(lp, "{c}.    b :- a, c.    :- not b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(a)));
	}

	void testIncrementalEq() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"{c;d}.\n"
			"a :- c.\n"
			"a :- d.\n"
			"b :- a.\n");

		// b == a
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(true, lp.isDefined(a));
		CPPUNIT_ASSERT_EQUAL(false, lp.isDefined(b));

		std::stringstream exp("1 2 1 0 1");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
		lp.updateProgram();
		lpAdd(lp,
			"e :- a, b.\n"
			"#output e : e.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		exp.str("1 5 1 0 1\n5 e");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
	}

	void testIncrementalEqUnfreeze() {
		lp.start(ctx);
		lp.updateProgram();
		lp.freeze(a);
		lp.endProgram();
		lp.updateProgram();
		lpAdd(lp,
			"{d}.\n"
			"a :- c.\n"
			"b :- d, not a.\n"
			"#external a. [release]");

		lp.endProgram();
		CPPUNIT_ASSERT(ctx.numVars() == 2 && ctx.master()->numFreeVars() == 1);
		CPPUNIT_ASSERT(lp.getLiteral(b) == lp.getLiteral(d));
	}

	void testIncrementalEqComplement() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "a :- not b.  b :- not a.");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		PrgAtom* na = lp.getAtom(a);
		PrgAtom* nb = lp.getAtom(b);
		CPPUNIT_ASSERT(nb->literal() == ~na->literal());
		// I1:
		lp.updateProgram();
		lpAdd(lp, "c :- a, b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		PrgAtom* nc = lp.getAtom(c);
		CPPUNIT_ASSERT(nc->hasVar() == false);
	}

	void testIncrementalEqUpdateAssigned() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lp.freeze(a);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		// I1:
		lp.updateProgram();
		lpAdd(lp, "a :- b.  b :- a.");

		PrgAtom* x = lp.getAtom(a);
		x->setValue(value_weak_true);
		lp.endProgram();
		// only weak-true so still relevant in bodies!
		CPPUNIT_ASSERT(x->deps_begin()->sign() == false);
	}

	void testIncrementalEqResetState() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "{a;b}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());

		// I1:
		lp.updateProgram();
		lpAdd(lp,
			"c :- f.\n"
			"d :- g.\n"
			"c :- d, a.\n"
			"d :- c, b.\n"
			"f :- e, not h.\n"
			"g :- e, not i.\n"
			"{e}.");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getAtom(c)->scc() == 0);
		CPPUNIT_ASSERT(lp.getAtom(d)->scc() == 0);
	}

	void testIncrementalUnfreezeUnsuppEq() {
		lp.start(ctx, LogicProgram::AspOptions().noScc());
		// I0:
		lp.updateProgram();
		lp.freeze(a);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		// I1:
		lp.updateProgram();
		lpAdd(lp,
			"a :- b.\n"
			"b :- a, c.\n"
			"{c}.\n");
		lp.endProgram();
		PrgAtom* x = lp.getAtom(a);
		PrgAtom* y = lp.getAtom(b);
		CPPUNIT_ASSERT(ctx.master()->isFalse(x->literal()));
		CPPUNIT_ASSERT(ctx.master()->isFalse(y->literal()));
	}

	void testIncrementalUnfreezeEq() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lp.freeze(a);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// I1:
		lp.updateProgram();
		lpAdd(lp,
			"{c}.\n"
			"b :- c.\n"
			"a :- b.\n");
		PrgAtom* x = lp.getAtom(a);
		lp.endProgram();
		// body {b} is eq to body {c}
		CPPUNIT_ASSERT(ctx.master()->value(x->var()) == value_free);
		CPPUNIT_ASSERT(x->supports() == 1 && x->supps_begin()->node() == 1);
	}

	void testIncrementalStats() {
		LpStats incStats;
		lp.start(ctx, LogicProgram::AspOptions().noEq());
		// I1:
		lp.updateProgram();
		lpAdd(lp,
			"a :- not b.\n"
			"b :- not a.\n"
			"#external c.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		incStats = lp.stats;
		CPPUNIT_ASSERT_EQUAL(uint32(3), incStats.atoms);
		CPPUNIT_ASSERT_EQUAL(uint32(2), incStats.bodies[0].sum());
		CPPUNIT_ASSERT_EQUAL(uint32(2), incStats.rules[0].sum());
		CPPUNIT_ASSERT_EQUAL(uint32(0), incStats.ufsNodes);
		CPPUNIT_ASSERT_EQUAL(uint32(0), incStats.sccs);

		// I2:
		lp.updateProgram();
		lpAdd(lp,
			"{c, f}.\n"
			"d :- not c.\n"
			"d :- e, f.\n"
			"e :- d, f.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		incStats.accu(lp.stats);
		CPPUNIT_ASSERT_EQUAL(uint32(6), incStats.atoms);
		CPPUNIT_ASSERT_EQUAL(uint32(5), incStats.bodies[0].sum());
		CPPUNIT_ASSERT_EQUAL(uint32(6), incStats.rules[0].sum());
		CPPUNIT_ASSERT_EQUAL(uint32(1), incStats.sccs);
		// I3:
		lp.updateProgram();
		lpAdd(lp,
			"g :- d, not i.\n"
			"i :- not g.\n"
			"g :- h.\n"
			"h :- g, not f.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		incStats.accu(lp.stats);
		CPPUNIT_ASSERT_EQUAL(uint32(9), incStats.atoms);
		CPPUNIT_ASSERT_EQUAL(uint32(9), incStats.bodies[0].sum());
		CPPUNIT_ASSERT_EQUAL(uint32(10), incStats.rules[0].sum());
		CPPUNIT_ASSERT_EQUAL(uint32(2), incStats.sccs);
	}

	void testIncrementalTransform() {
		lp.start(ctx, LogicProgram::AspOptions().noEq());
		lp.setExtendedRuleMode(LogicProgram::mode_transform);
		// I1:
		lp.updateProgram();
		lpAdd(lp, "{a}. % -> a :- not a'. a' :- not a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.sccGraph.get() == 0);
		// I2:
		lp.updateProgram();
		lpAdd(lp,
			"% a' must not take up id!\n"
			"b :- a.\n"
			"b :- c.\n"
			"c :- b.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.sccGraph.get() != 0);
	}

	void testIncrementalBackpropCompute() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp,
			"a :- b.\n"
			"  :- not a.\n"
			"#external b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.getRootId(a) == 2);
		PrgAtom* x = lp.getAtom(b);
		CPPUNIT_ASSERT(x->value() == value_weak_true);
		// I1:
		lp.updateProgram();
		lpAdd(lp, "b :- c.  c :- b.");

		// UNSAT: no support for b,c
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram());
	}

	void testIncrementalBackpropSolver() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp,
			"{a}.\n"
			":- not a.\n"
			":- not b.\n"
			"#external b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		PrgAtom* na = lp.getAtom(a);
		PrgAtom* nb = lp.getAtom(b);
		CPPUNIT_ASSERT(na->value() == value_true);
		CPPUNIT_ASSERT(nb->value() == value_weak_true);
		// I1:
		lp.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(na->value() == value_true);
		CPPUNIT_ASSERT(nb->value() == value_weak_true);
	}

	void testIncrementalFreezeUnfreeze() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp,
			"{a}."
			"#external b.\n"
			"#external b. [release]");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(lit_false(), lp.getLiteral(b));
		// I1:
		lp.updateProgram();
		lpAdd(lp,
			"#external c.\n"
			"c :- b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isFalse(lp.getLiteral(b)));
	}
	void testIncrementalSymbolUpdate() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "{a}.");
		lp.addOutput("a", a);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		uint32 os = ctx.output.size();
		// I1:
		lp.updateProgram();
		lpAdd(lp, "{b;c}.");
		lp.addOutput("b", b);

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(!isSentinel(lp.getLiteral(c)));
		CPPUNIT_ASSERT_EQUAL(os + 1, ctx.output.size());
	}
	void testIncrementalFreezeDefined() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// I1:
		lp.updateProgram();
		lpAdd(lp, "#external a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.getAtom(a)->frozen() == false);
	}
	void testIncrementalUnfreezeDefined() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// I1:
		lp.updateProgram();
		lpAdd(lp, "#external a. [release]");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(!ctx.master()->isFalse(lp.getLiteral(a)));
	}
	void testIncrementalUnfreezeAsFact() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "#external a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		Literal litA = lp.getLiteral(a);
		// I1:
		lp.updateProgram();
		lpAdd(lp, "a.");
		CPPUNIT_ASSERT_EQUAL(true , lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(litA, lp.getLiteral(a));
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(a));
		CPPUNIT_ASSERT_EQUAL(true , lp.isDefined(a));
		CPPUNIT_ASSERT_EQUAL(true, ctx.master()->isTrue(litA));
	}
	void testIncrementalImplicitUnfreeze() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "#external a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.getAtom(a)->frozen() == true);
		CPPUNIT_ASSERT(!ctx.master()->isFalse(lp.getLiteral(a)));
		// I1:
		lp.updateProgram();
		lpAdd(lp, "{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.getAtom(a)->frozen() == false);
	}
	void testIncrementalRedefine() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// I1:
		lp.updateProgram();
		CPPUNIT_ASSERT_THROW(lpAdd(lp, "{a}."), RedefinitionError);
	}
	void testIncrementalGetAssumptions() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "#external a. #external b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		LitVec assume;
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 2 && assume[0] == ~lp.getLiteral(a) && assume[1] == ~lp.getLiteral(b));
	}

	void testIncrementalSimplifyCard() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		lp.updateProgram();
		lpAdd(lp,
			"b :- 1 {c, a}.\n"
			"d :- 1 {c, b}.\n"
			"c :- a, b.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
	}

	void testIncrementalSimplifyMinimize() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp, "a. #minimize{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.minimize()->adjust(0) == 1);
		ctx.removeMinimize();

		lp.updateProgram();
		lpAdd(lp, "#minimize{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.hasMinimize());
		CPPUNIT_ASSERT(ctx.minimize()->adjust(0) == 1);
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
	}

	void testIncrementalEqOverNeg() {
		lp.start(ctx);
		// I0: {a}.
		lp.updateProgram();
		lpAdd(lp, "{a}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		// I1:
		lp.updateProgram();
		lpAdd(lp,
			"b :- not a.\n"
			"c :- b.\n"
			"c :- f.\n"
			"d :- c.\n"
			"e :- d.\n"
			"g :- c.\n"
			"h :- not f, c.\n"
			"  :- not e.\n"
			"  :- not h.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(ctx.numVars() == 1 && ctx.master()->isFalse(lp.getLiteral(a)));
	}
	void testIncrementalKeepExternalValue() {
		lp.start(ctx);
		// I0:
		lp.updateProgram();
		lpAdd(lp,
			"b.\n"
			"a :- c.\n"
			"  :- a.\n"
			"#external c. [true]");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		LitVec assume;
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT_EQUAL(false, ctx.master()->pushRoot(assume));

		CPPUNIT_ASSERT_EQUAL(true, lp.update());
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		assume.clear();
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT_EQUAL(false, ctx.master()->pushRoot(assume));

		CPPUNIT_ASSERT_EQUAL(true, lp.update());
		lpAdd(lp, "c.");
		CPPUNIT_ASSERT_EQUAL(false, lp.endProgram());
	}

	void testIncrementalWriteMinimize() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "{a}. #minimize{a}.");
		lp.endProgram();
		std::stringstream exp("6 0 1 0 1 1");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
		lp.updateProgram();
		lpAdd(lp, "{b}. #minimize{b}.");

		lp.endProgram();
		exp.str("6 0 2 0 1 2 1 1");
		CPPUNIT_ASSERT(findSmodels(exp, lp));
		lp.updateProgram();
		lpAdd(lp, "{c}.");
		lp.endProgram();
		exp.clear();
		exp.seekg(0, ios::beg);
		CPPUNIT_ASSERT_EQUAL(false, findSmodels(exp, lp));
	}
	void testIncrementalWriteExternal() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "#external a.");
		lp.endProgram();
		std::stringstream str;
		AspParser::write(lp, str, AspParser::format_aspif);
		bool foundA = false, foundB = false;
		for (std::string x; std::getline(str, x);) {
			if (x.find("5 1 2") == 0) { foundA = true; }
			if (x.find("5 2 2") == 0) { foundB = true; }
		}
		CPPUNIT_ASSERT(foundA && !foundB);
		lp.updateProgram();
		lpAdd(lp, "#external b.");
		lp.endProgram();
		foundA = foundB = false;
		str.clear();
		AspParser::write(lp, str, AspParser::format_aspif);
		for (std::string x; std::getline(str, x);) {
			if (x.find("5 1 2") == 0) { foundA = true; }
			if (x.find("5 2 2") == 0) { foundB = true; }
		}
		CPPUNIT_ASSERT(!foundA && foundB);
	}
	void testIncrementalWriteUnfreeze() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "#external a.");
		lp.endProgram();
		lp.updateProgram();
		lpAdd(lp, "#external a. [release]");
		lp.endProgram();
		CPPUNIT_ASSERT(!lp.isExternal(a));
		std::stringstream str;
		AspParser::write(lp, str, AspParser::format_aspif);
		bool found = false;
		for (std::string x; std::getline(str, x);) {
			if (x.find("5 1 3") == 0) { found = true; break; }
		}
		CPPUNIT_ASSERT(found);
	}
	void testIncrementalSetInputAtoms() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "{a;b;c}.");
		CPPUNIT_ASSERT(lp.numAtoms() == 3);
		lp.setMaxInputAtom(lp.numAtoms());
		Var d = lp.newAtom();
		Var e = lp.newAtom();
		CPPUNIT_ASSERT(d == 4 && e == 5);
		lp.endProgram();
		CPPUNIT_ASSERT(lp.numAtoms() == 5 && lp.startAuxAtom() == 4 && lp.stats.auxAtoms == 2);
		lp.updateProgram();
		CPPUNIT_ASSERT_MESSAGE("aux atoms are removed on update", lp.numAtoms() == 3);
		CPPUNIT_ASSERT_EQUAL(false, lp.validAtom(d));
		CPPUNIT_ASSERT_EQUAL(false, lp.validAtom(e));
		CPPUNIT_ASSERT_EQUAL(d, lp.newAtom());
	}

	void testFreezeIsExternal() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "{b}. #external a.");
		CPPUNIT_ASSERT_EQUAL(true , lp.isExternal(a));
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(b));
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(true , lp.isExternal(a));
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(b));
	}
	void testUnfreezeIsNotExternal() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp,
			"#external a.\n"
			"#external b. [release]\n"
			"#external a. [release]\n"
			"#external b.\n");
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(a));
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(b));
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(a));
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(b));
	}
	void testFreezeStaysExternal() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "#external a.");
		CPPUNIT_ASSERT_EQUAL(true, lp.isExternal(a));
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.isExternal(a));
		lp.updateProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.isExternal(a));
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.isExternal(a));
	}
	void testDefinedIsNotExternal() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "#external a.");
		lp.endProgram();
		lp.updateProgram();
		lpAdd(lp, "a :- b.");
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(a));
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(a));
	}
	void testFactIsNotExternal() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "a. #external a.");
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(a));
	}
	void testFactIsDefined() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "a.");
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(true, lp.isDefined(a));
	}
	void testBogusAtomIsNotDefined() {
		lp.start(ctx);
		lp.updateProgram();
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(false, lp.isDefined(0xDEAD));
		CPPUNIT_ASSERT_EQUAL(false, lp.isExternal(0xDEAD));
		CPPUNIT_ASSERT_EQUAL(lit_false(), lp.getLiteral(0xDEAD));
	}
	void testMakeAtomicCondition() {
		lpAdd(lp.start(ctx), "{a;b}.");
		Potassco::Lit_t cond[2] = { Potassco::lit(a), Potassco::neg(b) };
		Id_t c1 = lp.newCondition(Potassco::toSpan(cond, 1));
		Id_t c2 = lp.newCondition(Potassco::toSpan(cond + 1, 1));
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(c1), lp.getLiteral(a));
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(c2), ~lp.getLiteral(b));
	}

	void testMakeComplexCondition() {
		lpAdd(lp.start(ctx), "{a;b}.");
		Potassco::Lit_t cond[2] = { Potassco::lit(a), Potassco::neg(b) };
		Id_t c1 = lp.newCondition(Potassco::toSpan(cond, 0));
		Id_t c2 = lp.newCondition(Potassco::toSpan(cond, 2));
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(c1), lit_true());
		Literal c2Lit = lp.getLiteral(c2);
		Solver& s = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(value_free, s.value(c2Lit.var()));
		CPPUNIT_ASSERT(s.assume(c2Lit) && s.propagate());
		CPPUNIT_ASSERT(s.isTrue(lp.getLiteral(a)));
		CPPUNIT_ASSERT(s.isFalse(lp.getLiteral(b)));
	}
	void testMakeFalseCondition() {
		lp.start(ctx);
		Var a = lp.newAtom();
		Potassco::Lit_t cond[2] ={Potassco::lit(a), Potassco::neg(a)};
		Id_t c1 = lp.newCondition(Potassco::toSpan(cond, 2));
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(lp.getLiteral(c1), lit_false());
		CPPUNIT_ASSERT_THROW(solverLiteral(lp, c1), std::logic_error);
	}
	void testMakeInvalidCondition() {
		lp.start(ctx);
		Var a = lp.newAtom();
		Var b = lp.newAtom();
		Potassco::Lit_t cond[2] ={Potassco::lit(a), Potassco::neg(b)};
		Id_t c1 = lp.newCondition(Potassco::toSpan(cond, 2));
		Potassco::Lit_t cAsLit = static_cast(c1);
		CPPUNIT_ASSERT_THROW(lp.newCondition(Potassco::toSpan(&cAsLit, 1)), std::logic_error);
	}
	void testExtractCondition() {
		lpAdd(lp.start(ctx), "{a;b}.");
		Potassco::Lit_t cond[2] = { Potassco::lit(a), Potassco::lit(b) };
		Id_t c1 = lp.newCondition(Potassco::toSpan(cond, 2));
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());

		Potassco::LitVec ext;
		lp.extractCondition(c1, ext);
		CPPUNIT_ASSERT(ext.size() == 2 && std::equal(ext.begin(), ext.end(), cond));

		lp.dispose(false);
		CPPUNIT_ASSERT_THROW(lp.extractCondition(c1, ext), std::logic_error);
	}
	void testGetConditionAfterDispose() {
		lpAdd(lp.start(ctx), "{a;b}.");
		Potassco::Lit_t cond[2] = { Potassco::lit(a), Potassco::lit(b) };
		Id_t c1 = lp.newCondition(Potassco::toSpan(cond, 2));
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());

		CPPUNIT_ASSERT(!isSentinel(lp.getLiteral(c1)));
		lp.dispose(false);
		CPPUNIT_ASSERT_THROW(lp.getLiteral(c1), std::logic_error);
	}

	void testAssumptionsAreVolatile() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "{a}. #assume{a}.");
		CPPUNIT_ASSERT(lp.endProgram());
		LitVec assume;
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 1 && assume[0] == lp.getLiteral(a));
		lp.updateProgram();
		lpAdd(lp, "#assume{not a}.");
		CPPUNIT_ASSERT(lp.endProgram());
		assume.clear();
		lp.getAssumptions(assume);
		CPPUNIT_ASSERT(assume.size() == 1 && assume[0] == ~lp.getLiteral(a));
	}

	void testProjectionIsExplicitAndCumulative() {
		lp.start(ctx);
		lp.updateProgram();
		lpAdd(lp, "{a;b}. #project {a}.");
		CPPUNIT_ASSERT(lp.endProgram());

		CPPUNIT_ASSERT(ctx.output.projectMode() == OutputTable::project_explicit);
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), lp.getLiteral(a)) != ctx.output.proj_end());
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), lp.getLiteral(b)) == ctx.output.proj_end());

		lp.updateProgram();
		lpAdd(lp, "{c;d}. #project{d}.");
		CPPUNIT_ASSERT(lp.endProgram());

		CPPUNIT_ASSERT(ctx.output.projectMode() == OutputTable::project_explicit);
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), lp.getLiteral(a)) != ctx.output.proj_end());
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), lp.getLiteral(b)) == ctx.output.proj_end());
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), lp.getLiteral(c)) == ctx.output.proj_end());
		CPPUNIT_ASSERT(std::find(ctx.output.proj_begin(), ctx.output.proj_end(), lp.getLiteral(d)) != ctx.output.proj_end());
	}

	void testTheoryAtomsAreFrozen() {
		lpAdd(lp.start(ctx), "b :- a.");
		Potassco::TheoryData& t = lp.theoryData();
		t.addTerm(0, "Theory");
		t.addAtom(a, 0, Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(a) != lit_false());
		CPPUNIT_ASSERT(lp.isExternal(a));
		CPPUNIT_ASSERT(lp.getLiteral(b) != lit_false());
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.varInfo(lp.getLiteral(a).var()).frozen());
	}
	void testTheoryAtomsAreFrozenIncremental() {
		lp.start(ctx).update();
		lpAdd(lp, "b :- a.");
		Potassco::TheoryData& t = lp.theoryData();
		t.addTerm(0, "Theory");
		t.addAtom(a, 0, Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(a) != lit_false());
		CPPUNIT_ASSERT(lp.getLiteral(b) != lit_false());
		std::stringstream str;
		AspParser::write(lp, str, AspParser::format_aspif);
		for (std::string x; std::getline(str, x);) {
			CPPUNIT_ASSERT(x.find("5 1") != 0);
		}
		lp.update();
		lpAdd(lp,
			"{c}."
			"a :- c.");
		lp.endProgram();
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->value(lp.getLiteral(a).var()) == value_free);
		ctx.addUnary(~lp.getLiteral(c));
		ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(a)));
	}
	void testAcceptIgnoresAuxChoicesFromTheoryAtoms() {
		lp.start(ctx);
		a = lp.newAtom();
		Potassco::TheoryData& t = lp.theoryData();
		t.addTerm(0, "Theory");
		t.addAtom(a, 0, Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(a) != lit_false());
		std::stringstream str;
		AspParser::write(lp, str, AspParser::format_aspif);
		for (std::string x; std::getline(str, x);) {
			CPPUNIT_ASSERT(x.find("1 1") != 0);
			CPPUNIT_ASSERT(x.find("5 1") != 0);
		}
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.varInfo(lp.getLiteral(a).var()).frozen());
	}
	void testFalseHeadTheoryAtomsAreRemoved() {
		lpAdd(lp.start(ctx), "a :- b.");
		Potassco::TheoryData& t = lp.theoryData();
		t.addTerm(0, "Theory");
		t.addAtom(a, 0, Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(a) == lit_false());
		CPPUNIT_ASSERT(lp.getLiteral(b) == lit_false());
		CPPUNIT_ASSERT(t.numAtoms() == 0);
	}
	void testFalseBodyTheoryAtomsAreKept() {
		lp.start(ctx);
		a = lp.newAtom();
		Potassco::TheoryData& t = lp.theoryData();
		t.addTerm(0, "Theory");
		t.addAtom(a, 0, Potassco::toSpan());
		lpAdd(lp, ":- a.");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(a) == lit_false());
		CPPUNIT_ASSERT(t.numAtoms() == 1);
		std::stringstream str;
		AspParser::write(lp, str, AspParser::format_aspif);
		CPPUNIT_ASSERT(str.str().find("1 0 0 0 1 1") != std::string::npos);
	}
	void testFactTheoryAtomsAreNotExternal() {
		lp.start(ctx).updateProgram();
		lpAdd(lp, "a.");
		Potassco::TheoryData& t = lp.theoryData();
		t.addAtom(a, 0, Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(a) == lit_true());
		CPPUNIT_ASSERT(lp.isDefined(a));
		CPPUNIT_ASSERT(lp.isFact(a));
		CPPUNIT_ASSERT(!lp.isExternal(a));
		CPPUNIT_ASSERT(lp.getRootAtom(a)->supports() == 0);
		lp.updateProgram();
		lpAdd(lp, "b.");
		t.addAtom(b, 0, Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(b) == lit_true());
		CPPUNIT_ASSERT(lp.isDefined(b));
		CPPUNIT_ASSERT(lp.isFact(b));
		CPPUNIT_ASSERT(lp.getRootAtom(b)->supports() == 0);
	}
	void testTheoryAtomsAreAdded() {
		lp.start(ctx).updateProgram();
		lpAdd(lp, "{a;b}.");
		Potassco::TheoryData& t = lp.theoryData();
		t.addAtom(c, 0, Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT(lp.getLiteral(c).var() != 0);
		CPPUNIT_ASSERT(lp.isExternal(c));
		lp.updateProgram();
		lpAdd(lp, "c.");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.isFact(c));
		CPPUNIT_ASSERT(!lp.isExternal(c));
		CPPUNIT_ASSERT(ctx.master()->isTrue(lp.getLiteral(c)));
		LitVec vec;
		lp.getAssumptions(vec);
		CPPUNIT_ASSERT(vec.empty());
	}
	void testOutputFactsNotSupportedInSmodels() {
		lp.start(ctx);
		lp.addOutput("Hallo", Potassco::toSpan());
		lp.addOutput("World", Potassco::toSpan());
		lp.endProgram();
		CPPUNIT_ASSERT_EQUAL(false, lp.supportsSmodels());
	}
	void testDisposeBug() {
		lp.start(ctx);
		lp.theoryData().addTerm(0, 99);
		lp.start(ctx);
		CPPUNIT_ASSERT_EQUAL(false, lp.theoryData().hasTerm(0));
	}
private:
	typedef Asp::PrgDepGraph DG;
	SharedContext ctx;
	LogicProgram  lp;
	Var           a, b, c, d, e, f;
};
class SatBuilderTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(SatBuilderTest);
	CPPUNIT_TEST(testPrepare);
	CPPUNIT_TEST(testNoClauses);
	CPPUNIT_TEST(testAddClause);
	CPPUNIT_TEST(testAddSoftClause);
	CPPUNIT_TEST(testAddEmptySoftClause);
	CPPUNIT_TEST(testAddConflicting);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
		builder.startProgram(ctx);
	}
	void testPrepare() {
		builder.prepareProblem(10);
		builder.endProgram();
		CPPUNIT_ASSERT(ctx.numVars() == 10);
	}
	void testNoClauses() {
		builder.prepareProblem(2);
		builder.endProgram();
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 0);
	}
	void testAddClause() {
		builder.prepareProblem(2);
		LitVec clause; clause.push_back(posLit(1)); clause.push_back(posLit(2));
		builder.addClause(clause);
		builder.endProgram();
		CPPUNIT_ASSERT(ctx.numConstraints() == 1);
		CPPUNIT_ASSERT(!ctx.hasMinimize());
	}
	void testAddSoftClause() {
		builder.prepareProblem(3);
		LitVec clause;
		clause.push_back(posLit(1));
		builder.addClause(clause, 1);
		clause.clear();
		clause.push_back(negLit(1));
		clause.push_back(posLit(2));
		clause.push_back(negLit(3));
		builder.addClause(clause, 2);
		builder.endProgram();
		CPPUNIT_ASSERT(ctx.numConstraints() == 1);
		CPPUNIT_ASSERT(ctx.minimize()->numRules() == 1);
		CPPUNIT_ASSERT(ctx.numVars() > 3);
	}
	void testAddEmptySoftClause() {
		builder.prepareProblem(3);
		LitVec clause;
		clause.push_back(posLit(1));
		// force 1
		builder.addClause(clause);

		clause.clear();
		clause.push_back(negLit(1));
		builder.addClause(clause, 1);
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		CPPUNIT_ASSERT(ctx.minimize()->numRules() == 1);
		CPPUNIT_ASSERT(ctx.minimize()->adjust(0) == 1);
	}
	void testAddConflicting() {
		builder.prepareProblem(3);
		LitVec clause;
		clause.push_back(posLit(1));
		CPPUNIT_ASSERT(builder.addClause(clause));
		clause.clear();
		clause.push_back(negLit(1));
		CPPUNIT_ASSERT(builder.addClause(clause) == false);
		clause.clear();
		clause.push_back(posLit(2));
		clause.push_back(posLit(3));
		CPPUNIT_ASSERT(builder.addClause(clause) == false);
		CPPUNIT_ASSERT(builder.endProgram() == false);
		CPPUNIT_ASSERT(ctx.ok() == false);
	}
private:
	SharedContext ctx;
	SatBuilder    builder;
};

class PBBuilderTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(PBBuilderTest);
	CPPUNIT_TEST(testPrepare);
	CPPUNIT_TEST(testNegativeWeight);
	CPPUNIT_TEST(testProduct);
	CPPUNIT_TEST(testProductTrue);
	CPPUNIT_TEST(testProductFalse);
	CPPUNIT_TEST(testInconsistent);
	CPPUNIT_TEST(testInconsistentW);
	CPPUNIT_TEST(testCoefficientReductionOnEq);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
		builder.startProgram(ctx);
	}
	void testPrepare() {
		builder.prepareProblem(10, 0, 0);
		builder.endProgram();
		CPPUNIT_ASSERT(ctx.numVars() == 10);
	}
	void testNegativeWeight() {
		builder.prepareProblem(5, 0, 0);
		WeightLitVec con;
		con.push_back(WeightLiteral(posLit(1), 2));
		con.push_back(WeightLiteral(posLit(2), -2));
		con.push_back(WeightLiteral(posLit(3), -1));
		con.push_back(WeightLiteral(posLit(4), 1));
		con.push_back(WeightLiteral(posLit(5), 1));
		builder.addConstraint(con, 2);
		builder.endProgram();
		CPPUNIT_ASSERT(ctx.numConstraints() == 1);
		CPPUNIT_ASSERT(ctx.master()->numAssignedVars() == 0);
		ctx.master()->assume(negLit(1)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 0);
	}
	void testProduct() {
		builder.prepareProblem(3, 1, 1);
		LitVec p1(3), p2;
		p1[0] = posLit(1);
		p1[1] = posLit(2);
		p1[2] = posLit(3);
		p2    = p1;
		Literal x = builder.addProduct(p1);
		Literal y = builder.addProduct(p2);
		CPPUNIT_ASSERT(x.var() == 4 && x == y);
	}
	void testProductTrue() {
		builder.prepareProblem(3, 1, 1);
		LitVec p1(3);
		p1[0] = posLit(1);
		p1[1] = posLit(2);
		p1[2] = posLit(3);
		ctx.master()->force(posLit(1), 0);
		ctx.master()->force(posLit(2), 0);
		ctx.master()->force(posLit(3), 0);
		Literal x = builder.addProduct(p1);
		CPPUNIT_ASSERT(x == lit_true());
	}
	void testProductFalse() {
		builder.prepareProblem(3, 1, 1);
		LitVec p1(3);
		p1[0] = posLit(1);
		p1[1] = posLit(2);
		p1[2] = posLit(3);
		ctx.master()->force(negLit(2), 0);
		Literal x = builder.addProduct(p1);
		CPPUNIT_ASSERT(x == lit_false());
	}
	void testInconsistent() {
		builder.prepareProblem(1, 0, 0);
		WeightLitVec con;
		con.push_back(WeightLiteral(posLit(1), 1));
		CPPUNIT_ASSERT_EQUAL(true, builder.addConstraint(con, 1));
		con.assign(1, WeightLiteral(posLit(1), 1));
		CPPUNIT_ASSERT_EQUAL(false, builder.addConstraint(con, 0, true));
		CPPUNIT_ASSERT_EQUAL(false, builder.endProgram());
	}
	void testInconsistentW() {
		builder.prepareProblem(2, 0, 0);
		WeightLitVec con;
		con.push_back(WeightLiteral(posLit(1), 1));
		CPPUNIT_ASSERT_EQUAL(true, builder.addConstraint(con, 1));
		con.assign(1, WeightLiteral(posLit(1), 3));
		con.push_back(WeightLiteral(posLit(2), 2));
		CPPUNIT_ASSERT_EQUAL(false, builder.addConstraint(con, 2, true));
		CPPUNIT_ASSERT_EQUAL(false, builder.endProgram());
	}
	void testCoefficientReductionOnEq() {
		builder.prepareProblem(4, 0, 0);
		WeightLitVec con;
		con.push_back(WeightLiteral(posLit(1), 3));
		con.push_back(WeightLiteral(posLit(2), 2));
		con.push_back(WeightLiteral(posLit(3), 1));
		con.push_back(WeightLiteral(posLit(4), 1));
		CPPUNIT_ASSERT_EQUAL(true, builder.addConstraint(con, 2, true));
		CPPUNIT_ASSERT_EQUAL(true, builder.endProgram());
		CPPUNIT_ASSERT(ctx.master()->isFalse(posLit(1)));
	}
private:
	SharedContext ctx;
	PBBuilder     builder;
};
CPPUNIT_TEST_SUITE_REGISTRATION(LogicProgramTest);
CPPUNIT_TEST_SUITE_REGISTRATION(SatBuilderTest);
CPPUNIT_TEST_SUITE_REGISTRATION(PBBuilderTest);
 } }
clasp-3.2.2/libclasp/tests/rule_test.cpp000066400000000000000000000515641304134206100202720ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifdef _MSC_VER
#pragma warning (disable: 4996)
#endif
#include "test.h"
#include "lpcompare.h"
#include 
#include 
namespace Clasp { namespace Test {
using namespace Clasp::Asp;
static bool operator==(const Potassco::LitSpan& lhs, const Potassco::LitSpan& rhs) {
	return lhs.size == rhs.size && std::equal(Potassco::begin(lhs), Potassco::end(lhs), Potassco::begin(rhs));
}
static bool operator==(const Potassco::Sum_t& lhs, const Potassco::Sum_t rhs) {
	return lhs.bound == rhs.bound && lhs.lits.size == rhs.lits.size && std::equal(Potassco::begin(lhs.lits), Potassco::end(lhs.lits), Potassco::begin(rhs.lits));
}
static bool operator==(const Rule& lhs, const Rule& rhs) {
	return lhs.ht == rhs.ht && lhs.head.size == rhs.head.size && std::equal(Potassco::begin(lhs.head), Potassco::end(lhs.head), rhs.head.first)
		&&   lhs.normal() == rhs.normal() && (lhs.normal() ? lhs.cond == rhs.cond : lhs.agg == rhs.agg);
}
static bool operator==(Potassco::RuleBuilder& rb, const Rule& rhs) {
	return rb.rule() == rhs;
}

class RuleTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(RuleTest);
	CPPUNIT_TEST(testHashIgnoresOrder);
	CPPUNIT_TEST(testRemoveDuplicateInNormal);
	CPPUNIT_TEST(testMergeDuplicateInExtended);
	CPPUNIT_TEST(testContraNormal);

	CPPUNIT_TEST(testNoContraExtended);
	CPPUNIT_TEST(testContraExtended);
	CPPUNIT_TEST(testMultiSimplify);
	CPPUNIT_TEST(testCardinalityIfAllWeightsEqual);
	CPPUNIT_TEST(testNormalIfMinWeightNeeded);
	CPPUNIT_TEST(testSelfblockNormal);
	CPPUNIT_TEST(testTautNormal);

	CPPUNIT_TEST(testTrivialDisjunctive);
	CPPUNIT_TEST(testEmptyDisjunctive);
	CPPUNIT_TEST(testDisjunctive);
	CPPUNIT_TEST(testRemoveDuplicateInDisjunctive);
	CPPUNIT_TEST(testDisjunctiveTAUT);
	CPPUNIT_TEST(testDisjunctiveBLOCK);
	CPPUNIT_TEST(testDisjunctiveBLOCKALL);
	CPPUNIT_TEST_SUITE_END();

public:
	void setUp() {
		prg.startProgram(ctx);
	}
	void testHashIgnoresOrder() {
		RuleBuilder r1, r2, r3;
		LogicProgram::SRule info1, info2, info3;
		r1.start().addHead(1).addGoal(Potassco::neg(10)).addGoal(20).addGoal(25).end();
		r2.start().addHead(1).addGoal(20).addGoal(25).addGoal(Potassco::neg(10)).end();
		r3.start().addHead(1).addGoal(25).addGoal(Potassco::neg(10)).addGoal(20).end();
		prg.simplifyRule(r1.rule(), mem, info1);
		prg.simplifyRule(r2.rule(), mem, info2);
		prg.simplifyRule(r3.rule(), mem, info3);
		CPPUNIT_ASSERT(info1.hash == info2.hash && info2.hash == info3.hash);
		CPPUNIT_ASSERT(info1.pos == info2.pos && info2.pos == info3.pos);
	}

	void testRemoveDuplicateInNormal() {
		// a :- b, b, not c -> a :- b, not c.
		rule.start(Head_t::Disjunctive).addHead(1).addGoal(2).addGoal(2).addGoal(Potassco::neg(3)).end();
		prg.simplifyRule(rule.rule(), mem, meta);
		CPPUNIT_ASSERT(1 == meta.pos);
		CPPUNIT_ASSERT(rule.start().addHead(1).addGoal(2).addGoal(Potassco::neg(3)) == mem.rule());
	}

	void testMergeDuplicateInExtended() {
		// a :- 2 {b, not c, b} -> a :- 2 [b=2, not c].
		rule.addHead(1).startSum(2).addGoal(2).addGoal(Potassco::neg(3)).addGoal(2).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(1 == meta.pos);
		CPPUNIT_ASSERT(rule.start().addHead(1).startSum(2).addGoal(2, 2).addGoal(Potassco::neg(3)) == mem.rule());
	}
	void testContraNormal() {
		// a :- b, c, not b.
		rule.start().addHead(1).addGoal(2).addGoal(3).addGoal(Potassco::neg(2)).end();
		CPPUNIT_ASSERT(!prg.simplifyRule(rule.rule(), mem, meta));
	}

	void testNoContraExtended() {
		// a :- 2 {b, c, not b}.
		rule.addHead(1).startSum(2).addGoal(2).addGoal(3).addGoal(Potassco::neg(2)).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		Rule r = mem.rule();
		CPPUNIT_ASSERT(r.bt == Body_t::Count);

		// a :- 4 {not b, b, b, c, d}.
		rule.start().addHead(1).startSum(4).addGoal(Potassco::neg(2)).addGoal(2).addGoal(2).addGoal(3).addGoal(4).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		r = mem.rule();
		CPPUNIT_ASSERT(r.bt == Body_t::Sum);
		CPPUNIT_ASSERT(r.head[0] == 1);

		// a :- 4 [b=2, c=1, not b=1, not c=2].
		rule.start().addHead(1).startSum(4).addGoal(2, 2).addGoal(3).addGoal(Potassco::neg(2)).addGoal(Potassco::neg(3), 2).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		r = mem.rule();
		CPPUNIT_ASSERT(r.bt == Body_t::Sum);
		CPPUNIT_ASSERT(r.head[0] == 1);
	}

	void testContraExtended() {
		// a :- 3 {b, c, not b, not c}.
		rule.addHead(1).startSum(3).addGoal(2).addGoal(3).addGoal(Potassco::neg(2)).addGoal(Potassco::neg(3)).end();
		CPPUNIT_ASSERT(!prg.simplifyRule(rule.rule(), mem, meta));

		// a :- 4 [b=2, c=1, not b=1, not c=1].
		rule.start().addHead(1).startSum(4).addGoal(2, 2).addGoal(3).addGoal(Potassco::neg(2)).addGoal(Potassco::neg(3)).end();
		CPPUNIT_ASSERT(!prg.simplifyRule(rule.rule(), mem, meta));
	}

	void testMultiSimplify() {
		// a :- 1 [b=0,c=0,d=2,e=0] -> a :- d.
		//  - remove 0 weights: 1 [d=2]
		//  - bound weights   : 1 [d=1]
		//  - flatten         : d.
		rule.addHead(1).startSum(1).addGoal(2, 0).addGoal(3, 0).addGoal(4, 2).addGoal(5, 0).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(meta.pos == 1);
		CPPUNIT_ASSERT(rule.start().addHead(1).addGoal(4) == mem.rule());
	}
	void testCardinalityIfAllWeightsEqual() {
		// a :- 3 [b=2,c=2, d=2,e=0] ->
		rule.addHead(1).startSum(3).addGoal(2, 2).addGoal(3, 2).addGoal(4, 2).addGoal(5, 0).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(rule.start().addHead(1).startSum(2).addGoal(2).addGoal(3).addGoal(4).end() == mem.rule());

		// a :- 2 [b=1,c=2 b=1] -> 1 {b,c}
		rule.start().addHead(1).startSum(2).addGoal(2, 1).addGoal(3, 2).addGoal(2, 1).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(rule.start().addHead(1).startSum(1).addGoal(2).addGoal(3) == mem.rule());
	}

	void testNormalIfMinWeightNeeded() {
		// a :- 8 [b=4,c=3, d=2,e=0] -> b,c,d
		rule.addHead(1).startSum(8).addGoal(2, 4).addGoal(3, 3).addGoal(4, 2).addGoal(5, 0).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(rule.start().addHead(1).addGoal(2).addGoal(3).addGoal(4).end() == mem.rule());
	}
	void testSelfblockNormal() {
		// a :- not a.
		rule.start().addHead(1).addGoal(Potassco::neg(1)).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(rule.start().addGoal(Potassco::neg(1)).end() == mem.rule());
	}

	void testTautNormal() {
		// a :- a, b.
		rule.start().addHead(1).addGoal(1).addGoal(2).end();
		CPPUNIT_ASSERT(!prg.simplifyRule(rule.rule(), mem, meta));
	}

	void testTrivialDisjunctive() {
		// a :- x.
		rule.start().addHead(1).addGoal(2).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
	}
	void testEmptyDisjunctive() {
		rule.start().addGoal(2).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
	}

	void testDisjunctive() {
		// a | b :- x.
		rule.start().addHead(1).addHead(2).addGoal(3).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta) && rule == mem.rule());
	}

	void testRemoveDuplicateInDisjunctive() {
		// a | b | a :- x, x.
		rule.start().addHead(1).addHead(2).addHead(1).addGoal(3).addGoal(3).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(rule.start().addHead(1).addHead(2).addGoal(3).end() == mem.rule());
	}

	void testDisjunctiveTAUT() {
		// a | b | c :- b, x.
		rule.start().addHead(1).addHead(2).addHead(3).addGoal(4).addGoal(2).end();
		CPPUNIT_ASSERT(!prg.simplifyRule(rule.rule(), mem, meta));
	}

	void testDisjunctiveBLOCK() {
		// a | b | c :- x, not b.
		rule.start().addHead(1).addHead(2).addHead(3).addGoal(4).addGoal(Potassco::neg(2)).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(rule.start().addHead(1).addHead(3).addGoal(4).addGoal(Potassco::neg(2)).end() == mem.rule());
	}
	void testDisjunctiveBLOCKALL() {
		// a | b :- not a, not b.
		rule.start().addHead(1).addHead(2).addGoal(Potassco::neg(1)).addGoal(Potassco::neg(2)).end();
		CPPUNIT_ASSERT(prg.simplifyRule(rule.rule(), mem, meta));
		CPPUNIT_ASSERT(rule.start().addGoal(Potassco::neg(1)).addGoal(Potassco::neg(2)).end() == mem.rule());
	}
private:
	typedef Potassco::BasicStack BasicStack;
	typedef LogicProgram::SRule SRule;
	typedef Potassco::RuleBuilder RuleBuilder;
	SharedContext ctx;
	LogicProgram  prg;
	RuleBuilder   mem;
	RuleBuilder   rule;
	SRule         meta;
};
class RuleTransformTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(RuleTransformTest);
	CPPUNIT_TEST(testChoiceRuleEmpty);
	CPPUNIT_TEST(testChoiceRuleOneHead);
	CPPUNIT_TEST(testChoiceRuleUseExtraHead);

	CPPUNIT_TEST(testTrivialConstraintRule);
	CPPUNIT_TEST(testUnsatConstraintRule);

	CPPUNIT_TEST(testDegeneratedConstraintRule);
	CPPUNIT_TEST(testBoundEqOneExp);
	CPPUNIT_TEST(testBoundEqOneQuad);

	CPPUNIT_TEST(testSixThreeExp);
	CPPUNIT_TEST(testSixThreeQuad);

	CPPUNIT_TEST(testWeightSixFourExp);
	CPPUNIT_TEST(testWeightFourExp);
	CPPUNIT_TEST(testWeightSixFourQuad);
	CPPUNIT_TEST(testWeightBug);
	CPPUNIT_TEST(testDegeneratedWeightRule);

	CPPUNIT_TEST(testStupidWeightBug);
	CPPUNIT_TEST(testWeightBogusNormal);

	CPPUNIT_TEST(testShiftDisjunction);

	CPPUNIT_TEST(testMixedRule);
	CPPUNIT_TEST(testDisjMixedRule);

	CPPUNIT_TEST_SUITE_END();

public:
	void setUp() {
		prg.start(ctx, LogicProgram::AspOptions().noEq().noScc());
		for (Var v; (v = prg.newAtom()) != 7;) { ; }
	}
	void testChoiceRuleEmpty() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_choice);
		prg.addRule(Head_t::Choice, Potassco::toSpan(), Potassco::toSpan());
		CPPUNIT_ASSERT_EQUAL(0u, prg.stats.rules[1][RuleStats::Choice]);
	}
	void testChoiceRuleOneHead() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_choice);
		lpAdd(prg, "{a}.");;

		prg.endProgram();
		std::stringstream exp;
		exp << "1 1 1 1 8 \n"
			  << "1 8 1 1 1 \n";
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testChoiceRuleUseExtraHead() {
		lpAdd(prg, "{d,e,f,g}.");
		prg.setExtendedRuleMode(LogicProgram::mode_transform_choice);
		lpAdd(prg, "{a,b,c} :- d, e, not f, not g.");

		prg.endProgram();
		std::stringstream exp;
		exp << "1 1 2 1 9 8\n"      // a    :- auxBody, not auxA.
		    << "1 9 1 1 1\n"        // auxA :- not a.
		    << "1 2 2 1 10 8\n"     // b    :- auxBody, not auxB.
		    << "1 10 1 1 2\n"       // auxB :- not b.
		    << "1 3 2 1 11 8\n"     // c    :- auxBody, not auxC.
		    << "1 11 1 1 3\n"       // auxC :- not c.
		    << "1 8 4 2 6 7 4 5\n"; // auxB :- d, e, not f, not g.
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testTrivialConstraintRule() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform);
		Potassco::Atom_t a = 1;
		prg.addRule(Head_t::Disjunctive, Potassco::toSpan(&a, 1), 0, Potassco::toSpan());
		prg.endProgram();
		CPPUNIT_ASSERT_EQUAL(1u, prg.stats.rules[1].sum());
	}

	void testUnsatConstraintRule() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform);
		lpAdd(prg, "a :- 2 {b}.");
		CPPUNIT_ASSERT_EQUAL(0u, prg.stats.rules[0].sum());

		lpAdd(prg, "a :- 3 {b = 2}.");
		CPPUNIT_ASSERT_EQUAL(0u, prg.stats.rules[0].sum());
	}
	void testDegeneratedConstraintRule() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform);
		lpAdd(prg,
			"{b, c, d}."
			"a :- 3 { b, c, d }.");
		CPPUNIT_ASSERT_EQUAL(0u, prg.stats.bodies[0][Body_t::Count]);
	}
	void testBoundEqOneExp() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg,
			"{b, c, d}."
			"a :- 1 { b, c, d }.");
		prg.endProgram();
		CPPUNIT_ASSERT_EQUAL(4u, prg.stats.rules[1].sum());
		std::stringstream exp;
		exp << "1 1 1 0 2 \n"
		    << "1 1 1 0 3 \n"
		    << "1 1 1 0 4 \n";
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}
	void testBoundEqOneQuad() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg,"{b, c, d}.");
		// a :- 1 { b, c, d }.
		rule.addHead(1).startSum(1).addGoal(2).addGoal(3).addGoal(4);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(4u, tm.transform(rule.rule(), RuleTransform::strategy_split_aux));
		prg.endProgram();
		std::stringstream exp;
		exp << "1 1 1 0 2 \n"
		    << "1 1 1 0 8 \n"
		    << "1 8 1 0 3 \n"
		    << "1 8 1 0 4 \n";
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}
	void testSixThreeExp() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg, "{b, c, d, e, f, g}.");
		// a :- 3 {b, c, d, e, f, g}
		rule.addHead(1).startSum(3).addGoal(2).addGoal(3).addGoal(4).addGoal(5).addGoal(6).addGoal(7);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(20u, tm.transform(rule.rule(), RuleTransform::strategy_select_no_aux));
		prg.endProgram();
		std::stringstream exp;
		exp // starting with b
			<< "1 1 3 0 2 3 4 \n"
			<< "1 1 3 0 2 3 5 \n"
			<< "1 1 3 0 2 3 6 \n"
			<< "1 1 3 0 2 3 7 \n"
			<< "1 1 3 0 2 4 5 \n"
			<< "1 1 3 0 2 4 6 \n"
			<< "1 1 3 0 2 4 7 \n"
			<< "1 1 3 0 2 5 6 \n"
			<< "1 1 3 0 2 5 7 \n"
			<< "1 1 3 0 2 6 7 \n"
			// starting with c
			<< "1 1 3 0 3 4 5 \n"
			<< "1 1 3 0 3 4 6 \n"
			<< "1 1 3 0 3 4 7 \n"
			<< "1 1 3 0 3 5 6 \n"
			<< "1 1 3 0 3 5 7 \n"
			<< "1 1 3 0 3 6 7 \n"
			// starting with d
			<< "1 1 3 0 4 5 6 \n"
			<< "1 1 3 0 4 5 7 \n"
			<< "1 1 3 0 4 6 7 \n"
			// starting with e
			<< "1 1 3 0 5 6 7 \n";
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testSixThreeQuad() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg, "{b, c, d, e, f, g}.");
		// a :- 3 {b, c, d, e, f, g}
		rule.addHead(1).startSum(3).addGoal(2).addGoal(3).addGoal(4).addGoal(5).addGoal(6).addGoal(7);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(18u, tm.transform(rule.rule()));
		CPPUNIT_ASSERT_EQUAL(15u, prg.numAtoms());
		prg.endProgram();
		std::stringstream exp;
		exp
			<< "1 1 2 0 2 8 \n"   // a     :- b, (c,2)
			<< "1 1 1 0 9 \n"     // a     :- (c,3)

			<< "1 8 2 0 3 10 \n"  // (c,2) :- c, (d,1)
			<< "1 8 1 0 11 \n"    // (c,2) :- (d,2)
			<< "1 9 2 0 3 11 \n"  // (c,3) :- c, (d,2)
			<< "1 9 1 0 12 \n"    // (c,3) :- (d,3)

			<< "1 10 1 0 4 \n"    // (d,1) :- d.
			<< "1 10 1 0 13 \n"   // (d,1) :- (e,1)
			<< "1 11 2 0 4 13 \n" // (d,2) :- d, (e,1).
			<< "1 11 1 0 14 \n"   // (d,2) :- (e,2).
			<< "1 12 2 0 4 14 \n" // (d,3) :- d, (e,2).
			<< "1 12 3 0 5 6 7 \n"// (d,3) :- (e,2).

			<< "1 13 1 0 5 \n"    // (e,1) :- e.
			<< "1 13 1 0 15 \n"   // (e,1) :- (f,1).
			<< "1 14 2 0 5 15 \n" // (e,2) :- e, (f,1).
			<< "1 14 2 0 6 7 \n"  // (e,2) :- f,g.

			<< "1 15 1 0 6 \n"    // (f,1) :- f
			<< "1 15 1 0 7 \n";   // (f,1) :- g
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testWeightSixFourExp() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg, "{b, c, d, e, f, g}.");
		// a :- 4 {b=4, c=3, d=2, e=2, f=1, g=1}
		rule.addHead(1).startSum(4).addGoal(2, 4).addGoal(3, 3).addGoal(4, 2).addGoal(5, 2).addGoal(6, 1).addGoal(7, 1);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(8u, tm.transform(rule.rule(), RuleTransform::strategy_select_no_aux));
		prg.endProgram();
		std::stringstream exp;
		exp // starting with b
			<< "1 1 1 0 2 \n"
			<< "1 1 2 0 3 4 \n"
			<< "1 1 2 0 3 5 \n"
			<< "1 1 2 0 3 6 \n"
			<< "1 1 2 0 3 7 \n"
			<< "1 1 2 0 4 5 \n"
			<< "1 1 3 0 4 6 7 \n"
			<< "1 1 3 0 5 6 7 \n";
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}
	void testWeightFourExp() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		Var a = 1, b = 2, c = 3, d = 4, e = 5;
		lpAdd(prg, "{b, c, d, e}.");
		// a :- 4 {b = 2, c = 2, d = 1, e = 1}.
		rule.addHead(a).startSum(4).addGoal(b, 2).addGoal(c, 2).addGoal(d, 1).addGoal(e, 1);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(3u, tm.transform(rule.rule(), RuleTransform::strategy_select_no_aux));
		prg.endProgram();
		std::stringstream exp;
		exp
			<< "1 1 2 0 2 3 \n"
			<< "1 1 3 0 2 4 5 \n"
			<< "1 1 3 0 3 4 5 \n";
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testWeightSixFourQuad() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg, "{b, c, d, e, f, g}.");
		// a :- 4 {b=4, c=3, d=2, e=2, f=1, g=1}
		rule.addHead(1).startSum(4).addGoal(2, 4).addGoal(3, 3).addGoal(4, 2).addGoal(5, 2).addGoal(6, 1).addGoal(7, 1);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(14u, tm.transform(rule.rule()));
		CPPUNIT_ASSERT(13u == prg.numAtoms());
		prg.endProgram();
		std::stringstream exp;
		exp // head
			<< "1 1 1 0 2 \n"     // a     :- b.
			<< "1 1 1 0 8 \n"     // a     :- (c, 4)

			<< "1 8 2 0 3 9 \n"   // (c,4) :- c, (d,1).
			<< "1 8 1 0 10 \n"    // (c,4) :- (d, 4)

			<< "1 9 1 0 4 \n"     // (d,1) :- d.
			<< "1 9 1 0 11 \n"    // (d,1) :- (e, 1)
			<< "1 10 2 0 4 12 \n" // (d,4) :- d, (e,2)
			<< "1 10 3 0 5 6 7 \n"// (d,4) :- e,f,g.

			<< "1 11 1 0 5 \n"    // (e,1) :- e.
			<< "1 12 1 0 5 \n"    // (e,2) :- e.
			<< "1 11 1 0 13 \n"   // (e,1) :- (f,1).
			<< "1 12 2 0 6 7 \n"  // (e,2) :- f,g.

			<< "1 13 1 0 6 \n"    // (f,1) :- f.
			<< "1 13 1 0 7 \n";   // (f,1) :- g.

		CPPUNIT_ASSERT(findSmodels(exp, prg));

	}

	void testWeightBug() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg, "{b, c, d}.");
		// a :- 5 {b=3, c=3, d=1}
		rule.addHead(1).startSum(5).addGoal(2, 3).addGoal(3, 3).addGoal(4, 1);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(2u, tm.transform(rule.rule()));
		CPPUNIT_ASSERT(8u == prg.numAtoms());
		prg.endProgram();
		std::stringstream exp;
		exp
			<< "1 1 2 0 2 8 \n"// a    :- b, (c, 2)
			<< "1 8 1 0 3 \n"; // (c,2):- c.
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testDegeneratedWeightRule() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg, "{b, c, d}.");
		// a :- 20 {b=18, c=18, d=18}
		rule.addHead(1).startSum(20).addGoal(2, 18).addGoal(3, 18).addGoal(4, 18);
		Potassco::RuleBuilder mem;
		LogicProgram::SRule meta;
		prg.simplifyRule(rule.rule(), mem, meta);
		RuleTransform tm(prg);
		CPPUNIT_ASSERT_EQUAL(3u, tm.transform(mem.rule(), RuleTransform::strategy_select_no_aux));
		prg.endProgram();
		std::stringstream exp;
		exp
			<< "1 1 2 0 2 3 \n"  // a :- b, c
			<< "1 1 2 0 2 4 \n"  // a :- b, d
			<< "1 1 2 0 3 4 \n"; // a :- c, d
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testStupidWeightBug() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		Var v8 = prg.newAtom();
		Var v9 = prg.newAtom();
		lpAdd(prg, "{a,b,c,d,e,f,g,h}.");
		// x :- 24 {a=31, b=29, c=29, d=28, e=21, f=15, g=8, h=5}
		rule.addHead(v9).startSum(24).addGoal(1, 31).addGoal(2, 29).addGoal(3, 29).addGoal(4, 28).addGoal(5, 21).addGoal(6, 15)
			.addGoal(7, 8).addGoal(v8, 5);

		RuleTransform tm(prg);
		uint32 prev = prg.numAtoms();
		CPPUNIT_ASSERT_EQUAL(14u, tm.transform(rule.rule()));
		CPPUNIT_ASSERT(prg.numAtoms() == prev+6);
		prg.endProgram();
		std::stringstream exp;
		exp  << "1 13 3 0 6 7 8 \n";
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}

	void testWeightBogusNormal() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform_weight);
		lpAdd(prg, "{a,b,c}.");
		// a :- 24 {b=12,c=12}.
		rule.addHead(1).startSum(24).addGoal(2, 12).addGoal(3, 12);
		RuleTransform tm(prg);
		uint32 prev = prg.numAtoms();
		CPPUNIT_ASSERT_EQUAL(1u, tm.transform(rule.rule()));
		CPPUNIT_ASSERT(prg.numAtoms() == prev);
	}

	void testShiftDisjunction() {
		rule.start().addHead(1).addHead(2).addGoal(3).addGoal(4);
		RuleTransform tm(prg);
		uint32 nr = tm.transform(rule.rule());
		CPPUNIT_ASSERT(3 == nr);
	}
	void testMixedRule() {
		prg.setExtendedRuleMode(LogicProgram::mode_transform);
		lpAdd(prg,
			"{a} :- 3 {b=2, c=1, d=2, e=1}."
			"{b,c,d,e}.");
		CPPUNIT_ASSERT(prg.endProgram());
		std::stringstream exp;
		exp
			<< "1 8 2 0 2 3 \n"  // aux :- b, c
			<< "1 8 2 0 2 4 \n"  // aux :- b, d
			<< "1 8 2 0 2 5 \n"  // aux :- b, e
			<< "1 1 2 1 9 8\n";  // a   :- not a', aux
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}
	void testDisjMixedRule() {
		LogicProgram prg;
		SharedContext ctx;
		prg.start(ctx);
		prg.setExtendedRuleMode(LogicProgram::mode_transform);
		lpAdd(prg,
			"a|b :- 3{c=2, d=1, e=2, f=1}."
			"a :- b."
			"b :- a."
			"{c,d,e,f}.");
		CPPUNIT_ASSERT(prg.endProgram());
		std::stringstream exp;
		exp
			<< "1 7 2 0 3 4 \n"   // aux :- c, d
			<< "1 7 2 0 3 5 \n"   // aux :- c, e
			<< "1 7 2 0 3 6 \n"   // aux :- c, f
			<< "8 2 1 2 1 0 7\n"; // a|b :- aux
		CPPUNIT_ASSERT(findSmodels(exp, prg));
	}
private:
	typedef Potassco::RuleBuilder RuleBuilder;
	SharedContext ctx;
	LogicProgram  prg;
	RuleBuilder   rule;
};
CPPUNIT_TEST_SUITE_REGISTRATION(RuleTest);
CPPUNIT_TEST_SUITE_REGISTRATION(RuleTransformTest);

} }

clasp-3.2.2/libclasp/tests/satelite_test.cpp000066400000000000000000000145711304134206100211320ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 
#include 
#include 
#include 
#include 
#include 
#ifdef _MSC_VER
#pragma warning (disable : 4267) //  conversion from 'size_t' to unsigned int
#pragma once
#endif


namespace Clasp { namespace Test {

class SatEliteTest : public CppUnit::TestFixture {
  CPPUNIT_TEST_SUITE(SatEliteTest);

	CPPUNIT_TEST(testDontAddSatClauses);
	CPPUNIT_TEST(testSimpleSubsume);
	CPPUNIT_TEST(testSimpleStrengthen);

	CPPUNIT_TEST(testClauseCreatorAddsToPreprocessor);

	CPPUNIT_TEST(testDimacs);
	CPPUNIT_TEST(testFreeze);

	CPPUNIT_TEST(testElimPureLits);
	CPPUNIT_TEST(testDontElimPureLits);
	CPPUNIT_TEST(testExtendModel);
	CPPUNIT_TEST(testExtendModel2);
	CPPUNIT_TEST_SUITE_END();
public:
	SatEliteTest(){
		for (int i = 0; i < 10; ++i) {
			ctx.addVar(Var_t::Atom);
		}
		opts.satPre.type = SatPreParams::sat_pre_ve_bce;
		ctx.startAddConstraints();
	}

	void testDontAddSatClauses() {
		LitVec cl;
		cl.push_back(posLit(1)); cl.push_back(posLit(2));
		pre.addClause(cl);
		ctx.addUnary(posLit(1));
		CPPUNIT_ASSERT_EQUAL(true, pre.preprocess(ctx, opts.satPre));
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
	}

	void testSimpleSubsume() {
		LitVec cl;
		cl.push_back(posLit(1)); cl.push_back(posLit(2));
		pre.addClause(cl);
		cl.push_back(posLit(3));
		pre.addClause(cl);
		CPPUNIT_ASSERT_EQUAL(true, pre.preprocess(ctx, opts.satPre));
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
	}

	void testSimpleStrengthen() {
		LitVec cl;
		cl.push_back(posLit(1)); cl.push_back(posLit(2));
		pre.addClause(cl);
		cl[0] = negLit(1);
		pre.addClause(cl);
		CPPUNIT_ASSERT_EQUAL(true, pre.preprocess(ctx, opts.satPre));
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
	}

	void testClauseCreatorAddsToPreprocessor() {
		ctx.setConfiguration(&opts, Ownership_t::Retain);
		ctx.setPreserveModels();
		ClauseCreator nc(ctx.master());
		nc.start().add(posLit(1)).add(posLit(2)).end();
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numConstraints());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numBinary());
	}

	void testDimacs() {
		std::stringstream prg;
		SharedContext ctx2;
		opts.satPre.disableBce();
		ctx2.setConfiguration(&opts, Ownership_t::Retain);
		SatBuilder api;
		api.startProgram(ctx2);

		prg << "c simple test case\n"
				<< "p cnf 2 4\n"
			  << "1 2 2 1 0\n"
				<< "1 2 1 2 0\n"
				<< "-1 -2 -1 0\n"
				<< "-2 -1 -2 0\n";
		CPPUNIT_ASSERT(api.parseProgram(prg) && api.endProgram());
		CPPUNIT_ASSERT(ctx2.numVars() == 2 && ctx2.master()->numAssignedVars() == 0);
		CPPUNIT_ASSERT(ctx2.endInit());
		CPPUNIT_ASSERT(ctx2.eliminated(2));
	}

	void testFreeze() {
		std::stringstream prg;
		SharedContext ctx2;
		ctx2.setConfiguration(&opts, Ownership_t::Retain);
		SatBuilder api;
		api.startProgram(ctx2);
		prg << "c simple test case\n"
				<< "p cnf 2 2\n"
			  << "1 2 0\n"
				<< "-1 -2 0\n";
		CPPUNIT_ASSERT(api.parseProgram(prg));
		ctx2.setFrozen(1, true);
		ctx2.setFrozen(2, true);
		CPPUNIT_ASSERT(ctx2.numVars() == 2);
		CPPUNIT_ASSERT(ctx2.endInit());
		CPPUNIT_ASSERT(ctx2.numConstraints() == 2);
		CPPUNIT_ASSERT(ctx2.numBinary() == 2);
	}

	void testElimPureLits() {
		LitVec cl;
		cl.push_back(posLit(1)); cl.push_back(posLit(2));
		pre.addClause(cl);
		opts.satPre.disableBce();
		pre.preprocess(ctx, opts.satPre);
		CPPUNIT_ASSERT(0u == ctx.numConstraints());
		CPPUNIT_ASSERT(ctx.eliminated(1) == true);
	}
	void testDontElimPureLits() {
		LitVec cl;
		cl.push_back(posLit(1)); cl.push_back(posLit(2));
		pre.addClause(cl);
		ctx.setPreserveModels(true);
		pre.preprocess(ctx, opts.satPre);
		CPPUNIT_ASSERT(1u == ctx.numConstraints());
		CPPUNIT_ASSERT(ctx.eliminated(1) == false);
	}

	void testExtendModel() {
		SharedContext ctx2;
		ctx2.setPreserveModels(true);
		opts.satPre.disableBce();
		ctx2.setConfiguration(&opts, Ownership_t::Retain);
		ctx2.addVar(Var_t::Atom);
		ctx2.addVar(Var_t::Atom);
		ctx2.addVar(Var_t::Atom);
		ctx2.startAddConstraints();
		ClauseCreator nc(ctx2.master());
		nc.start().add(negLit(1)).add(posLit(2)).end();
		nc.start().add(posLit(1)).add(negLit(2)).end();
		nc.start().add(posLit(2)).add(negLit(3)).end();
		ctx2.endInit();
		CPPUNIT_ASSERT(1u == ctx2.numConstraints());
		CPPUNIT_ASSERT(ctx2.eliminated(1) == true && ctx2.numEliminatedVars() == 1);
		// Eliminated vars are initially assigned
		CPPUNIT_ASSERT(value_free != ctx2.master()->value(1));
		ctx2.master()->assume(negLit(2)) && ctx2.master()->propagate();
		ctx2.master()->search(-1, -1, 1.0);
		// negLit(2) -> negLit(1) -> 1 == F
		CPPUNIT_ASSERT_EQUAL(value_false, ctx2.master()->model[1]);
	}

	void testExtendModel2() {
		SharedContext ctx2;
		ctx2.setPreserveModels(true);
		opts.satPre.disableBce();
		ctx2.setConfiguration(&opts, Ownership_t::Retain);
		ctx2.addVar(Var_t::Atom);
		ctx2.addVar(Var_t::Atom);
		ctx2.addVar(Var_t::Atom);
		ctx2.addVar(Var_t::Atom);
		ctx2.startAddConstraints();
		ClauseCreator nc(ctx2.master());

		nc.start().add(posLit(1)).add(posLit(3)).add(posLit(2)).end();
		nc.start().add(negLit(1)).add(posLit(3)).add(negLit(2)).end();

		nc.start().add(posLit(2)).add(posLit(3)).add(posLit(4)).end();
		nc.start().add(negLit(2)).add(posLit(3)).add(negLit(4)).end();

		ctx2.endInit();
		ctx2.master()->assume(posLit(3));
		ctx2.master()->search(-1, -1, 1.0);
		uint32 n = 1;
		LitVec sym = ctx2.master()->symmetric();
		while (!sym.empty()) {
			++n;
			ctx2.satPrepro->extendModel(ctx2.master()->model, sym);
		}
		CPPUNIT_ASSERT(n == 4);
	}
private:
	SharedContext  ctx;
	SatElite	     pre;
	BasicSatConfig opts;
};
CPPUNIT_TEST_SUITE_REGISTRATION(SatEliteTest);
} }
clasp-3.2.2/libclasp/tests/shared_clause_test.cpp000066400000000000000000000203101304134206100221060ustar00rootroot00000000000000//
// Copyright (c) 2009, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 
#include 
#include 
#ifdef _MSC_VER
#pragma warning (disable : 4267) //  conversion from 'size_t' to unsigned int
#pragma once
#endif


namespace Clasp { namespace Test {
using namespace Clasp::mt;
class SharedClauseTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(SharedClauseTest);
	CPPUNIT_TEST(testClauseCtorAddsWatches);
	CPPUNIT_TEST(testPropSharedClauseConflict);
	CPPUNIT_TEST(testPropRandomClauses);
	CPPUNIT_TEST(testPropAlreadySatisfied);
	CPPUNIT_TEST(testReasonBumpsActivityIfLearnt);
	CPPUNIT_TEST(testSimplifySAT);
	CPPUNIT_TEST(testSimplifyUnique);
	CPPUNIT_TEST(testSimplifyShared);

	CPPUNIT_TEST(testCloneShared);
	CPPUNIT_TEST_SUITE_END();
public:
	typedef ConstraintInfo ClauseInfo;
	SharedClauseTest() {
		a1 = posLit(ctx.addVar(Var_t::Atom));
		a2 = posLit(ctx.addVar(Var_t::Atom));
		a3 = posLit(ctx.addVar(Var_t::Atom));
		b1 = posLit(ctx.addVar(Var_t::Body));
		b2 = posLit(ctx.addVar(Var_t::Body));
		b3 = posLit(ctx.addVar(Var_t::Body));

		for (int i = 6; i < 15; ++i) {
			ctx.addVar(Var_t::Atom);
		}
		ctx.startAddConstraints(10);
	}
	void testClauseCtorAddsWatches() {
		makeLits(2, 2);
		ClauseHead* sharedCl= createShared(ctx, clLits, ClauseInfo());
		ctx.add(sharedCl);
		CPPUNIT_ASSERT_EQUAL(2, countWatches(*ctx.master(), sharedCl, clLits));
	}

	void testPropSharedClauseConflict() {
		makeLits(2, 2);
		ClauseHead* c = createShared(ctx, clLits, ClauseInfo());
		simplePropTest(c);
	}

	void testPropRandomClauses() {
		for (int i = 0; i != 100; ++i) {
			SharedContext cc;
			for (int j = 0; j < 12; ++j) { cc.addVar(Var_t::Atom); }
			cc.startAddConstraints(1);

			makeRandomClause( (rand() % 10) + 2 );
			ClauseHead* c = createShared(cc, clLits, ClauseInfo());
			cc.add(c);
			check(*cc.master(), c);
		}
	}

	void testPropAlreadySatisfied() {
		makeLits(2, 2);
		ClauseHead* c1 = createShared(ctx, clLits, ClauseInfo());
		ctx.add(c1);

		// satisfy the clauses...
		ctx.addUnary(clLits[3]);
		ctx.master()->propagate();

		// ...make all but one literal false
		ctx.addUnary(~clLits[0]);
		ctx.addUnary(~clLits[1]);
		ctx.master()->propagate();

		// ...and assert that the last literal is still unassigned
		CPPUNIT_ASSERT(value_free == ctx.master()->value(clLits[2].var()));
	}

	void testReasonBumpsActivityIfLearnt() {
		makeLits(4, 0);
		ctx.endInit();
		ClauseInfo e(Constraint_t::Conflict);
		ClauseHead* c = createShared(ctx, clLits, e);
		Solver& solver= *ctx.master();
		solver.addLearnt(c, (uint32)clLits.size());

		solver.assume(~clLits[0]);
		solver.propagate();
		solver.assume(~clLits[1]);
		solver.propagate();
		uint32 a = c->activity().activity();
		solver.assume(~clLits[2]);
		solver.force(~clLits[3], Antecedent(0));
		CPPUNIT_ASSERT_EQUAL(false, solver.propagate());
		CPPUNIT_ASSERT_EQUAL(a+1, c->activity().activity());
	}

	void testSimplifySAT() {
		makeLits(3, 2);
		ClauseHead* c1 = createShared(ctx, clLits, ClauseInfo());
		ctx.add(c1);

		ctx.addUnary(~clLits[4]);
		ctx.addUnary(clLits[3]);
		ctx.master()->propagate();

		CPPUNIT_ASSERT_EQUAL(true, c1->simplify(*ctx.master(), false));
	}

	void testSimplifyUnique() {
		makeLits(3, 3);
		ClauseHead* c = createShared(ctx, clLits, ClauseInfo());
		ctx.add(c);

		ctx.addUnary(~clLits[2]);
		ctx.addUnary(~clLits[3]);
		ctx.master()->propagate();

		CPPUNIT_ASSERT_EQUAL(false, c->simplify(*ctx.master(), false));
		CPPUNIT_ASSERT(4 == c->size());
		CPPUNIT_ASSERT_EQUAL(2, countWatches(*ctx.master(), c, clLits));
	}

	void testSimplifyShared() {
		makeLits(3, 3);
		SharedLiterals* sLits   = SharedLiterals::newShareable(clLits, Constraint_t::Conflict);
		CPPUNIT_ASSERT(sLits->unique() && sLits->type() == Constraint_t::Conflict && sLits->size() == 6);
		SharedLiterals* other   = sLits->share();
		CPPUNIT_ASSERT(!sLits->unique());

		ctx.addUnary(~clLits[2]);
		ctx.addUnary(~clLits[3]);
		ctx.master()->propagate();

		CPPUNIT_ASSERT_EQUAL(uint32(4), sLits->simplify(*ctx.master()));
		CPPUNIT_ASSERT_EQUAL(uint32(6), sLits->size());
		sLits->release();
		other->release();
	}

	void testCloneShared() {
		makeLits(3, 2);
		ClauseHead* c = createShared(ctx, clLits, ClauseInfo());
		Solver& solver2 = ctx.pushSolver();
		ctx.endInit(true);
		ClauseHead* clone = (ClauseHead*)c->cloneAttach(solver2);
		LitVec lits;
		clone->toLits(lits);
		CPPUNIT_ASSERT(lits == clLits);
		CPPUNIT_ASSERT(countWatches(solver2, clone, clLits) == 2);
		c->destroy(ctx.master(), true);

		for (uint32 i = 0; i != clLits.size()-1; ++i) {
			solver2.assume(~clLits[i]);
			solver2.propagate();
		}
		CPPUNIT_ASSERT(solver2.isTrue(clLits.back()));
		CPPUNIT_ASSERT(solver2.reason(clLits.back()) == clone);

		clone->destroy(&solver2, true);

	}
private:
	SharedContext ctx;
	LitVec clLits;
	Literal a1, a2, a3, b1, b2, b3;
	ClauseHead* createShared(SharedContext& ctx, const LitVec& lits, const ClauseInfo& e) {
		assert(lits.size() >= 2);
		SharedLiterals* shared_lits = SharedLiterals::newShareable(lits, e.type());
		return SharedLitsClause::newClause(*ctx.master(), shared_lits, e, &lits[0], false);
	}

	void simplePropTest(ClauseHead* c) {
		Solver& solver = *ctx.master();
		solver.add(c);
		solver.assume(~clLits[0]);
		solver.propagate();
		solver.assume( ~clLits.back() );
		solver.propagate();
		solver.assume(~clLits[1]);
		solver.propagate();

		CPPUNIT_ASSERT_EQUAL(true, solver.isTrue( clLits[2] ) );
		CPPUNIT_ASSERT_EQUAL(true, c->locked(solver));
		Antecedent reason = solver.reason(clLits[2]);
		CPPUNIT_ASSERT(reason == c);

		LitVec r;
		reason.reason(solver, clLits[2], r);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[0]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[1]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~clLits[3]) != r.end());
	}
	int countWatches(const Solver& s, ClauseHead* c, const LitVec& lits) {
		int w     = 0;
		for (LitVec::size_type i = 0; i != lits.size(); ++i) {
			w += s.hasWatch(~lits[i], c);
		}
		return w;
	}
	void check(Solver& solver, ClauseHead* c) {
		std::string s = toString(clLits);
		std::random_shuffle(clLits.begin(), clLits.end());
		CPPUNIT_ASSERT( value_free == solver.value(clLits.back().var()) );
		for (LitVec::size_type i = 0; i != clLits.size() - 1; ++i) {
			CPPUNIT_ASSERT( value_free == solver.value(clLits[i].var()) );
			solver.force(~clLits[i], 0);
			solver.propagate();
		}
		CPPUNIT_ASSERT_EQUAL_MESSAGE(s.c_str(), true, solver.isTrue(clLits.back()));

		Antecedent reason = solver.reason(clLits.back());
		CPPUNIT_ASSERT(reason == c);
		LitVec r;
		c->reason(solver, clLits.back(), r);
		for (LitVec::size_type i = 0; i != clLits.size() - 1; ++i) {
			LitVec::iterator it = std::find(r.begin(), r.end(), ~clLits[i]);
			CPPUNIT_ASSERT_MESSAGE(s.c_str(), it != r.end());
			r.erase(it);
		}
		while (!r.empty() && isSentinel(r.back())) r.pop_back();
		CPPUNIT_ASSERT(r.empty());
	}
	std::string toString(const LitVec& c) {
		std::string res="[";
		for (uint32 i = 0; i != c.size(); ++i) {
			if (c[i].sign()) {
				res += '~';
			}
			res += ('a' + i);
			res += ' ';
		}
		res+="]";
		return res;
	}
	void makeLits(int pos, int neg) {
		clLits.clear();
		int size = pos + neg;
		LitVec lit(size);
		for (int i = 0; i < pos; ++i) {
			lit[i] = posLit(i+1);
			clLits.push_back(lit[i]);
		}
		for (int i = pos; i < pos + neg; ++i) {
			lit[i] = negLit(i+1);
			clLits.push_back(lit[i]);
		}
	}
	void makeRandomClause(int size) {
		int pos = rand() % size + 1;
		makeLits( pos, size - pos );
	}
};
CPPUNIT_TEST_SUITE_REGISTRATION(SharedClauseTest);
} }
clasp-3.2.2/libclasp/tests/solver_test.cpp000066400000000000000000002077751304134206100206440ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 
#include 
#include 
#include 
namespace Clasp { namespace Test {
using namespace Clasp::mt;
struct TestingConstraint : public Constraint {
	TestingConstraint(bool* del = 0, ConstraintType t = Constraint_t::Static)
		: type_(t), propagates(0), undos(0), sat(false), keepWatch(true), setConflict(false), deleted(del) {}
	Constraint* cloneAttach(Solver&) {
		return new TestingConstraint(0, type_);
	}
	PropResult propagate(Solver&, Literal, uint32&) {
		++propagates;
		return PropResult(!setConflict, keepWatch);
	}
	void undoLevel(Solver&) {
		++undos;
	}
	bool simplify(Solver&, bool) { return sat; }
	void reason(Solver&, Literal, LitVec& out) { out = ante; }
	void destroy(Solver* s, bool b) {
		if (deleted) *deleted = true;
		if (s && b) {
			for (Var v = 1; s->validVar(v); ++v) {
				s->removeWatch(posLit(v), this);
				s->removeWatch(negLit(v), this);
			}
			for (uint32 i = 1; i <= s->decisionLevel(); ++i) {
				s->removeUndoWatch(i, this);
			}
		}
		Constraint::destroy(s, b);
	}
	bool locked(const Solver&) const { return false; }
	uint32 isOpen(const Solver&, const TypeSet&, LitVec&) { return 0; }
	static uint32 size() { return uint32(10); }
	ConstraintType type() const { return type_; }
	LitVec ante;
	ConstraintType type_;
	int propagates;
	int undos;
	bool sat;
	bool keepWatch;
	bool setConflict;
	bool* deleted;
};
struct TestingPostProp : public PostPropagator {
	explicit TestingPostProp(bool cfl, uint32 p = PostPropagator::priority_class_simple) : props(0), resets(0), inits(0), prio(p), conflict(cfl), deleteOnProp(false) {}
	bool propagateFixpoint(Solver& s, PostPropagator*) {
		++props;
		bool ok = !conflict;
		if (deleteOnProp) {
			s.removePost(this);
			this->destroy();
		}
		return ok;
	}
	void reset() {
		++resets;
	}
	bool init(Solver&) { ++inits; return true; }
	uint32 priority() const { return prio; }
	int props;
	int resets;
	int inits;
	uint32 prio;
	bool conflict;
	bool deleteOnProp;
};

class SolverTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(SolverTest);
	CPPUNIT_TEST(testReasonStore);
	CPPUNIT_TEST(testSingleOwnerPtr);
	CPPUNIT_TEST(testDefaults);
	CPPUNIT_TEST(testVarNullIsSentinel);
	CPPUNIT_TEST(testSolverAlwaysContainsSentinelVar);
	CPPUNIT_TEST(testSolverOwnsConstraints);
	CPPUNIT_TEST(testAddVar);
	CPPUNIT_TEST(testEliminateVar);
	CPPUNIT_TEST(testCmpScores);

	CPPUNIT_TEST(testValueSet);
	CPPUNIT_TEST(testPreferredLitByType);
	CPPUNIT_TEST(testInitSavedValue);
	CPPUNIT_TEST(testReset);
	CPPUNIT_TEST(testForce);
	CPPUNIT_TEST(testNoUpdateOnConsistentAssign);
	CPPUNIT_TEST(testAssume);
	CPPUNIT_TEST(testGetDecision);
	CPPUNIT_TEST(testAddWatch);
	CPPUNIT_TEST(testRemoveWatch);
	CPPUNIT_TEST(testNotifyWatch);
	CPPUNIT_TEST(testKeepWatchOnPropagate);
	CPPUNIT_TEST(testRemoveWatchOnPropagate);
	CPPUNIT_TEST(testWatchOrder);
	CPPUNIT_TEST(testUndoUntil);
	CPPUNIT_TEST(testUndoWatches);
	CPPUNIT_TEST(testLazyRemoveWatches);
	CPPUNIT_TEST(testPropBinary);
	CPPUNIT_TEST(testPropTernary);
	CPPUNIT_TEST(testRestartAfterUnitLitResolvedBug);
	CPPUNIT_TEST(testEstimateBCP);
	CPPUNIT_TEST(testEstimateBCPLoop);
	CPPUNIT_TEST(testAssertImmediate);
	CPPUNIT_TEST(testPreferShortBfs);

	CPPUNIT_TEST(testPostPropInit);
	CPPUNIT_TEST(testPropagateCallsPostProp);
	CPPUNIT_TEST(testPropagateCallsResetOnConflict);
	CPPUNIT_TEST(testPostpropPriority);
	CPPUNIT_TEST(testPostpropPriorityExt);
	CPPUNIT_TEST(testPostpropRemove);
	CPPUNIT_TEST(testPostpropRemoveOnProp);
	CPPUNIT_TEST(testPostpropBug);
	CPPUNIT_TEST(testPostpropAddAfterInitBug);

	CPPUNIT_TEST(testSimplifyRemovesSatBinClauses);
	CPPUNIT_TEST(testSimplifyRemovesSatTernClauses);
	CPPUNIT_TEST(testSimplifyRemovesSatConstraints);
	CPPUNIT_TEST(testRemoveConditional);
	CPPUNIT_TEST(testStrengthenConditional);
	CPPUNIT_TEST(testLearnConditional);


	CPPUNIT_TEST(testResolveUnary);
	CPPUNIT_TEST(testResolveConflict);
	CPPUNIT_TEST(testResolveConflictBounded);

	CPPUNIT_TEST(testClearAssumptions);
	CPPUNIT_TEST(testStopConflict);
	CPPUNIT_TEST(testClearStopConflictResetsBtLevel);

	CPPUNIT_TEST(testSearchKeepsAssumptions);
	CPPUNIT_TEST(testSearchAddsLearntFacts);
	CPPUNIT_TEST(testSearchMaxConflicts);

	CPPUNIT_TEST(testProblemStats);
	CPPUNIT_TEST(testSolverStats);
	CPPUNIT_TEST(testClaspStats);
#if WITH_THREADS
	CPPUNIT_TEST(testLearntShort);
	CPPUNIT_TEST(testLearntShortAreDistributed);
	CPPUNIT_TEST(testAuxAreNotDistributed);
	CPPUNIT_TEST(testAttachToDB);
	CPPUNIT_TEST(testAttachDeferred);
#endif

	CPPUNIT_TEST(testUnfortunateSplitSeq);
	CPPUNIT_TEST(testSplitInc);
	CPPUNIT_TEST(testSplitFlipped);
	CPPUNIT_TEST(testSplitFlipToNewRoot);
	CPPUNIT_TEST(testSplitImplied);

	CPPUNIT_TEST(testAddShortIncremental);
	CPPUNIT_TEST(testSwitchToMtIncremental);
#if TEST_ONCE
	CPPUNIT_TEST(testScheduleAdvance);
	CPPUNIT_TEST(testLubyAdvance);
#endif

	CPPUNIT_TEST(testPushAux);
	CPPUNIT_TEST(testPushAuxFact);
	CPPUNIT_TEST(testPopAuxRemovesConstraints);
	CPPUNIT_TEST(testPopAuxRemovesConstraintsRegression);
	CPPUNIT_TEST(testPopAuxMaintainsQueue);
	CPPUNIT_TEST(testIncrementalAux);

	CPPUNIT_TEST(testUnfreezeStepBug);
	CPPUNIT_TEST(testRemoveConstraint);

	CPPUNIT_TEST(testPopVars);
	CPPUNIT_TEST(testPopVarsAfterCommit);
	CPPUNIT_TEST(testPopVarsIncremental);
	CPPUNIT_TEST(testPopVarsIncrementalBug);
	CPPUNIT_TEST(testPopVarsMT);
	CPPUNIT_TEST_SUITE_END();
public:
	void setUp() {
	}
	template 
	void testReasonStore() {
		ST store;
		store.resize(1);
		Constraint* x = new TestingConstraint(0, Constraint_t::Conflict);
		store[0] = x;
		store.setData(0, 22);
		CPPUNIT_ASSERT(store[0]      == x);
		CPPUNIT_ASSERT(store.data(0) == 22);
		Literal p(10,0), q(22, 0);
		store[0]   = Antecedent(p, q);
		uint32 old = store.data(0);
		store.setData(0, 74);
		CPPUNIT_ASSERT(store.data(0) == 74);
		store.setData(0, old);
		CPPUNIT_ASSERT(store[0].firstLiteral() == p && store[0].secondLiteral() == q);

		typedef typename ST::value_type ReasonWithData;
		ReasonWithData rwd(x, 169);
		store[0]    = rwd.ante();
		if (rwd.data() != UINT32_MAX) {
			store.setData(0, rwd.data());
		}
		CPPUNIT_ASSERT(store[0] == x);
		CPPUNIT_ASSERT(store.data(0) == 169);

		rwd = ReasonWithData(p, UINT32_MAX);
		store[0] = rwd.ante();
		if (rwd.data() != UINT32_MAX) {
			store.setData(0, rwd.data());
		}
		CPPUNIT_ASSERT(store[0].firstLiteral() == p);
		x->destroy();
	}
	void testReasonStore() {
		if (sizeof(void*) == sizeof(uint32)) {
			testReasonStore();
		}
		testReasonStore();
	}

	void testSingleOwnerPtr() {
		bool conDel1 = false, conDel2 = false;
		TestingConstraint* f = new TestingConstraint(&conDel2);
		{
			SingleOwnerPtr x(new TestingConstraint(&conDel1));
			SingleOwnerPtr y(f);
			y.release();
		}
		CPPUNIT_ASSERT_EQUAL(true, conDel1);
		CPPUNIT_ASSERT_EQUAL(false, conDel2);
		{
			SingleOwnerPtr y(f);
			y = f;
			CPPUNIT_ASSERT_EQUAL(true, y.is_owner());
			y.release();
			CPPUNIT_ASSERT_EQUAL(false, conDel2);
			y = f;
			CPPUNIT_ASSERT_EQUAL(true, !conDel2 && y.is_owner());
		}
		CPPUNIT_ASSERT_EQUAL(true, conDel2);
	}
	void testDefaults() {
		Solver& s = *ctx.master();
		const SolverParams& x = ctx.configuration()->solver(s.id());
		CPPUNIT_ASSERT(x.heuId == 0);
		CPPUNIT_ASSERT(x.ccMinRec == false);
		CPPUNIT_ASSERT(x.ccMinAntes == SolverStrategies::all_antes);
		CPPUNIT_ASSERT(x.search == SolverStrategies::use_learning);
		CPPUNIT_ASSERT(x.compress == 0);
		CPPUNIT_ASSERT(x.initWatches == SolverStrategies::watch_rand);

		CPPUNIT_ASSERT_EQUAL(0u, s.numVars());
		CPPUNIT_ASSERT_EQUAL(0u, s.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(0u, s.numConstraints());
		CPPUNIT_ASSERT_EQUAL(0u, s.numLearntConstraints());
		CPPUNIT_ASSERT_EQUAL(0u, s.decisionLevel());
		CPPUNIT_ASSERT_EQUAL(0u, s.queueSize());
		ctx.setFrozen(0, true);
		CPPUNIT_ASSERT(ctx.stats().vars.frozen == 0);
	}
	void testVarNullIsSentinel() {
		Literal p = lit_true();
		CPPUNIT_ASSERT_EQUAL(true, isSentinel(p));
		CPPUNIT_ASSERT_EQUAL(true, isSentinel(~p));
	}
	void testSolverAlwaysContainsSentinelVar() {
		Solver& s = *ctx.master();
		CPPUNIT_ASSERT_EQUAL(value_true, s.value(sentVar));
		CPPUNIT_ASSERT(s.isTrue(posLit(sentVar)));
		CPPUNIT_ASSERT(s.isFalse(negLit(sentVar)));
		CPPUNIT_ASSERT(s.seen(sentVar) == true);
	}
	void testSolverOwnsConstraints() {
		bool conDel = false;
		bool lconDel = false;
		{
			SharedContext ctx;
			Solver& s = ctx.startAddConstraints();
			ctx.add( new TestingConstraint(&conDel) );
			ctx.endInit();
			s.addLearnt( new TestingConstraint(&lconDel, Constraint_t::Conflict), TestingConstraint::size());
			CPPUNIT_ASSERT_EQUAL(1u, s.numConstraints());
			CPPUNIT_ASSERT_EQUAL(1u, s.numLearntConstraints());
		}
		CPPUNIT_ASSERT_EQUAL(true, conDel);
		CPPUNIT_ASSERT_EQUAL(true, lconDel);
	}

	void testAddVar() {
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Body);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(2u, s.numVars());
		CPPUNIT_ASSERT_EQUAL(0u, s.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(2u, s.numFreeVars());
		CPPUNIT_ASSERT_EQUAL(Var_t::Atom, ctx.varInfo(v1).type());
		CPPUNIT_ASSERT_EQUAL(Var_t::Body, ctx.varInfo(v2).type());

		CPPUNIT_ASSERT_EQUAL( true, ctx.varInfo(v1).preferredSign() );
		CPPUNIT_ASSERT_EQUAL( false, ctx.varInfo(v2).preferredSign() );
	}

	void testEliminateVar() {
		Var v1 = ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Body);
		Solver& s = ctx.startAddConstraints();
		ctx.eliminate(v1);
		CPPUNIT_ASSERT_EQUAL(uint32(2), s.numVars());
		CPPUNIT_ASSERT_EQUAL(uint32(1), ctx.numEliminatedVars());
		CPPUNIT_ASSERT_EQUAL(uint32(1), s.numFreeVars());
		CPPUNIT_ASSERT_EQUAL(uint32(0), s.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, ctx.eliminated(v1));
		// so v1 is ignored by heuristics!
		CPPUNIT_ASSERT(s.value(v1) != value_free);

		// ignore subsequent calls
		ctx.eliminate(v1);
		CPPUNIT_ASSERT_EQUAL(uint32(1), ctx.numEliminatedVars());
		ctx.endInit();
	}

	void testCmpScores() {
		ReduceStrategy rs;
		ConstraintScore a1 = makeScore(100, 5), a2 = makeScore(90, 3);
		CPPUNIT_ASSERT(rs.compare(ReduceStrategy::score_act, a1, a2) > 0);
		CPPUNIT_ASSERT(rs.compare(ReduceStrategy::score_lbd, a1, a2) < 0);
		CPPUNIT_ASSERT(rs.compare(ReduceStrategy::score_both, a1, a2) > 0);

		CPPUNIT_ASSERT(!a1.bumped() && !a2.bumped());
		a1.bumpLbd(4);
		CPPUNIT_ASSERT(rs.compare(ReduceStrategy::score_act, a1, a2) > 0);
		CPPUNIT_ASSERT(rs.compare(ReduceStrategy::score_lbd, a1, a2) < 0);
		CPPUNIT_ASSERT(rs.compare(ReduceStrategy::score_both, a1, a2) > 0);
		CPPUNIT_ASSERT(a1.bumped() && a1.activity() == 100 && a1.lbd() == 4);
		a1.clearBumped();
		CPPUNIT_ASSERT(!a1.bumped() && a1.activity() == 100 && a1.lbd() == 4);

		a1.bumpActivity();
		CPPUNIT_ASSERT(!a1.bumped() && a1.activity() == 101 && a1.lbd() == 4);
		a1.reset(Clasp::ACT_MAX - 1, 2);
		a1.bumpActivity();
		CPPUNIT_ASSERT(!a1.bumped() && a1.activity() == Clasp::ACT_MAX && a1.lbd() == 2);
		a1.bumpActivity();
		CPPUNIT_ASSERT(!a1.bumped() && a1.activity() == Clasp::ACT_MAX && a1.lbd() == 2);
	}

	void testValueSet() {
		ValueSet vs;
		CPPUNIT_ASSERT_EQUAL(vs.empty(), true);
		vs.set(ValueSet::pref_value, value_true);
		CPPUNIT_ASSERT_EQUAL(vs.empty(), false);
		CPPUNIT_ASSERT_EQUAL(vs.has(ValueSet::pref_value), true);
		CPPUNIT_ASSERT_EQUAL(vs.sign(), false);
		vs.set(ValueSet::saved_value, value_false);
		CPPUNIT_ASSERT_EQUAL(vs.has(ValueSet::saved_value), true);
		CPPUNIT_ASSERT_EQUAL(vs.sign(), true);

		vs.set(ValueSet::user_value, value_true);
		CPPUNIT_ASSERT_EQUAL(vs.has(ValueSet::user_value), true);
		CPPUNIT_ASSERT_EQUAL(vs.sign(), false);

		vs.set(ValueSet::user_value, value_free);
		CPPUNIT_ASSERT_EQUAL(vs.has(ValueSet::user_value), false);
		CPPUNIT_ASSERT_EQUAL(vs.sign(), true);
	}
	void testPreferredLitByType() {
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Body);
		Var v3 = ctx.addVar(Var_t::Hybrid);
		Var v4 = ctx.addVar(Var_t::Body, VarInfo::Eq);
		CPPUNIT_ASSERT_EQUAL( true, ctx.varInfo(v1).preferredSign() );
		CPPUNIT_ASSERT_EQUAL( false, ctx.varInfo(v2).preferredSign() );
		CPPUNIT_ASSERT_EQUAL( true, ctx.varInfo(v3).preferredSign() );
		CPPUNIT_ASSERT_EQUAL( false, ctx.varInfo(v4).preferredSign() );
	}

	void testInitSavedValue() {
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Body);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL( value_free, s.pref(v1).get(ValueSet::saved_value) );
		CPPUNIT_ASSERT_EQUAL( value_free, s.pref(v2).get(ValueSet::saved_value) );

		s.setPref(v1, ValueSet::saved_value, value_true);
		s.setPref(v2, ValueSet::saved_value, value_false);

		CPPUNIT_ASSERT_EQUAL( value_true, s.pref(v1).get(ValueSet::saved_value) );
		CPPUNIT_ASSERT_EQUAL( value_false, s.pref(v2).get(ValueSet::saved_value));
	}

	void testReset() {
		ctx.addVar(Var_t::Atom); ctx.addVar(Var_t::Body);
		Solver& s = ctx.startAddConstraints();
		s.add( new TestingConstraint(0) );
		ctx.endInit();
		s.addLearnt( new TestingConstraint(0, Constraint_t::Conflict), TestingConstraint::size());
		s.assume( posLit(1) );
		ctx.reset();
		testDefaults();
		Var n = ctx.addVar(Var_t::Body);
		ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(Var_t::Body, ctx.varInfo(n).type());
	}

	void testForce() {
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(true, s.force(posLit(v1), 0));
		CPPUNIT_ASSERT_EQUAL(true, s.force(negLit(v2), posLit(v1)));
		CPPUNIT_ASSERT_EQUAL(true, s.isTrue(posLit(v1)));
		CPPUNIT_ASSERT_EQUAL(true, s.isTrue(negLit(v2)));
		CPPUNIT_ASSERT(s.reason(negLit(v2)).type() == Antecedent::Binary);

		CPPUNIT_ASSERT_EQUAL(2u, s.queueSize());
	}

	void testNoUpdateOnConsistentAssign() {
		Var v1 = ctx.addVar(Var_t::Atom);
		Var v2 = ctx.addVar(Var_t::Atom);
		Solver& s = ctx.startAddConstraints();
		s.force( posLit(v2), 0 );
		s.force( posLit(v1), 0 );
		uint32 oldA = s.numAssignedVars();
		CPPUNIT_ASSERT_EQUAL(true, s.force( posLit(v1), posLit(v2) ));
		CPPUNIT_ASSERT_EQUAL(oldA, s.numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(2u, s.queueSize());
	}

	void testAssume() {
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		CPPUNIT_ASSERT_EQUAL(true, s.assume(p));
		CPPUNIT_ASSERT_EQUAL(value_true, s.value(p.var()));
		CPPUNIT_ASSERT_EQUAL(1u, s.decisionLevel());
		CPPUNIT_ASSERT_EQUAL(1u, s.queueSize());
	}

	void testGetDecision() {
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Literal q = posLit(ctx.addVar(Var_t::Atom));
		Literal r = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		s.assume(p);
		s.assume(q);
		s.assume(~r);
		CPPUNIT_ASSERT_EQUAL(p, s.decision(1));
		CPPUNIT_ASSERT_EQUAL(q, s.decision(2));
		CPPUNIT_ASSERT_EQUAL(~r, s.decision(3));
		CPPUNIT_ASSERT_EQUAL(~r, s.decision(s.decisionLevel()));
	}
	void testAddWatch() {
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		TestingConstraint c;
		CPPUNIT_ASSERT_EQUAL(false, s.hasWatch(p, &c));
		s.addWatch(p, &c);
		CPPUNIT_ASSERT_EQUAL(true, s.hasWatch(p, &c));
		CPPUNIT_ASSERT_EQUAL(1u, s.numWatches(p));
	}

	void testRemoveWatch() {
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		TestingConstraint c;
		s.addWatch(p, &c);
		s.removeWatch(p, &c);
		CPPUNIT_ASSERT_EQUAL(false, s.hasWatch(p, &c));
	}

	void testNotifyWatch() {
		Literal p = posLit(ctx.addVar(Var_t::Atom)), q = posLit(ctx.addVar(Var_t::Atom));
		TestingConstraint c;
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		s.addWatch(p, &c);
		s.addWatch(q, &c);
		s.assume(p);
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(1, c.propagates);
		s.assume(~q);
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(1, c.propagates);
	}

	void testKeepWatchOnPropagate() {
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		TestingConstraint c;
		s.addWatch(p, &c);
		s.assume(p);
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(true, s.hasWatch(p, &c));
	}

	void testRemoveWatchOnPropagate() {
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		TestingConstraint c;
		c.keepWatch = false;
		s.addWatch(p, &c);
		s.assume(p);
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(false, s.hasWatch(p, &c));
	}

	void testWatchOrder() {
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		TestingConstraint c1, c2, c3;
		c1.keepWatch = false;
		c2.setConflict = true;
		s.addWatch(p, &c1);
		s.addWatch(p, &c2);
		s.addWatch(p, &c3);
		s.assume(p);
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
		CPPUNIT_ASSERT_EQUAL(false, s.hasWatch(p, &c1));
		CPPUNIT_ASSERT_EQUAL(true, s.hasWatch(p, &c2));
		CPPUNIT_ASSERT_EQUAL(true, s.hasWatch(p, &c3));
		CPPUNIT_ASSERT_EQUAL(1, c1.propagates);
		CPPUNIT_ASSERT_EQUAL(1, c2.propagates);
		CPPUNIT_ASSERT_EQUAL(0, c3.propagates);
	}

	void testUndoUntil() {
		Literal a = posLit(ctx.addVar(Var_t::Atom)), b = posLit(ctx.addVar(Var_t::Atom))
			, c = posLit(ctx.addVar(Var_t::Atom)), d = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		s.assume(a);
		s.force(~b, a);
		s.force(~c, a);
		s.force(d, a);
		CPPUNIT_ASSERT_EQUAL(4u, s.queueSize());
		CPPUNIT_ASSERT_EQUAL(4u, s.numAssignedVars());
		s.undoUntil(0u);
		CPPUNIT_ASSERT_EQUAL(0u, s.numAssignedVars());
		for (Var i = a.var(); i != d.var()+1; ++i) {
			CPPUNIT_ASSERT_EQUAL(value_free, s.value(i));
		}
	}

	void testUndoWatches() {
		Literal a = posLit(ctx.addVar(Var_t::Atom)), b = posLit(ctx.addVar(Var_t::Atom));
		TestingConstraint c;
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		s.assume(a);
		s.addUndoWatch(1, &c);
		s.assume(b);
		s.undoUntil(1);
		CPPUNIT_ASSERT_EQUAL(0, c.undos);
		s.undoUntil(0);
		CPPUNIT_ASSERT_EQUAL(1, c.undos);
	}
	void testLazyRemoveWatches() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		uint32  x = s.numWatches(a);
		Solver::ConstraintDB db;
		for (uint32 i = 0; i != 10; ++i) {
			db.push_back(new TestingConstraint);
			s.addWatch(a, db[i]);
		}
		ctx.endInit();
		s.assume(a);
		for (uint32 i = 0; i != 10; ++i) {
			s.addUndoWatch(1, db[i]);
		}
		s.destroyDB(db);
		s.undoUntil(0);
		CPPUNIT_ASSERT(s.numWatches(a) == x);
	}

	void testPropBinary() {
		LitVec bin = addBinary();
		Solver& s  = *ctx.master();
		for (int i = 0; i < 2; ++i) {
			s.assume(~bin[i]);
			CPPUNIT_ASSERT(s.propagate());
			int o = (i+1)%2;
			CPPUNIT_ASSERT_EQUAL(true, s.isTrue(bin[o]));
			CPPUNIT_ASSERT_EQUAL(Antecedent::Binary, s.reason(bin[o]).type());
			LitVec r;
			s.reason(bin[o], r);
			CPPUNIT_ASSERT_EQUAL(1u, (uint32)r.size());
			CPPUNIT_ASSERT(~bin[i] == r[0]);
			s.undoUntil(0);
		}
		s.assume(~bin[0]);
		s.force(~bin[1], 0);
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
		const LitVec& r = s.conflict();
		CPPUNIT_ASSERT_EQUAL(2u, (uint32)r.size());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~bin[0]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~bin[1]) != r.end());
	}

	void testPropTernary() {
		LitVec tern = addTernary();
		Solver& s   = *ctx.master();
		for (int i = 0; i < 3; ++i) {
			s.assume(~tern[i]);
			s.assume(~tern[(i+1)%3]);
			CPPUNIT_ASSERT(s.propagate());
			int o = (i+2)%3;
			CPPUNIT_ASSERT_EQUAL(true, s.isTrue(tern[o]));
			CPPUNIT_ASSERT_EQUAL(Antecedent::Ternary, s.reason(tern[o]).type());
			LitVec r;
			s.reason(tern[o], r);
			CPPUNIT_ASSERT_EQUAL(2u, (uint32)r.size());
			CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~tern[i]) != r.end());
			CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~tern[(i+1)%3]) != r.end());
			s.undoUntil(0);
		}
		s.assume(~tern[0]);
		s.force(~tern[1], 0);
		s.force(~tern[2], 0);
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
		const LitVec& r = s.conflict();
		CPPUNIT_ASSERT_EQUAL(3u, (uint32)r.size());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~tern[0]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~tern[1]) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~tern[2]) != r.end());
	}

	void testRestartAfterUnitLitResolvedBug() {
		LitVec bin = addBinary();
		Solver& s  = *ctx.master();
		s.force(~bin[0], 0);
		s.undoUntil(0);
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(true, s.isTrue(~bin[0]));
		CPPUNIT_ASSERT_EQUAL(true, s.isTrue(bin[1]));
	}

	void testEstimateBCP() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Literal d = posLit(ctx.addVar(Var_t::Atom));
		Literal e = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(a, b);
		ctx.addBinary(~b, c);
		ctx.addBinary(~c, d);
		ctx.addBinary(~d, e);
		ctx.endInit();
		for (int i = 0; i < 4; ++i) {
			uint32 est = s.estimateBCP(~a, i);
			CPPUNIT_ASSERT_EQUAL(uint32(i + 2), est);
		}
	}

	void testEstimateBCPLoop() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(a, b);
		ctx.addBinary(~b, c);
		ctx.addBinary(~c, ~a);
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(uint32(3), s.estimateBCP(~a, -1));
	}

	void testAssertImmediate() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal d = posLit(ctx.addVar(Var_t::Atom));
		Literal q = posLit(ctx.addVar(Var_t::Atom));
		Literal f = posLit(ctx.addVar(Var_t::Atom));
		Literal x = posLit(ctx.addVar(Var_t::Atom));
		Literal z = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();

		ClauseCreator cl(&s);
		cl.addDefaultFlags(ClauseCreator::clause_watch_first);
		cl.start().add(~z).add(d).end();
		cl.start().add(a).add(b).end();
		cl.start().add(a).add(~b).add(z).end();
		cl.start().add(a).add(~b).add(~z).add(d).end();
		cl.start().add(~b).add(~z).add(~d).add(q).end();
		cl.start().add(~q).add(f).end();
		cl.start().add(~f).add(~z).add(x).end();
		s.assume( ~a );
		CPPUNIT_ASSERT_EQUAL( true, s.propagate() );

		CPPUNIT_ASSERT_EQUAL( 7u, s.numAssignedVars());

		Antecedent whyB = s.reason(b);
		Antecedent whyZ = s.reason(z);
		Antecedent whyD = s.reason(d);
		Antecedent whyQ = s.reason(q);
		Antecedent whyF = s.reason(f);
		Antecedent whyX = s.reason(x);

		CPPUNIT_ASSERT(whyB.type() == Antecedent::Binary && whyB.firstLiteral() == ~a);
		CPPUNIT_ASSERT(whyZ.type() == Antecedent::Ternary && whyZ.firstLiteral() == ~a && whyZ.secondLiteral() == b);
		CPPUNIT_ASSERT(whyD.type() == Antecedent::Generic);
		CPPUNIT_ASSERT(whyQ.type() == Antecedent::Generic);

		CPPUNIT_ASSERT(whyF.type() == Antecedent::Binary && whyF.firstLiteral() == q);
		CPPUNIT_ASSERT(whyX.type() == Antecedent::Ternary && whyX.firstLiteral() == f && whyX.secondLiteral() == z);
	}

	void testPreferShortBfs() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal p = posLit(ctx.addVar(Var_t::Atom));
		Literal q = posLit(ctx.addVar(Var_t::Atom));
		Literal x = posLit(ctx.addVar(Var_t::Atom));
		Literal y = posLit(ctx.addVar(Var_t::Atom));
		Literal z = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ClauseCreator cl(&s);
		cl.addDefaultFlags(ClauseCreator::clause_watch_least);
		cl.start().add(a).add(x).add(y).add(p).end();   // c1
		cl.start().add(a).add(x).add(y).add(z).end();   // c2
		cl.start().add(a).add(p).end();                 // c3
		cl.start().add(a).add(~p).add(z).end();         // c4
		cl.start().add(~z).add(b).end();                // c5
		cl.start().add(a).add(x).add(q).add(~b).end();  // c6
		cl.start().add(a).add(~b).add(~p).add(~q).end();// c7

		CPPUNIT_ASSERT_EQUAL(7u, s.numConstraints());
		CPPUNIT_ASSERT_EQUAL(2u, ctx.numBinary());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numTernary());

		s.assume( ~x );
		s.propagate();
		s.assume( ~y );
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(2u, s.numAssignedVars());
		s.assume( ~a );

		CPPUNIT_ASSERT_EQUAL(false, s.propagate());

		CPPUNIT_ASSERT_EQUAL( 7u, s.numAssignedVars());

		CPPUNIT_ASSERT( s.reason(b).type() == Antecedent::Binary );
		CPPUNIT_ASSERT( s.reason(p).type() == Antecedent::Binary );
		CPPUNIT_ASSERT( s.reason(z).type() == Antecedent::Ternary );
		CPPUNIT_ASSERT( s.reason(q).type() == Antecedent::Generic );
	}
	void testPostPropInit() {
		TestingPostProp* p = new TestingPostProp(false);
		Solver& s = ctx.startAddConstraints();
		s.addPost(p);
		CPPUNIT_ASSERT_EQUAL(0, p->inits); // init is called *after* setup
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(1, p->inits);
		ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(2, p->inits);
	}
	void testPropagateCallsPostProp() {
		TestingPostProp* p = new TestingPostProp(false);
		Solver& s = ctx.startAddConstraints();
		s.addPost(p);
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(0, p->props); // not yet enabled
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(1, p->props);
		CPPUNIT_ASSERT_EQUAL(0, p->resets);
	}
	void testPropagateCallsResetOnConflict() {
		TestingPostProp* p = new TestingPostProp(true);
		Solver& s = ctx.startAddConstraints();
		s.addPost(p);
		ctx.endInit();
		CPPUNIT_ASSERT_EQUAL(1, p->props);
		CPPUNIT_ASSERT_EQUAL(1, p->resets);
	}

	void testPostpropPriority() {
		TestingPostProp* p1 = new TestingPostProp(false);
		p1->prio += 10;
		TestingPostProp* p2 = new TestingPostProp(false);
		p2->prio += 30;
		TestingPostProp* p3 = new TestingPostProp(false);
		p3->prio += 20;
		Solver& s = ctx.startAddConstraints();
		s.addPost(p2);
		s.addPost(p1);
		s.addPost(p3);
		CPPUNIT_ASSERT(p1->next == p3 && p3->next == p2);
	}

	void testPostpropPriorityExt() {
		TestingPostProp* p1 = new TestingPostProp(false);
		TestingPostProp* p2 = new TestingPostProp(false);
		TestingPostProp* p3 = new TestingPostProp(false);
		TestingPostProp* p4 = new TestingPostProp(false);
		p1->prio = 10;
		p2->prio = 20;
		p3->prio = PostPropagator::priority_class_general;
		p4->prio = PostPropagator::priority_class_general;
		Solver& s = ctx.startAddConstraints();
		s.addPost(p3);
		s.addPost(p2);
		CPPUNIT_ASSERT(s.getPost(PostPropagator::priority_class_general));
		CPPUNIT_ASSERT(s.getPost(20));
		CPPUNIT_ASSERT(p2->next == p3);
		s.addPost(p4);
		CPPUNIT_ASSERT(p2->next == p3);
		CPPUNIT_ASSERT(p3->next == p4);
		ctx.endInit();
		CPPUNIT_ASSERT(p3->inits == 1);
		p3->props = 0;
		p2->props = 0;
		p4->props = 0;
		s.removePost(p2);
		s.removePost(p3);
		s.addPost(p3);
		s.propagate();
		CPPUNIT_ASSERT(p3->props == 1 && p4->props == 1);
		s.addPost(p1);
		CPPUNIT_ASSERT(p1->next == p4);
		s.addPost(p2);
		CPPUNIT_ASSERT(p1->next == p2 && p2->next == p4);
		s.removePost(p3);
		s.removePost(p4);
		s.propagate();
		CPPUNIT_ASSERT(p3->props == 1 && p4->props == 1 && p1->props == 1 && p2->props == 1);
		s.addPost(p3);
		s.addPost(p4);
		p3->conflict = true;
		s.propagate();
		CPPUNIT_ASSERT(p3->props == 2 && p1->props == 2 && p2->props == 2 && p4->props == 1);
	}

	void testPostpropRemove() {
		SingleOwnerPtr p1(new TestingPostProp(false, 1));
		SingleOwnerPtr p2(new TestingPostProp(false, 2));
		SingleOwnerPtr p3(new TestingPostProp(false, 3));
		Solver& s = ctx.startAddConstraints();
		s.addPost(p1.release());
		s.addPost(p2.release());
		s.addPost(p3.release());
		CPPUNIT_ASSERT(p1->next == p2.get() && p2->next == p3.get());
		s.removePost(p2.acquire());
		CPPUNIT_ASSERT(p1->next == p3.get() && p3->next == 0 && p2->next == 0);
		s.removePost(p2.acquire());
		s.removePost(p3.acquire());
		CPPUNIT_ASSERT(p1->next == 0);
		ctx.endInit();
		CPPUNIT_ASSERT(p1->props == 1);
	}

	void testPostpropRemoveOnProp() {
		TestingPostProp* p1 = new TestingPostProp(false);
		TestingPostProp* p2 = new TestingPostProp(false);
		TestingPostProp* p3 = new TestingPostProp(false);
		Solver& s = ctx.startAddConstraints();
		s.addPost(p1);
		s.addPost(p2);
		s.addPost(p3);
		ctx.endInit();
		p2->deleteOnProp = true;
		s.propagate();
		CPPUNIT_ASSERT(p1->props == 2 && p3->props == 2);
	}

	void testPostpropBug() {
		Solver& s = ctx.startAddConstraints();
		SingleOwnerPtr p1(new TestingPostProp(false));
		s.addPost(p1.release());
		ctx.endInit();
		// later
		ctx.startAddConstraints();
		s.removePost(p1.get());
		p1.acquire();
		ctx.endInit();
		s.removePost(p1.get());
		CPPUNIT_ASSERT(p1->inits == 1);
	}

	void testPostpropAddAfterInitBug() {
		Solver& s = ctx.startAddConstraints();
		SingleOwnerPtr p1(new TestingPostProp(false));
		ctx.endInit();
		s.addPost(p1.release());
		CPPUNIT_ASSERT(p1->inits == 1);
		s.propagate();
		CPPUNIT_ASSERT(p1->props == 1);
	}

	void testSimplifyRemovesSatBinClauses() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Literal d = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(a, b);
		ctx.addBinary(a, c);
		ctx.addBinary(~a, d);
		s.force(a, 0);
		s.simplify();
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numBinary());
	}

	void testSimplifyRemovesSatTernClauses() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Literal d = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.addTernary(a, b, d);
		ctx.addTernary(~a, b, c);
		s.force(a, 0);
		s.simplify();
		s.assume(~b);
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numTernary());

		// simplify transformed the tern-clause ~a b c to the bin clause b c
		// because ~a is false on level 0
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numBinary());
		s.propagate();
		CPPUNIT_ASSERT_EQUAL(true, s.isTrue(c));
	}

	void testSimplifyRemovesSatConstraints() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		TestingConstraint* t1;
		TestingConstraint* t2;
		TestingConstraint* t3;
		TestingConstraint* t4;
		bool t2Del = false, t3Del = false;
		s.add( t1 = new TestingConstraint );
		s.add( t2 = new TestingConstraint(&t2Del) );
		ctx.endInit();
		s.addLearnt( t3 = new TestingConstraint(&t3Del, Constraint_t::Conflict), TestingConstraint::size() );
		s.addLearnt( t4 = new TestingConstraint(0, Constraint_t::Conflict), TestingConstraint::size() );
		t1->sat = false;
		t2->sat = true;
		t3->sat = true;
		t4->sat = false;
		CPPUNIT_ASSERT_EQUAL(2u, s.numLearntConstraints());
		CPPUNIT_ASSERT_EQUAL(2u, s.numLearntConstraints());
		s.force( a, 0 );
		s.simplify();
		CPPUNIT_ASSERT_EQUAL(1u, s.numLearntConstraints());
		CPPUNIT_ASSERT_EQUAL(1u, s.numLearntConstraints());
		CPPUNIT_ASSERT_EQUAL(true, t2Del);
		CPPUNIT_ASSERT_EQUAL(true, t3Del);
	}

	void testRemoveConditional() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Literal tag = posLit(s.pushTagVar(false));
		ClauseCreator cc(&s);
		cc.start(Constraint_t::Conflict).add(posLit(a)).add(posLit(b)).add(posLit(c)).add(~tag).end();
		CPPUNIT_ASSERT(s.numLearntConstraints() == 1);
		s.removeConditional();
		CPPUNIT_ASSERT(s.numLearntConstraints() == 0);
	}

	void testStrengthenConditional() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		ClauseCreator cc(&s);
		Literal tag = posLit(s.pushTagVar(false));
		cc.start(Constraint_t::Conflict).add(posLit(a)).add(posLit(b)).add(posLit(c)).add(~tag).end();
		CPPUNIT_ASSERT(s.numLearntConstraints() == 1);
		s.strengthenConditional();
		CPPUNIT_ASSERT(ctx.numLearntShort() == 1 || ctx.numTernary() == 1);
	}

	void testLearnConditional() {
		Var b = ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Literal tag = posLit(s.pushTagVar(true));
		s.assume(posLit(b));
		s.propagate();
		TestingConstraint* cfl = new TestingConstraint;
		cfl->ante.push_back(tag);
		cfl->ante.push_back(posLit(b));
		s.force(lit_false(), cfl);
		cfl->destroy(&s, true);
		s.resolveConflict();
		CPPUNIT_ASSERT(ctx.numLearntShort() == 0 && ctx.numBinary() == 0);
		CPPUNIT_ASSERT(s.numLearntConstraints() == 1 && s.decisionLevel() == 1);
		s.strengthenConditional();
		s.clearAssumptions();
		CPPUNIT_ASSERT(s.isTrue(negLit(b)));
	}

	void testResolveUnary() {
		ctx.enableStats(1);
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(posLit(a), posLit(b));
		ctx.addBinary(negLit(b), posLit(c));
		ctx.addBinary(negLit(a), posLit(c));
		s.assume( negLit(c) );
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.resolveConflict());
		CPPUNIT_ASSERT_EQUAL(false, s.hasConflict());
		CPPUNIT_ASSERT_EQUAL(true, s.isTrue(posLit(c)));
		CPPUNIT_ASSERT_EQUAL(0u, s.decisionLevel());
		CPPUNIT_ASSERT(s.stats.extra->learnts[Constraint_t::Conflict-1] == 1);
	}

	void testResolveConflict() {
		Literal x1 = posLit(ctx.addVar( Var_t::Atom )); Literal x2 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x3 = posLit(ctx.addVar( Var_t::Atom )); Literal x4 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x5 = posLit(ctx.addVar( Var_t::Atom )); Literal x6 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x7 = posLit(ctx.addVar( Var_t::Atom )); Literal x8 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x9 = posLit(ctx.addVar( Var_t::Atom )); Literal x10 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x11 = posLit(ctx.addVar( Var_t::Atom )); Literal x12 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x13 = posLit(ctx.addVar( Var_t::Atom )); Literal x14 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x15 = posLit(ctx.addVar( Var_t::Atom )); Literal x16 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x17 = posLit(ctx.addVar( Var_t::Atom ));
		Solver& s   = ctx.startAddConstraints();
		ClauseCreator cl(&s);
		cl.start().add(~x11).add(x12).end();
		cl.start().add(x1).add(~x12).add(~x13).end();
		cl.start().add(~x4).add(~x12).add(x14).end();
		cl.start().add(x13).add(~x14).add(~x15).end();
		cl.start().add(~x2).add(x15).add(x16).end();
		cl.start().add(x3).add(x15).add(~x17).end();
		cl.start().add(~x6).add(~x16).add(x17).end();
		cl.start().add(~x2).add(x9).add(x10).end();
		cl.start().add(~x4).add(~x7).add(~x8).end();
		cl.start().add(x5).add(x6).end();
		CPPUNIT_ASSERT_EQUAL(true, ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(0u, s.queueSize());

		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x1) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(x2) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x3) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(x4) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x5) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(x7) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x9) && s.propagate());

		CPPUNIT_ASSERT_EQUAL(false, s.assume(x11) && s.propagate());

		CPPUNIT_ASSERT_EQUAL(true, s.resolveConflict());
		CPPUNIT_ASSERT_EQUAL(s.trail().back(), x15); // UIP
		CPPUNIT_ASSERT_EQUAL(5u, s.decisionLevel());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Generic, s.reason(s.trail().back()).type());

		LitVec cflClause;
		s.reason(s.trail().back(), cflClause);
		cflClause.push_back(s.trail().back());
		CPPUNIT_ASSERT(LitVec::size_type(4) == cflClause.size());
		CPPUNIT_ASSERT(std::find(cflClause.begin(), cflClause.end(), x2) != cflClause.end());
		CPPUNIT_ASSERT(std::find(cflClause.begin(), cflClause.end(), ~x3) != cflClause.end());
		CPPUNIT_ASSERT(std::find(cflClause.begin(), cflClause.end(), x6) != cflClause.end());
		CPPUNIT_ASSERT(std::find(cflClause.begin(), cflClause.end(), x15) != cflClause.end());
	}

	void testResolveConflictBounded() {
		Literal x1 = posLit(ctx.addVar( Var_t::Atom )); Literal x2 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x3 = posLit(ctx.addVar( Var_t::Atom )); Literal x4 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x5 = posLit(ctx.addVar( Var_t::Atom )); Literal x6 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x7 = posLit(ctx.addVar( Var_t::Atom )); Literal x8 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x9 = posLit(ctx.addVar( Var_t::Atom )); Literal x10 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x11 = posLit(ctx.addVar( Var_t::Atom )); Literal x12 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x13 = posLit(ctx.addVar( Var_t::Atom )); Literal x14 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x15 = posLit(ctx.addVar( Var_t::Atom )); Literal x16 = posLit(ctx.addVar( Var_t::Atom ));
		Literal x17 = posLit(ctx.addVar( Var_t::Atom )); Literal x18 = posLit(ctx.addVar( Var_t::Atom ));
		Solver& s = ctx.startAddConstraints();
		ClauseCreator cl(&s);
		cl.start().add(~x11).add(x12).end();
		cl.start().add(x1).add(~x12).add(~x13).end();
		cl.start().add(~x4).add(~x12).add(x14).end();
		cl.start().add(x13).add(~x14).add(~x15).end();
		cl.start().add(~x2).add(x15).add(x16).end();
		cl.start().add(x3).add(x15).add(~x17).end();
		cl.start().add(~x6).add(~x16).add(x17).end();
		cl.start().add(~x2).add(x9).add(x10).end();
		cl.start().add(~x4).add(~x7).add(~x8).end();
		cl.start().add(x5).add(x6).end();
		CPPUNIT_ASSERT_EQUAL(true, ctx.endInit());
		CPPUNIT_ASSERT_EQUAL(0u, s.queueSize());

		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x1) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(x2) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x3) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(x4) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x5) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.assume(x7) && s.propagate());

		// force backtrack-level to 6
		CPPUNIT_ASSERT_EQUAL(true, s.assume(x18) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.backtrack());

		CPPUNIT_ASSERT_EQUAL(true, s.assume(~x9) && s.propagate());
		CPPUNIT_ASSERT_EQUAL(false, s.assume(x11) && s.propagate());

		CPPUNIT_ASSERT_EQUAL(true, s.resolveConflict());
		CPPUNIT_ASSERT_EQUAL(s.trail().back(), x15); // UIP
		CPPUNIT_ASSERT_EQUAL(6u, s.decisionLevel());  // Jump was bounded!
		Antecedent ante = s.reason(s.trail().back());
		CPPUNIT_ASSERT_EQUAL(Antecedent::Generic, ante.type());
		ClauseHead* cflClause = (ClauseHead*)ante.constraint();
		LitVec r;
		cflClause->reason(s, s.trail().back(), r);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), x2) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~x3) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), x6) != r.end());

		CPPUNIT_ASSERT_EQUAL(true, s.hasWatch(x6, cflClause));

		CPPUNIT_ASSERT_EQUAL(true, s.backtrack());
		CPPUNIT_ASSERT_EQUAL(true, s.isTrue(x15));  // still true, because logically implied on level 5
		CPPUNIT_ASSERT_EQUAL(true, s.backtrack());
		CPPUNIT_ASSERT_EQUAL(value_free, s.value(x15.var()));
	}

	void testSearchKeepsAssumptions() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		Var d = ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ClauseCreator cl(&s);
		ctx.addBinary(posLit(a), posLit(b));
		ctx.addBinary(negLit(b), posLit(c));
		ctx.addBinary(negLit(a), posLit(c));
		ctx.addBinary(negLit(c), negLit(d));
		ctx.endInit();
		s.simplify();
		s.assume( posLit(d) );
		s.pushRootLevel();
		CPPUNIT_ASSERT_EQUAL(value_false, s.search(-1, -1, 0));
		CPPUNIT_ASSERT_EQUAL(1u, s.decisionLevel());
	}
	void testSearchAddsLearntFacts() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		Var d = ctx.addVar( Var_t::Atom );
		struct Dummy : public DecisionHeuristic {
			Dummy(Literal first, Literal second) {lit_[0] = first; lit_[1] = second;}
			void updateVar(const Solver&, Var, uint32) {}
			Literal doSelect(Solver& s) {
				for (uint32 i = 0; i < 2; ++i) {
					if (s.value(lit_[i].var()) == value_free) {
						return lit_[i];
					}
				}
				return Literal();
			}
			Literal lit_[2];
		}h(negLit(c),negLit(a));
		ctx.master()->setHeuristic(&h, Ownership_t::Retain);
		Solver& s = ctx.startAddConstraints();
		ClauseCreator cl(&s);
		ctx.addBinary(posLit(a), posLit(b));
		ctx.addBinary(negLit(b), posLit(c));
		ctx.addBinary(negLit(a), posLit(c));
		ctx.endInit();
		s.assume( posLit(d) );
		s.pushRootLevel();
		CPPUNIT_ASSERT_EQUAL(value_true, s.search(-1, -1, 0));
		s.clearAssumptions();
		CPPUNIT_ASSERT_EQUAL(0u, s.decisionLevel());
		CPPUNIT_ASSERT(s.isTrue(posLit(c)));
	}

	void testSearchMaxConflicts() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(posLit(a), negLit(b));
		ctx.addBinary(negLit(a), posLit(b));
		ctx.addBinary(negLit(a), negLit(b));
		ctx.endInit();
		s.simplify();
		s.assume(posLit(c));
		s.pushRootLevel();
		s.assume(posLit(a));
		CPPUNIT_ASSERT_EQUAL(value_free, s.search(1, -1, 0));
		CPPUNIT_ASSERT_EQUAL(1u, s.decisionLevel());
	}

	void testClearAssumptions() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(negLit(a), negLit(b));
		ctx.addBinary(negLit(a), posLit(b));
		ctx.endInit();
		s.assume(posLit(a));
		s.pushRootLevel();
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
		CPPUNIT_ASSERT_EQUAL(true, s.clearAssumptions());
		CPPUNIT_ASSERT_EQUAL(0u, s.decisionLevel());

		s.force(posLit(a), 0);
		CPPUNIT_ASSERT_EQUAL(false, s.propagate());
		CPPUNIT_ASSERT_EQUAL(false, s.clearAssumptions());
	}

	void testStopConflict() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		Var d = ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(negLit(a), negLit(b));
		ctx.addBinary(negLit(a), posLit(b));
		ctx.endInit();
		s.assume(posLit(a)) && !s.propagate() && s.resolveConflict();
		CPPUNIT_ASSERT(s.decisionLevel() == 0 && s.queueSize() == 1 && !s.hasConflict());
		s.setStopConflict();
		CPPUNIT_ASSERT(s.hasConflict() && !s.resolveConflict());
		s.clearStopConflict();
		CPPUNIT_ASSERT(s.decisionLevel() == 0 && s.queueSize() == 1 && !s.hasConflict());
		s.propagate();
		s.assume(posLit(c)) && s.propagate();
		s.pushRootLevel(1);
		CPPUNIT_ASSERT(s.rootLevel() == 1);
		s.assume(posLit(d));
		s.setStopConflict();
		CPPUNIT_ASSERT(s.rootLevel() == 2);
		s.clearStopConflict();
		CPPUNIT_ASSERT(s.rootLevel() == 1 && s.queueSize() == 1);
	}

	void testClearStopConflictResetsBtLevel() {
		Var a = ctx.addVar( Var_t::Atom );
		Var b = ctx.addVar( Var_t::Atom );
		Var c = ctx.addVar( Var_t::Atom );
		Var d = ctx.addVar( Var_t::Atom );
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(negLit(c), posLit(d));
		ctx.endInit();
		s.assume(posLit(a)) && s.propagate();
		s.assume(posLit(b)) && s.propagate();
		s.assume(posLit(c)) && s.propagate();
		CPPUNIT_ASSERT(s.numFreeVars() == 0);
		s.setBacktrackLevel(s.decisionLevel());
		s.backtrack();
		uint32 bt = s.backtrackLevel();
		s.assume(posLit(d)) && s.propagate();
		CPPUNIT_ASSERT(bt != s.decisionLevel());
		s.setStopConflict();
		CPPUNIT_ASSERT(s.backtrackLevel() == s.decisionLevel());
		s.clearStopConflict();
		CPPUNIT_ASSERT(s.backtrackLevel() == bt);
	}

	void testProblemStats() {
		ProblemStats p1, p2;
		CPPUNIT_ASSERT_EQUAL(uint32(0), p1.vars.num);
		CPPUNIT_ASSERT_EQUAL(uint32(0), p2.vars.eliminated);
		CPPUNIT_ASSERT_EQUAL(uint32(0), p1.constraints.other);
		CPPUNIT_ASSERT_EQUAL(uint32(0), p2.constraints.binary);
		CPPUNIT_ASSERT_EQUAL(uint32(0), p2.constraints.ternary);

		p1.vars.num           = 100; p2.vars.num           = 150;
		p1.vars.eliminated    =  20; p2.vars.eliminated    =  30;
		p1.constraints.other  = 150; p2.constraints.other  = 150;
		p1.constraints.binary =   0; p2.constraints.binary = 100;
		p1.constraints.ternary= 100; p2.constraints.ternary=   0;
		p1.diff(p2);

		CPPUNIT_ASSERT_EQUAL(uint32(50), p1.vars.num);
		CPPUNIT_ASSERT_EQUAL(uint32(10), p1.vars.eliminated);
		CPPUNIT_ASSERT_EQUAL(uint32(0),  p1.constraints.other);
		CPPUNIT_ASSERT_EQUAL(uint32(100),p1.constraints.binary);
		CPPUNIT_ASSERT_EQUAL(uint32(100),p1.constraints.ternary);

		StatisticObject s = StatisticObject::map(&p1);
		CPPUNIT_ASSERT(s.size() == p1.size());
		CPPUNIT_ASSERT(s.at("vars").value() == double(p1.vars.num));
		CPPUNIT_ASSERT_EQUAL(s.at("constraints").value(), (double)p1.constraints.other);
		CPPUNIT_ASSERT_EQUAL(s.at("constraints_binary").value(), (double)p1.constraints.binary);
		CPPUNIT_ASSERT_EQUAL(s.at("constraints_ternary").value(), (double)p1.constraints.ternary);
	}

	void testSolverStats() {
		SolverStats st, st2;
		st.enableExtended();
		st2.enableExtended();

		st.conflicts = 12; st2.conflicts = 3;
		st.choices = 100; st2.choices = 99;
		st.restarts = 7;  st2.restarts = 8;

		st.extra->models = 10; st2.extra->models = 2;
		st.extra->learnts[0] = 6;  st2.extra->learnts[0] = 4;
		st.extra->learnts[1] = 5;  st2.extra->learnts[1] = 4;
		st.extra->lits[0] = 15; st2.extra->lits[0] = 14;
		st.extra->lits[1] = 5;  st2.extra->lits[1] = 4;
		st.extra->binary = 6;  st2.extra->ternary = 5;
		st.extra->deleted = 10;

		st.accu(st2);

		CPPUNIT_ASSERT_EQUAL(uint64(15), st.conflicts);
		CPPUNIT_ASSERT_EQUAL(uint64(199), st.choices);
		CPPUNIT_ASSERT_EQUAL(uint64(15), st.restarts);
		CPPUNIT_ASSERT_EQUAL(uint64(12), st.extra->models);
		CPPUNIT_ASSERT_EQUAL(uint64(29), st.extra->lits[0]);
		CPPUNIT_ASSERT_EQUAL(uint64(9), st.extra->lits[1]);
		CPPUNIT_ASSERT_EQUAL(uint64(10), st.extra->learnts[0]);
		CPPUNIT_ASSERT_EQUAL(uint64(9), st.extra->learnts[1]);
		CPPUNIT_ASSERT_EQUAL(uint32(6), st.extra->binary);
		CPPUNIT_ASSERT_EQUAL(uint32(5), st.extra->ternary);
		CPPUNIT_ASSERT_EQUAL(uint64(10), st.extra->deleted);

		StatisticObject s = StatisticObject::map(&st);
		CPPUNIT_ASSERT_EQUAL(double(15) , s.at("conflicts").value());
		CPPUNIT_ASSERT_EQUAL(double(199), s.at("choices").value());
		CPPUNIT_ASSERT_EQUAL(double(15) , s.at("restarts").value());
		StatisticObject e = s.at("extra");
		CPPUNIT_ASSERT_EQUAL(double(12), e.at("models").value());
		CPPUNIT_ASSERT_EQUAL(double(29), e.at("lits_conflict").value());
		CPPUNIT_ASSERT_EQUAL(double(9) , e.at("lemmas_loop").value());
		CPPUNIT_ASSERT_EQUAL(double(6) , e.at("lemmas_binary").value());
		CPPUNIT_ASSERT_EQUAL(double(5) , e.at("lemmas_ternary").value());
		CPPUNIT_ASSERT_EQUAL(double(10), e.at("lemmas_deleted").value());
	}
	void testClaspStats() {
		ClaspStatistics stats;
		typedef ClaspStatistics::Key_t Key_t;
		SolverStats st;
		st.enableExtended();
		st.choices = 100;
		st.extra->learnts[1] = 5;
		st.extra->binary = 6;
		stats.setRoot(StatisticObject::map(&st));
		Key_t root = stats.root();
		CPPUNIT_ASSERT(stats.type(root) == Potassco::Statistics_t::Map);
		Key_t choices = stats.get(root, "choices");
		CPPUNIT_ASSERT(stats.type(choices) == Potassco::Statistics_t::Value);
		CPPUNIT_ASSERT(stats.value(choices) == (double)100);
		Key_t extra = stats.get(root, "extra");
		CPPUNIT_ASSERT(stats.type(extra) == Potassco::Statistics_t::Map);
		Key_t bin = stats.get(extra, "lemmas_binary");
		CPPUNIT_ASSERT(stats.type(bin) == Potassco::Statistics_t::Value);
		CPPUNIT_ASSERT(stats.value(bin) == (double)6);

		Key_t binByPath = stats.get(root, "extra.lemmas_binary");
		CPPUNIT_ASSERT(binByPath == bin);
	}
	void testLearntShort() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		ctx.setShareMode(ContextParams::share_problem);
		ctx.setConcurrency(2);
		Solver& s = ctx.startAddConstraints();
		ctx.addBinary(c, d);
		ctx.endInit();
		ClauseCreator cc(&s);
		CPPUNIT_ASSERT(cc.start(Constraint_t::Conflict).add(a).add(b).end());
		CPPUNIT_ASSERT(cc.start(Constraint_t::Conflict).add(~a).add(~b).add(c).end());
		CPPUNIT_ASSERT(ctx.numLearntShort() == 2);
		CPPUNIT_ASSERT(ctx.numBinary()  == 1);
		CPPUNIT_ASSERT(ctx.numTernary() == 0);

		cc.start(Constraint_t::Conflict).add(a).add(b).add(c).end();
		// ignore subsumed/duplicate clauses
		CPPUNIT_ASSERT(ctx.numLearntShort() == 2);

		s.assume(~b);
		s.propagate();
		CPPUNIT_ASSERT(s.isTrue(a) && s.reason(a).firstLiteral() == ~b);
		s.undoUntil(0);
		s.assume(a);
		s.propagate();
		s.assume(b);
		s.propagate();
		CPPUNIT_ASSERT(s.isTrue(c));
		LitVec res;
		s.reason(c, res);
		CPPUNIT_ASSERT(std::find(res.begin(), res.end(), a) != res.end());
		CPPUNIT_ASSERT(std::find(res.begin(), res.end(), b) != res.end());
	}

	void testLearntShortAreDistributed() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		struct Dummy : public Distributor {
			Dummy() : Distributor(Policy(UINT32_MAX, UINT32_MAX, UINT32_MAX)), unary(0), binary(0), ternary(0) {}
			void publish(const Solver&, SharedLiterals* lits) {
				uint32 size = lits->size();
				unary   += size == 1;
				binary  += size == 2;
				ternary += size == 3;
				shared.push_back(lits);
			}
			uint32 receive(const Solver&, SharedLiterals** out, uint32 num) {
				uint32 r = 0;
				while (!shared.empty() && num--) {
					out[r++] = shared.back();
					shared.pop_back();
				}
				return r;
			}
			uint32 unary;
			uint32 binary;
			uint32 ternary;
			PodVector::type shared;
		}* dummy;
		ctx.distributor.reset(dummy = new Dummy());
		ctx.setConcurrency(2);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		LitVec lits; lits.resize(2);
		lits[0] = a; lits[1] = b;
		ClauseCreator::create(s, lits, 0, ConstraintInfo(Constraint_t::Conflict));
		lits.resize(3);
		lits[0] = ~a; lits[1] = ~b; lits[2] = ~c;
		ClauseCreator::create(s, lits, 0, ConstraintInfo(Constraint_t::Loop));
		lits.resize(1);
		lits[0] = d;
		ClauseCreator::create(s, lits, 0, ConstraintInfo(Constraint_t::Conflict));
		CPPUNIT_ASSERT(dummy->unary  == 1);
		CPPUNIT_ASSERT(dummy->binary == 1);
		CPPUNIT_ASSERT(dummy->ternary == 1);
		SharedLiterals* rec[3];
		CPPUNIT_ASSERT(dummy->receive(s, rec, 3) == 3);
		CPPUNIT_ASSERT(ClauseCreator::integrate(s, rec[0], 0).ok() == true);
		CPPUNIT_ASSERT(ClauseCreator::integrate(s, rec[1], 0).ok() == true);
		CPPUNIT_ASSERT(ClauseCreator::integrate(s, rec[2], 0).ok() == true);
	}

	void testAuxAreNotDistributed() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		struct Dummy : public Distributor {
			Dummy() : Distributor(Policy(UINT32_MAX, UINT32_MAX, UINT32_MAX)) {}
			void publish(const Solver&, SharedLiterals* lits) {
				shared.push_back(lits);
			}
			uint32 receive(const Solver&, SharedLiterals**, uint32) { return 0; }
			PodVector::type shared;
		}* dummy;
		ctx.distributor.reset(dummy = new Dummy());
		ctx.setConcurrency(2);
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Var aux = s.pushAuxVar();

		LitVec lits; lits.resize(2);
		lits[0] = a; lits[1] = posLit(aux);
		ClauseCreator::create(s, lits, 0, ConstraintInfo(Constraint_t::Conflict));
		lits.resize(4);
		lits[0] = ~a; lits[1] = posLit(aux); lits[2] = b; lits[3] = c;
		ClauseCreator::create(s, lits, 0, ConstraintInfo(Constraint_t::Conflict));
		CPPUNIT_ASSERT(s.numLearntConstraints() == 2);
		CPPUNIT_ASSERT(dummy->shared.empty());
		CPPUNIT_ASSERT(s.getLearnt(0).simplify(s, false) == false);
		s.pushRoot(posLit(aux));
		s.pushRoot(a);
		lits.clear();
		s.copyGuidingPath(lits);
		CPPUNIT_ASSERT(lits.size() == 1 && lits[0] == a);
		s.clearAssumptions();
		lits.resize(4);
		lits[0] = ~a; lits[1] = posLit(aux); lits[2] = ~b; lits[3] = c;
		ClauseCreator::create(s, lits, 0, ConstraintInfo(Constraint_t::Conflict));
		s.assume(a) && s.propagate();
		s.assume(negLit(aux)) && s.propagate();
		s.assume(~c) && s.propagate();
		CPPUNIT_ASSERT(s.hasConflict());
		s.resolveConflict();
		CPPUNIT_ASSERT(s.numLearntConstraints() == 4);
		CPPUNIT_ASSERT(dummy->shared.empty());
		CPPUNIT_ASSERT(s.sharedContext()->numTernary() + s.sharedContext()->numBinary() == 0);
	}

	void testAttachToDB() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		ctx.setConcurrency(2);
		Solver& s = ctx.startAddConstraints();
		ClauseCreator cc(&s);
		cc.start().add(a).add(b).add(c).add(d).end();
		Solver& s2 = ctx.pushSolver();
		ctx.endInit();
		ctx.attach(s2);
		CPPUNIT_ASSERT(s2.numConstraints() == 1);
		ctx.unfreeze();
		Literal e = posLit(ctx.addVar( Var_t::Atom ));
		Literal f = posLit(ctx.addVar( Var_t::Atom ));
		Literal g = posLit(ctx.addVar( Var_t::Atom ));
		Literal h = posLit(ctx.addVar( Var_t::Atom ));
		ctx.startAddConstraints();
		cc.start().add(e).add(f).add(g).add(h).end();
		cc.start().add(a).end();
		ctx.endInit();
		CPPUNIT_ASSERT(s.numConstraints() == 1);
		ctx.attach(s2);
		CPPUNIT_ASSERT(s2.numConstraints() == 1);
		s2.assume(~e) && s2.propagate();
		s2.assume(~f) && s2.propagate();
		s2.assume(~g) && s2.propagate();
		CPPUNIT_ASSERT(s2.isTrue(h));
	}

	void testAttachDeferred() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		ctx.setConcurrency(2);
		Solver& s = ctx.startAddConstraints();
		ClauseCreator cc(&s);
		cc.start().add(a).add(b).add(c).add(d).end();
		Solver& s2= ctx.pushSolver();
		ctx.endInit(true);
		CPPUNIT_ASSERT(s2.numConstraints() == 1);
		ctx.unfreeze();
		ctx.startAddConstraints();
		cc.start().add(~a).add(~b).add(c).add(d).end();
		ctx.endInit(false);
		CPPUNIT_ASSERT(s.numConstraints() == 2);
		CPPUNIT_ASSERT(s2.numConstraints() == 1);
		ctx.unfreeze();
		ctx.startAddConstraints();
		cc.start().add(a).add(b).add(~c).add(~d).end();
		ctx.endInit(true);
		CPPUNIT_ASSERT(s.numConstraints() == 3);
		CPPUNIT_ASSERT(s2.numConstraints() == 3);
	}

	void testUnfortunateSplitSeq() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		ctx.setConcurrency(2);
		Solver& s = ctx.startAddConstraints();
		Solver& s2= ctx.pushSolver();
		ctx.endInit(true);

		s.assume(a)   && s.propagate();
		// new fact
		s.backtrack() && s.propagate();

		s.assume(b) && s.propagate();

		LitVec sGp;
		s.copyGuidingPath(sGp);

		sGp.push_back(~b);
		s.pushRootLevel();
		integrateGp(s2, sGp);
		sGp.pop_back();
		s.clearAssumptions();

		LitVec s2Gp;

		s2.assume(c)&& s.propagate();
		s2.copyGuidingPath(s2Gp);
		s.pushRootLevel();
		s2Gp.push_back(~c);
		integrateGp(s, s2Gp);
		s2.clearAssumptions();
		s2Gp.clear();

		s.assume(d)&& s.propagate();
		sGp.clear();
		s.copyGuidingPath(sGp);

		integrateGp(s2, sGp);
		CPPUNIT_ASSERT(s2.isTrue(~a));
	}

	void testSplitInc() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		s.assume(a) && s.propagate();
		s.assume(b) && s.propagate();
		s.assume(c) && s.propagate();
		s.assume(d) && s.propagate();
		LitVec gp;
		s.copyGuidingPath(gp);
		s.pushRootLevel();
		gp.push_back(~a);
		CPPUNIT_ASSERT(gp.size() == 1 && gp[0] == ~a && s.rootLevel() == 1);
		gp.pop_back();

		s.copyGuidingPath(gp);
		s.pushRootLevel();
		gp.push_back(~b);
		CPPUNIT_ASSERT(gp.size() == 2 && gp[1] == ~b && s.rootLevel() == 2);
		gp.pop_back();

		s.copyGuidingPath(gp);
		s.pushRootLevel();
		gp.push_back(~c);
		CPPUNIT_ASSERT(gp.size() == 3 && gp[2] == ~c && s.rootLevel() == 3);
		gp.pop_back();
	}

	void testSplitFlipped() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();

		LitVec gp;

		s.assume(a) && s.propagate();
		s.pushRootLevel();
		s.assume(b) && s.propagate();
		s.backtrack();

		s.assume(c) && s.propagate();
		s.backtrack();

		s.assume(d) && s.propagate();
		s.copyGuidingPath(gp);
		CPPUNIT_ASSERT(std::find(gp.begin(), gp.end(), ~b) != gp.end());
		CPPUNIT_ASSERT(std::find(gp.begin(), gp.end(), ~c) != gp.end());
	}

	void testSplitFlipToNewRoot() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();

		LitVec gp;
		s.assume(a) && s.propagate();
		s.copyGuidingPath(gp);
		s.pushRootLevel();

		s.assume(b) && s.propagate();
		s.assume(c) && s.propagate();

		s.backtrack(); // bt-level now 2, rootLevel = 1

		s.copyGuidingPath(gp);
		s.pushRootLevel();
		CPPUNIT_ASSERT(s.rootLevel() == s.backtrackLevel());
		s.assume(d) && s.propagate();
		s.copyGuidingPath(gp);
		s.pushRootLevel();
		CPPUNIT_ASSERT(std::find(gp.begin(), gp.end(), ~c) != gp.end());
	}

	void testSplitImplied() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		Literal e = posLit(ctx.addVar( Var_t::Atom ));
		Literal f = posLit(ctx.addVar( Var_t::Atom ));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();

		s.assume(a) && s.propagate();
		s.assume(b) && s.propagate();
		s.pushRootLevel(2);

		s.assume(c);
		s.setBacktrackLevel(s.decisionLevel());
		SingleOwnerPtr x( new TestingConstraint );
		s.force(~d, 2, x.get());

		LitVec gp;
		s.copyGuidingPath(gp);

		CPPUNIT_ASSERT(std::find(gp.begin(), gp.end(), ~d) != gp.end());
		s.pushRootLevel();
		s.assume(e);
		s.setBacktrackLevel(s.decisionLevel());
		s.force(~f, 2, x.get());

		s.copyGuidingPath(gp);
		CPPUNIT_ASSERT(std::find(gp.begin(), gp.end(), ~f) != gp.end());
	}

	void testAddShortIncremental() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		ctx.setConcurrency(2);
		ctx.startAddConstraints();
		ctx.addBinary(a, b);
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.numBinary()  == 1);
		ctx.startAddConstraints();
		ctx.addBinary(~a, ~b);
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.numBinary()  == 2);
	}

	void testSwitchToMtIncremental() {
		Literal a = posLit(ctx.addVar( Var_t::Atom ));
		Literal b = posLit(ctx.addVar( Var_t::Atom ));
		Literal c = posLit(ctx.addVar( Var_t::Atom ));
		Literal d = posLit(ctx.addVar( Var_t::Atom ));
		Solver& s = ctx.startAddConstraints();
		ClauseCreator cl(&s);
		cl.start().add(a).add(b).add(c).add(d).end();
		ctx.endInit(true);
		CPPUNIT_ASSERT(s.numVars() == 4 && s.numConstraints() == 1);
		ctx.unfreeze();
		Solver& s2 = ctx.pushSolver();
		CPPUNIT_ASSERT(ctx.concurrency() == 2);
		ctx.startAddConstraints();
		cl.start().add(~a).add(~b).add(~c).add(~d).end();
		ctx.endInit(true);
		CPPUNIT_ASSERT(s.numVars() == 4 && s.numConstraints() == 2);
		CPPUNIT_ASSERT(s2.numVars() == 4 && s2.numConstraints() == 2);
	}

	void testScheduleAdvance() {
		ScheduleStrategy r1 = ScheduleStrategy::geom(100,1.5,13);
		for (uint32 i = 0, m = (1u << 15)-1; i != m; ++i, r1.next()) {
			ScheduleStrategy r2 = ScheduleStrategy::geom(100,1.5,13);
			r2.advanceTo(i);
			CPPUNIT_ASSERT(r1.idx == r2.idx && r1.len == r2.len);
		}
	}
	void testLubyAdvance() {
		ScheduleStrategy r1 = ScheduleStrategy::luby(64,10);
		for (uint32 i = 0, m = (1u << 15)-1; i != m; ++i, r1.next()) {
			ScheduleStrategy r2 = ScheduleStrategy::luby(64,10);
			r2.advanceTo(i);
			CPPUNIT_ASSERT(r1.idx == r2.idx && r1.len == r2.len);
		}
	}
	void testPushAux() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT(s.numVars() == s.sharedContext()->numVars());

		Var aux = s.pushAuxVar();
		CPPUNIT_ASSERT(s.numVars() > s.sharedContext()->numVars());
		CPPUNIT_ASSERT(s.validVar(aux) && !s.sharedContext()->validVar(aux));
		LitVec clause;
		clause.push_back(posLit(aux));
		clause.push_back(a);
		clause.push_back(b);
		ClauseCreator::create(s, clause, 0, Constraint_t::Conflict);
		CPPUNIT_ASSERT(s.sharedContext()->numTernary() == 0);
		CPPUNIT_ASSERT(s.numLearntConstraints() == 1);
		s.assume(~a) && s.propagate();
		s.assume(~b) && s.propagate();
		CPPUNIT_ASSERT(s.isTrue(posLit(aux)));
		s.popAuxVar();
		CPPUNIT_ASSERT(s.decisionLevel() < 2u);
		CPPUNIT_ASSERT(s.numVars() == s.sharedContext()->numVars());
	}
	void testPushAuxFact() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Var aux = s.pushAuxVar();
		LitVec clause;
		clause.push_back(posLit(aux));
		clause.push_back(a);
		ClauseCreator::create(s, clause, 0, Constraint_t::Conflict);
		s.force(~a) && s.propagate();
		s.force(b)  && s.simplify();
		CPPUNIT_ASSERT(s.numFreeVars() == 0);
		s.popAuxVar();
		CPPUNIT_ASSERT(s.numFreeVars() == 0 && s.validVar(aux) == false);
	}
	void testPopAuxRemovesConstraints() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Var aux = s.pushAuxVar();
		LitVec clause;
		clause.push_back(a);
		clause.push_back(b);
		clause.push_back(c);
		clause.push_back(posLit(aux));
		ClauseCreator::create(s, clause, 0, Constraint_t::Conflict);
		clause.clear();
		clause.push_back(a);
		clause.push_back(b);
		clause.push_back(~c);
		clause.push_back(negLit(aux));
		ClauseCreator::create(s, clause, 0, Constraint_t::Conflict);
		CPPUNIT_ASSERT(s.numLearntConstraints() == 2);
		s.popAuxVar();
		CPPUNIT_ASSERT(s.numLearntConstraints() == 0);
	}
	void testPopAuxRemovesConstraintsRegression() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Literal c = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Var aux = s.pushAuxVar();
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, 1));
		lits.push_back(WeightLiteral(b, 1));
		lits.push_back(WeightLiteral(c, 1));
		lits.push_back(WeightLiteral(posLit(aux), 1));
		Solver::ConstraintDB t;
		t.push_back(WeightConstraint::create(s, lit_false(), lits, 3, WeightConstraint::create_explicit | WeightConstraint::create_no_add | WeightConstraint::create_no_freeze | WeightConstraint::create_no_share).first());
		s.force(posLit(aux)) && s.propagate();
		s.popAuxVar(1, &t);
	}
	void testPopAuxMaintainsQueue() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		ctx.endInit();
		Var aux = s.pushAuxVar();
		s.force(a, 0); s.propagate();
		s.force(posLit(aux), 0);
		s.force(b, 0);
		s.popAuxVar();
		CPPUNIT_ASSERT(s.isTrue(a) && s.isTrue(b) && s.queueSize() == 1 && s.assignment().units() == 1);
	}

	void testIncrementalAux() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		Solver& s2= ctx.pushSolver();
		ctx.endInit(true);
		Var aux   = s2.pushAuxVar();
		CPPUNIT_ASSERT(!ctx.validVar(aux) && !s.validVar(aux));
		LitVec clause;
		clause.push_back(a);
		clause.push_back(posLit(aux));
		ClauseCreator::create(s2, clause, 0, Constraint_t::Conflict);
		ctx.unfreeze();
		Var n     = ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		ctx.endInit(true);
		s2.assume(negLit(n)) && s2.propagate();
		CPPUNIT_ASSERT(s2.value(a.var()) == value_free);
	}

	void testUnfreezeStepBug() {
		Literal a = posLit(ctx.addVar(Var_t::Atom));
		Literal b = posLit(ctx.addVar(Var_t::Atom));
		Solver& s = ctx.startAddConstraints();
		Solver& s2= ctx.pushSolver();
		ctx.addBinary(~a, b);
		ctx.endInit(true);
		s2.force(b);
		ctx.unfreeze();
		ctx.endInit(true);
		CPPUNIT_ASSERT(s.force(a) && s.propagate());
		CPPUNIT_ASSERT(s.isTrue(b));
	}
	void testRemoveConstraint() {
		Solver& s = ctx.startAddConstraints();
		Solver& s2= ctx.pushSolver();
		ctx.add(new TestingConstraint());
		ctx.endInit(true);
		CPPUNIT_ASSERT(s2.numConstraints() == 1);
		ctx.removeConstraint(0, true);
		CPPUNIT_ASSERT(s.numConstraints() == 0);
		CPPUNIT_ASSERT(s2.numConstraints() == 1);
		ctx.unfreeze();
		ctx.startAddConstraints();
		ctx.add(new TestingConstraint());
		ctx.add(new TestingConstraint());
		ctx.endInit(true);
		CPPUNIT_ASSERT(s.numConstraints() == 2);
		CPPUNIT_ASSERT(s2.numConstraints() == 3);
	}
	void testPopVars() {
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		CPPUNIT_ASSERT(ctx.numVars() == 3u);
		CPPUNIT_ASSERT(ctx.master()->numVars() == 0u);
		ctx.popVars(2);
		CPPUNIT_ASSERT(ctx.numVars() == 1u);
	}
	void testPopVarsAfterCommit() {
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		CPPUNIT_ASSERT(ctx.master()->numVars() == 3u);
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 3u);
		ctx.popVars(2);
		CPPUNIT_ASSERT(ctx.numVars() == 1u);
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->numVars() == 1u);
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 1u);
	}
	void testPopVarsIncremental() {
		ctx.requestStepVar();
		Var v1 = ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		Var v3 = ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.numVars() == 4u);
		CPPUNIT_ASSERT(ctx.stepLiteral().var() == 4u);
		ctx.addUnary(posLit(v3));
		ctx.addUnary(posLit(v1));
		CPPUNIT_ASSERT(ctx.master()->trail().size() == 2u);
		CPPUNIT_ASSERT(ctx.master()->trail()[0] == posLit(v3));
		CPPUNIT_ASSERT(ctx.master()->trail()[1] == posLit(v1));
		ctx.unfreeze();
		ctx.popVars(2u);
		CPPUNIT_ASSERT_MESSAGE("step var is not counted", ctx.numVars() == 1u);
		CPPUNIT_ASSERT(ctx.stepLiteral().var() == 0u);
		CPPUNIT_ASSERT(ctx.master()->trail().size() == 1u);
		CPPUNIT_ASSERT(ctx.master()->trail()[0] == posLit(v1));
		ctx.endInit();
		ctx.unfreeze();
		Var v = ctx.addVar(Var_t::Atom);
		ctx.setFrozen(v, true);
		ctx.startAddConstraints();
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.numVars() == 3u);
		ctx.unfreeze();
		ctx.popVars(2u);
		CPPUNIT_ASSERT_MESSAGE("step var is not counted", ctx.stepLiteral().var() == 0u);
		CPPUNIT_ASSERT(ctx.stats().vars.frozen == 0u);
	}
	void testPopVarsIncrementalBug() {
		ctx.requestStepVar();
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		ctx.endInit();
		ctx.unfreeze();
		Var c = ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		ctx.addUnary(posLit(c));
		ctx.popVars(1);
		ctx.endInit();
		CPPUNIT_ASSERT(ctx.master()->isTrue(posLit(c)));
		CPPUNIT_ASSERT(ctx.master()->numFreeVars() == 3);
		CPPUNIT_ASSERT(ctx.master()->numAssignedVars() == 1);
	}
	void testPopVarsMT() {
		ctx.requestStepVar();
		ctx.addVar(Var_t::Atom);
		ctx.addVar(Var_t::Atom);
		Var c = ctx.addVar(Var_t::Atom);
		Solver& s2 = ctx.pushSolver();
		ctx.startAddConstraints();
		ctx.endInit(true);
		s2.force(posLit(c));
		ctx.unfreeze();
		CPPUNIT_ASSERT(ctx.master()->isTrue(posLit(c)) && s2.isTrue(posLit(c)));
		ctx.popVars(2); // pop c, b
		Var d = ctx.addVar(Var_t::Atom);
		ctx.startAddConstraints();
		CPPUNIT_ASSERT(ctx.master()->value(d) == value_free);
		ctx.endInit(true);
		CPPUNIT_ASSERT(s2.value(d) == value_free);
	}
private:
	SharedContext ctx;
	void integrateGp(Solver& s, LitVec& gp) {
		s.clearAssumptions();
		for (LitVec::size_type i = 0; i != gp.size(); ++i) {
			if (s.value(gp[i].var()) == value_free) {
				s.assume(gp[i]) && s.propagate();
				s.pushRootLevel();
			}
		}
	}
	LitVec addBinary() {
		LitVec r;
		r.push_back( posLit(ctx.addVar(Var_t::Atom)) );
		r.push_back( posLit(ctx.addVar(Var_t::Atom)) );
		ctx.startAddConstraints();
		ctx.addBinary(r[0], r[1]);
		ctx.endInit();
		return r;
	}
	LitVec addTernary() {
		LitVec r;
		r.push_back( posLit(ctx.addVar(Var_t::Atom)) );
		r.push_back( posLit(ctx.addVar(Var_t::Atom)) );
		r.push_back( posLit(ctx.addVar(Var_t::Atom)) );
		ctx.startAddConstraints();
		ctx.addTernary(r[0], r[1],r[2]);
		ctx.endInit();
		return r;
	}
};
CPPUNIT_TEST_SUITE_REGISTRATION(SolverTest);
} }

clasp-3.2.2/libclasp/tests/test.h000066400000000000000000000022131304134206100166730ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef TEST_TEST_H_INCLUDED
#define TEST_TEST_H_INCLUDED

#include 
#include 
#include 
#include 

namespace Clasp {
inline std::ostream& operator<<(std::ostream& os, Literal p) {
	if (p.sign()) os << "-";
	os << p.var();
	return os;
}
}

#endif

clasp-3.2.2/libclasp/tests/test_main.cpp000066400000000000000000000073421304134206100202420ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#if defined (_MSC_VER) && _MSC_VER >= 1200
#include 
#endif
//#define CHECK_HEAP 1

class CmdLineRunner : public CPPUNIT_NS::TextUi::TestRunner {
public:
	using CPPUNIT_NS::TextUi::TestRunner::run;
	bool run(const std::string& prefix, char** argv, int num) {
		using namespace CPPUNIT_NS;
		if (num == 0) { // run all tests
			return TextUi::TestRunner::run();
		}
		TextTestProgressListener progress;
		m_eventManager->addListener( &progress );
		for (int i = 0; i != num; ++i) {
			std::string path = strncmp(argv[i], prefix.c_str(), prefix.length()) != 0 ? prefix + argv[i] : argv[i];
			try { TestRunner::run(*m_eventManager, path); }
			catch (const std::invalid_argument& e) {
				m_eventManager->addError(m_suite, new Exception(Message(e.what()), CPPUNIT_SOURCELINE()));
			}
		}
		m_eventManager->removeListener( &progress );
		printResult( true );
		return m_result->wasSuccessful();
	}
};

void dump(CPPUNIT_NS::Test* root, int level, int maxLevel) {
	if (root && level != maxLevel) {
		printf("%s\n", root->getName().c_str());
		for (int i = 0; i < root->getChildTestCount(); i++) {
			CPPUNIT_NS::Test* c = root->getChildTestAt(i);
			if (level + 1 < maxLevel) { dump(c, level + 1, maxLevel); }
			else {
				printf("%s\n", c->getName().c_str());
			}
		}
	}
}
int main(int argc, char** argv) {
#if defined (_MSC_VER) && defined (CHECK_HEAP) && _MSC_VER >= 1200
	_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) |
				  _CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF |
	_CRTDBG_CHECK_ALWAYS_DF);

	_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR );
	_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
	_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
#endif
	CmdLineRunner runner;
	// Change the default outputter to a compiler error format outputter.
#if defined (_MSC_VER)
	runner.setOutputter( new CPPUNIT_NS::CompilerOutputter( &runner.result(), std::cout ) );
#else
	runner.setOutputter( new CPPUNIT_NS::CompilerOutputter( &runner.result(), std::cout, "%p:%l:" ) );
#endif
	if (argc == 2) {
		if (strcmp(argv[1], "--list") == 0) {
			dump(CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest(), 0, 1);
			return 0;
		}
		else if (strcmp(argv[1], "--list-all") == 0) {
			dump(CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest(), 0, INT_MAX);
			return 0;
		}
	}
	// Add all registered tests.
	runner.addTest( CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest() );
	// Run selected tests.
	return 1 - int(runner.run("Clasp::Test::", argv + 1, argc - 1));
}
clasp-3.2.2/libclasp/tests/unfounded_check_test.cpp000066400000000000000000000506261304134206100224450ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include "lpcompare.h"
#include 
#include 
#include 
#include 

namespace Clasp { namespace Test {
	using namespace Clasp::Asp;
	class UnfoundedCheckTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(UnfoundedCheckTest);
	CPPUNIT_TEST(testAllUncoloredNoUnfounded);
	CPPUNIT_TEST(testAlternativeSourceNotUnfounded);
	CPPUNIT_TEST(testOnlyOneSourceUnfoundedIfMinus);

	CPPUNIT_TEST(testWithSimpleCardinalityConstraint);
	CPPUNIT_TEST(testWithSimpleWeightConstraint);

	CPPUNIT_TEST(testNtExtendedBug);
	CPPUNIT_TEST(testNtExtendedFalse);

	CPPUNIT_TEST(testDependentExtReason);
	CPPUNIT_TEST(testEqBodyDiffType);
	CPPUNIT_TEST(testChoiceCardInterplay);
	CPPUNIT_TEST(testCardInterplayOnBT);

	CPPUNIT_TEST(testInitNoSource);

	CPPUNIT_TEST(testIncrementalUfs);
	CPPUNIT_TEST(testInitialStopConflict);
	CPPUNIT_TEST(testIncrementalLearnFact);

	CPPUNIT_TEST(testDetachRemovesWatches);

	CPPUNIT_TEST(testApproxUfs);

	CPPUNIT_TEST(testWeightReason);
	CPPUNIT_TEST(testCardExtSet);
	CPPUNIT_TEST(testCardNoSimp);
	CPPUNIT_TEST_SUITE_END();
public:
	class WrapDefaultUnfoundedCheck : public DefaultUnfoundedCheck {
	public:
		explicit WrapDefaultUnfoundedCheck(Asp::PrgDepGraph& g) : DefaultUnfoundedCheck(g) {}
		bool propagate(Solver& s) { return DefaultUnfoundedCheck::propagateFixpoint(s, 0); }
	};
	UnfoundedCheckTest() : ufs(0) { }
	void tearDown() {
		ufs   = 0;
	}
	Solver& solver() { return *ctx.master(); }
	void testAllUncoloredNoUnfounded() {
		setupSimpleProgram();
		uint32 x = solver().numAssignedVars();
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(x, solver().numAssignedVars());
	}

	void testAlternativeSourceNotUnfounded() {
		setupSimpleProgram();
		solver().assume( index[6] );
		solver().propagateUntil(ufs.get());
		uint32 old = solver().numAssignedVars();
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(old, solver().numAssignedVars());
	}

	void testOnlyOneSourceUnfoundedIfMinus() {
		setupSimpleProgram();
		solver().assume( index[6] );
		solver().assume( index[5] );
		solver().propagateUntil(ufs.get());
		uint32 old = solver().numAssignedVars();
		uint32 oldC = ctx.numConstraints();
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT(old < solver().numAssignedVars());
		CPPUNIT_ASSERT(solver().isFalse(index[4]));
		CPPUNIT_ASSERT(solver().isFalse(index[1]));
		CPPUNIT_ASSERT(!solver().isFalse(index[2]));
		CPPUNIT_ASSERT(oldC+1 == ctx.numConstraints() + ctx.numLearntShort());
	}

	void testWithSimpleCardinalityConstraint() {
		lpAdd(lp.start(ctx), "{x2}. x1 :- 1 {x1, x2}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		attachUfs();

		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(2u, solver().numVars());
		CPPUNIT_ASSERT_EQUAL(0u, solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()) );
		CPPUNIT_ASSERT_EQUAL(0u, solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(~lp.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(1u, solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()) );
		CPPUNIT_ASSERT_EQUAL(2u, solver().numAssignedVars());
		LitVec r;
		solver().reason(~lp.getLiteral(1), r);
		CPPUNIT_ASSERT(1 == r.size());
		CPPUNIT_ASSERT(r[0] == ~lp.getLiteral(2));
	}
	void testWithSimpleWeightConstraint() {
		lpAdd(lp.start(ctx), "{x2;x3}. x1 :- 2 {x1 = 2, x2 = 2, x3}.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		attachUfs();
		ufs->setReasonStrategy(DefaultUnfoundedCheck::only_reason);

		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(3u, solver().numVars());
		CPPUNIT_ASSERT_EQUAL(0u, solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()) );
		CPPUNIT_ASSERT_EQUAL(0u, solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(~lp.getLiteral(3)));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(1u, solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()) );
		CPPUNIT_ASSERT_EQUAL(1u, solver().numAssignedVars());

		CPPUNIT_ASSERT_EQUAL(true, solver().assume(~lp.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(2u, solver().numAssignedVars());

		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()) );
		CPPUNIT_ASSERT_EQUAL(3u, solver().numAssignedVars());

		LitVec r;
		solver().reason(~lp.getLiteral(1), r);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~lp.getLiteral(2)) != r.end());

		solver().undoUntil(0);
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(~lp.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(1u, solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()) );
		CPPUNIT_ASSERT_EQUAL(2u, solver().numAssignedVars());
		r.clear();
		solver().reason(~lp.getLiteral(1), r);
		CPPUNIT_ASSERT(1 == r.size());
		CPPUNIT_ASSERT(r[0] == ~lp.getLiteral(2));
	}

	void testNtExtendedBug() {
		lpAdd(lp.start(ctx),
			"{x1;x2;x3}.\n"
			"x4 :- 2 {x2, x4, x5}.\n"
			"x5 :- x4, x3.\n"
			"x5 :- x1.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		attachUfs();

		// T: {x4,x3}
		solver().assume(Literal(6, false));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		solver().assume(~lp.getLiteral(1));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(false, ufs->propagate(solver()));  // {x4, x5} are unfounded!

		solver().undoUntil(0);
		ufs->reset();

		// F: {x4,x3}
		solver().assume(Literal(6, true));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		// F: x1
		solver().assume(~lp.getLiteral(1));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		// x5 is false because both of its bodies are false
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(5)));

		// x4 is now unfounded but its defining body is not
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(4)));
		LitVec r;
		solver().reason(~lp.getLiteral(4), r);
		CPPUNIT_ASSERT(r.size() == 1 && r[0] == ~lp.getLiteral(5));
	}

	void testNtExtendedFalse() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"{x3}.\n"
			"x4 :- 2 {x1, x2, x5}.\n"
			"x5 :- x4, x3.\n"
			"x4 :- x5, x3.\n"
			"x1 :- not x3.\n"
			"x2 :- not x3.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		attachUfs();

		solver().assume(lp.getLiteral(3));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT(solver().numVars() == solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(4)));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(5)));

		solver().backtrack();
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT(solver().numVars() == solver().numAssignedVars());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(lp.getLiteral(4)));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(5)));
	}

	void testDependentExtReason() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"{x3, x4, x5}.\n"
			"x1 :- not x4.\n"
			"x1 :- 2 {x1, x2, x3}.\n"
			"x1 :- x2, x3.\n"
			"x2 :- x1, x5.");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		attachUfs();

		// assume ~B1, where B1 = 2 {x1, x2, x3}
		const Asp::PrgDepGraph::AtomNode& a = ufs->graph()->getAtom(lp.getAtom(1)->id());
		Literal x1 = ufs->graph()->getBody(a.body(1)).lit;

		solver().assume(~x1);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()) && ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(value_free, solver().value(lp.getLiteral(1).var()));
		CPPUNIT_ASSERT_EQUAL(value_free, solver().value(lp.getLiteral(2).var()));
		// B1
		CPPUNIT_ASSERT_EQUAL(1u, solver().numAssignedVars());

		// assume x4
		solver().assume(lp.getLiteral(4));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		// B1 + x4 (hence {not x4})
		CPPUNIT_ASSERT_EQUAL(2u, solver().numAssignedVars());

		// U = {x1, x2}.
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(1)));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(2)));
		Literal extBody = ufs->graph()->getBody(a.body(0)).lit;
		LitVec r;
		solver().reason(~lp.getLiteral(1), r);
		CPPUNIT_ASSERT(r.size() == 1u && r[0] == ~extBody);
	}

	void testEqBodyDiffType() {
		lpAdd(lp.start(ctx),
			"{x1; x4; x5}.\n"
			"{x2} :- x1.\n"
			"x3 :- x1.\n"
			"x2 :- x3, x4.\n"
			"x3 :- x2, x5.");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		attachUfs();

		solver().assume(~lp.getLiteral(1));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(3)));
	}

	void testChoiceCardInterplay() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"{x4}.\n"
			"{x1} :- x4.\n"
			"x2 :- 1 {x1, x3}.\n"
			"x3 :- x2.\n"
			"{x1} :- x3.");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		attachUfs();

		solver().assume(~lp.getLiteral(1));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(true, solver().isFalse(lp.getLiteral(3)));
	}

	void testCardInterplayOnBT() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"{x1;x5}.\n"
			"x2 :- 1 {x1, x3}.\n"
			"x2 :- x4.\n"
			"x4 :- x2.\n"
			"x4 :- x5.\n"
			"x3 :- x2, x4.");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		attachUfs();

		solver().assume(~lp.getLiteral(1));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()) && ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(false, solver().isFalse(lp.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(false, solver().isFalse(lp.getLiteral(3)));
		solver().undoUntil(0);

		solver().assume(~lp.getLiteral(5));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()) && ufs->propagate(solver()));
		CPPUNIT_ASSERT_EQUAL(false, solver().isFalse(lp.getLiteral(2)));
		CPPUNIT_ASSERT_EQUAL(false, solver().isFalse(lp.getLiteral(3)));
	}

	void testInitNoSource() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"{x3}.\n"
			"{x1;x2} :- x3.\n"
			"x1 :- x2.\n"
			"x2 :- x1.\n");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.stats.sccs == 1);

		solver().force(~lp.getLiteral(3));
		attachUfs();
		CPPUNIT_ASSERT(solver().isFalse(lp.getLiteral(1)));
	}

	void testIncrementalUfs() {
		lp.start(ctx, LogicProgram::AspOptions().noEq());
		lp.updateProgram();
		lpAdd(lp,
			"% I1:\n"
			"x1 :- not x2.\n"
			"x2 :- not x1.\n"
			"#external x3.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram() && ctx.endInit());
		CPPUNIT_ASSERT(ctx.sccGraph.get() == 0);
		lp.updateProgram();
		lpAdd(lp,
			"% I2:\n"
			"{x3;x6}.\n"
			"x4 :- not x3.\n"
			"x4 :- x5, x6.\n"
			"x5 :- x4, x6.\n"
			"#external x3. [release]");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(6u == ctx.sccGraph.get()->nodes());
		CPPUNIT_ASSERT(1 == lp.stats.sccs);
		attachUfs();
		CPPUNIT_ASSERT(6u == ufs->nodes());

		lp.updateProgram();
		lpAdd(lp,
			"% I3:\n"
			"x7 :- x4, not x9.\n"
			"x9 :- not x7.\n"
			"x7 :- x8.\n"
			"x8 :- x7, not x6.\n");

		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(11u == ctx.sccGraph.get()->nodes());
		CPPUNIT_ASSERT(1 == lp.stats.sccs);
		ctx.endInit();
		CPPUNIT_ASSERT(11u == ufs->nodes());
		CPPUNIT_ASSERT(lp.getAtom(7)->scc() != lp.getAtom(4)->scc());
	}

	void testInitialStopConflict() {
		lpAdd(lp.start(ctx),
			"{x3;x4}.\n"
			"x1 :- x3, x4.\n"
			"x1 :- x2, x4.\n"
			"x2 :- x1, x4.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		struct M : PostPropagator {
			uint32 priority() const { return priority_reserved_msg; }
			bool propagateFixpoint(Solver& s, PostPropagator*) {
				s.setStopConflict();
				return false;
			}
		} m;
		solver().addPost(&m);
		ctx.addUnary(~lp.getLiteral(3));
		attachUfs();
		CPPUNIT_ASSERT(solver().hasStopConflict());
		solver().removePost(&m);
		solver().popRootLevel();
		solver().propagate();
		CPPUNIT_ASSERT(solver().isFalse(lp.getLiteral(3)));
		CPPUNIT_ASSERT(solver().isFalse(lp.getLiteral(1)) && solver().isFalse(lp.getLiteral(2)));
	}

	void testIncrementalLearnFact() {
		lp.start(ctx);
		lp.update();
		lpAdd(lp,
			"{x3;x4}.\n"
			"x1 :- x3, x4.\n"
			"x1 :- x2, x4.\n"
			"x2 :- x1, x4.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		attachUfs();
		lp.update();
		lp.endProgram();
		ctx.addUnary(~lp.getLiteral(3));
		CPPUNIT_ASSERT(solver().propagate());
		CPPUNIT_ASSERT(ctx.endInit());
		CPPUNIT_ASSERT(solver().isFalse(lp.getLiteral(3)));
		CPPUNIT_ASSERT(solver().isFalse(lp.getLiteral(1)) && solver().isFalse(lp.getLiteral(2)));
	}

	void testDetachRemovesWatches() {
		lpAdd(lp.start(ctx, LogicProgram::AspOptions().noEq()),
			"{x3;x4;x5}.\n"
			"x1 :- x4.\n"
			"x1 :- 2 {x1, x2, x3}.\n"
			"x1 :- x2, x3.\n"
			"x2 :- x1, x5.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		ctx.endInit();
		uint32 numW = 0;
		for (uint32 i = 1; i <= solver().numVars(); ++i) {
			numW += solver().numWatches(posLit(i));
			numW += solver().numWatches(negLit(i));
		}
		ufs = new WrapDefaultUnfoundedCheck(*ctx.sccGraph);
		solver().addPost(ufs.release());
		ufs->destroy(&solver(), true);
		CPPUNIT_ASSERT(!solver().getPost(PostPropagator::priority_reserved_ufs));
		for (uint32 i = 1; i <= solver().numVars(); ++i) {
			numW -= solver().numWatches(posLit(i));
			numW -= solver().numWatches(negLit(i));
		}
		CPPUNIT_ASSERT(numW == 0);
	}

	void testApproxUfs() {
		lpAdd(lp.start(ctx),
			"a | b.\n"
			"c | d.\n"
			"c | e :- b.\n"
			"b | d :- c.\n"
			"c :- d, not b.\n"
			"c :- e.\n"
			"d :- e, not a.\n"
			"e :- c, d.");
		lp.endProgram();
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		CPPUNIT_ASSERT(lp.getAtom(1)->scc() == PrgNode::noScc);
		CPPUNIT_ASSERT(5u == ctx.sccGraph.get()->numAtoms());
		CPPUNIT_ASSERT(8u == ctx.sccGraph.get()->numBodies());
		attachUfs();
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(lp.getLiteral(2)) && solver().propagate());
		solver().assume(lp.getLiteral(3));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));

		CPPUNIT_ASSERT(solver().value(lp.getLiteral(4).var()) == value_free);
		CPPUNIT_ASSERT_EQUAL(true, ufs->propagate(solver()));

		CPPUNIT_ASSERT(solver().isFalse(lp.getLiteral(4)) || "TODO: Implement approx. ufs!");
	}

	void testWeightReason() {
		lpAdd(lp.start(ctx),
			"{x4;x5;x6;x7}.\n"
			"x1 :- 2 {x2, x3 = 2, not x4}.\n"
			"x2 :- x1, x5.\n"
			"x3 :- x2, x6.\n"
			"x3 :- x7.");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		attachUfs();
		ufs->setReasonStrategy(DefaultUnfoundedCheck::only_reason);
		ctx.master()->assume(~lp.getLiteral(7)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(3)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(1)));
		ctx.master()->undoUntil(0);

		ctx.master()->assume(lp.getLiteral(4)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->value(lp.getLiteral(1).var()) == value_free);
		ctx.master()->assume(lp.getLiteral(5)) && ctx.master()->propagate();
		ctx.master()->assume(lp.getLiteral(6)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->numAssignedVars() == 3);
		ctx.master()->assume(~lp.getLiteral(7)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(1)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(2)));
		CPPUNIT_ASSERT(ctx.master()->isFalse(lp.getLiteral(3)));

		LitVec reason;
		ctx.master()->reason(~lp.getLiteral(3), reason);
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~lp.getLiteral(7)) != reason.end());
		CPPUNIT_ASSERT(reason.size() == 1);
	}

	void testCardExtSet() {
		lpAdd(lp.start(ctx),
			"{x4; x5; x6; x7; x8}.\n"
			"c :- 2 {a, b, x4, x5}.\n"
			"a :- c,x6.\n"
			"b :- a,x7.\n"
			"a :- x8.\n");
		Var a = 1, b = 2, c = 3, x4 = 4, x5 = 5, x6 = 6, x7 = 7, x8 = 8;
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		attachUfs();
		ufs->setReasonStrategy(DefaultUnfoundedCheck::only_reason);
		Solver& solver = *ctx.master();
		solver.undoUntil(0);
		solver.assume(~lp.getLiteral(x4)) && solver.propagate();
		solver.assume(~lp.getLiteral(x8)) && solver.propagate();
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(a)));
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(c)));

		solver.undoUntil(0);
		solver.assume(~lp.getLiteral(x5)) && solver.propagate();
		solver.assume(~lp.getLiteral(x8)) && solver.propagate();
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(a)));
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(c)));

		solver.undoUntil(0);
		solver.assume(~lp.getLiteral(x4)) && solver.propagate();
		solver.assume(~lp.getLiteral(x5)) && solver.propagate();
		CPPUNIT_ASSERT(solver.numAssignedVars() == 2);

		solver.assume(lp.getLiteral(x6)) && solver.propagate();
		solver.assume(lp.getLiteral(x7)) && solver.propagate();
		CPPUNIT_ASSERT(solver.numAssignedVars() == 4);

		ctx.master()->assume(~lp.getLiteral(x8)) && ctx.master()->propagate();
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(a)));
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(b)));
		CPPUNIT_ASSERT(solver.isFalse(lp.getLiteral(c)));

		LitVec reason;
		ctx.master()->reason(~lp.getLiteral(a), reason);
		bool hasP = std::find(reason.begin(), reason.end(), ~lp.getLiteral(x4)) != reason.end();
		bool hasQ = std::find(reason.begin(), reason.end(), ~lp.getLiteral(x5)) != reason.end();
		bool hasT = std::find(reason.begin(), reason.end(), ~lp.getLiteral(x8)) != reason.end();
		CPPUNIT_ASSERT((hasP ^ hasQ) == true && hasT);
	}

	void testCardNoSimp() {
		lpAdd(lp.start(ctx),
			"b :- 2 {a, c, d, not a}.\n"
			"a :-b.\n"
			"a :- x5.\n"
			"{c;d;x5}.");
		Var a = 1, d = 4, x5 = 5;
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		CPPUNIT_ASSERT(lp.stats.sccs == 1);
		attachUfs();

		ufs->setReasonStrategy(DefaultUnfoundedCheck::only_reason);
		Solver& solver = *ctx.master();

		solver.assume(~lp.getLiteral(d)) && solver.propagate();
		solver.assume(lp.getLiteral(a)) && solver.propagate();

		CPPUNIT_ASSERT(solver.assume(~lp.getLiteral(x5)) && solver.propagateUntil(ufs.get()));
		CPPUNIT_ASSERT(!ufs->propagate(solver));
		solver.resolveConflict();
		CPPUNIT_ASSERT(solver.isTrue(lp.getLiteral(x5)));
		LitVec r;
		solver.reason(lp.getLiteral(x5), r);
		CPPUNIT_ASSERT(r.size() == 2);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~lp.getLiteral(d)) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), lp.getLiteral(a)) != r.end());
	}
private:
	SharedContext ctx;
	SingleOwnerPtr ufs;
	LogicProgram lp;
	LitVec index;
	void attachUfs() {
		if (ctx.sccGraph.get()) {
			ufs = new WrapDefaultUnfoundedCheck(*ctx.sccGraph);
			solver().addPost(ufs.release());
		}
		ctx.endInit();
	}
	void setupSimpleProgram() {
		lpAdd(lp.start(ctx),
			"{x5;x6;x7;x3}.\n"
			"x2 :- x1.\n"
			"x1 :- x2, x4.\n"
			"x4 :- x1, x3.\n"
			"x1 :- not x5.\n"
			"x2 :- not x7.\n"
			"x4 :- not x6.\n");
		CPPUNIT_ASSERT_EQUAL(true, lp.endProgram());
		index.assign(1, lit_true());
		for (Var v = 1; v <= lp.numAtoms(); ++v) {
			index.push_back(lp.getLiteral(v));
		}
		attachUfs();
		CPPUNIT_ASSERT_EQUAL(true, solver().propagateUntil(ufs.get()));
	}
};
CPPUNIT_TEST_SUITE_REGISTRATION(UnfoundedCheckTest);
} }
clasp-3.2.2/libclasp/tests/weight_constraint_test.cpp000066400000000000000000000660421304134206100230530ustar00rootroot00000000000000//
// Copyright (c) 2006, Benjamin Kaufmann
//
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/
//
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#include "test.h"
#include 
#include 
#include 
using namespace std;

namespace Clasp { namespace Test {
class WeightConstraintTest : public CppUnit::TestFixture {
	CPPUNIT_TEST_SUITE(WeightConstraintTest);
	CPPUNIT_TEST(testAssertTriviallySat);
	CPPUNIT_TEST(testAssertTriviallyUnSat);
	CPPUNIT_TEST(testAssertNotSoTriviallySat);
	CPPUNIT_TEST(testAssertNotSoTriviallyUnSat);

	CPPUNIT_TEST(testTrivialBackpropTrue);
	CPPUNIT_TEST(testTrivialBackpropFalse);
	CPPUNIT_TEST(testTrivialBackpropFalseWeight);

	CPPUNIT_TEST(testForwardTrue);
	CPPUNIT_TEST(testForwardFalse);
	CPPUNIT_TEST(testBackwardTrue);
	CPPUNIT_TEST(testBackwardFalse);

	CPPUNIT_TEST(testForwardTrueConflict);
	CPPUNIT_TEST(testForwardFalseConflict);
	CPPUNIT_TEST(testBackwardTrueConflict);
	CPPUNIT_TEST(testBackwardFalseConflict);

	CPPUNIT_TEST(testReasonBug);
	CPPUNIT_TEST(testWeightReasonAfterBackprop);
	CPPUNIT_TEST(testOrderBug);
	CPPUNIT_TEST(testBackwardAfterForward);

	CPPUNIT_TEST(testOnlyBTB);
	CPPUNIT_TEST(testOnlyBFB);

	CPPUNIT_TEST(testSimplify);
	CPPUNIT_TEST(testSimplifyCardinality);
	CPPUNIT_TEST(testSimplifyWeight);
	CPPUNIT_TEST(testSimplifyWatches);

	CPPUNIT_TEST(testAssertWeightTriviallySat);
	CPPUNIT_TEST(testAssertWeightTriviallyUnSat);
	CPPUNIT_TEST(testAssertWeightNotSoTriviallySat);
	CPPUNIT_TEST(testAssertWeightNotSoTriviallyUnSat);
	CPPUNIT_TEST(testWeightForwardTrue);
	CPPUNIT_TEST(testWeightForwardFalse);
	CPPUNIT_TEST(testWeightBackwardTrue);
	CPPUNIT_TEST(testWeightBackwardFalse);
	CPPUNIT_TEST(testWeightConflict);

	CPPUNIT_TEST(testCloneWeight);
	CPPUNIT_TEST(testCloneWeightShared);

	CPPUNIT_TEST(testAddOnLevel);
	CPPUNIT_TEST(testCreateSat);
	CPPUNIT_TEST(testCreateSatOnRoot);
	CPPUNIT_TEST(testCreateSatOnRootNoProp);

	CPPUNIT_TEST(testMergeNegativeWeight);
	CPPUNIT_TEST_SUITE_END();
public:
	WeightConstraintTest() {
		body  = posLit(ctx.addVar(Var_t::Body));
		a     = posLit(ctx.addVar(Var_t::Atom));
		b     = posLit(ctx.addVar(Var_t::Atom));
		c     = posLit(ctx.addVar(Var_t::Atom));
		d     = posLit(ctx.addVar(Var_t::Atom));
		e     = posLit(ctx.addVar(Var_t::Atom));
		f     = posLit(ctx.addVar(Var_t::Atom));
		ctx.startAddConstraints(10);
	}
	Solver& solver() { return *ctx.master(); }
	void testAssertTriviallySat() {
		LitVec lits;
		lits.push_back(body);
		lits.push_back(a);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 0));
		CPPUNIT_ASSERT(solver().isTrue(body));
		CPPUNIT_ASSERT(ctx.numConstraints() == 0);
	}
	void testAssertTriviallyUnSat() {
		LitVec lits;
		lits.push_back(body);
		lits.push_back(a);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 2));
		CPPUNIT_ASSERT(solver().isFalse(body));
		CPPUNIT_ASSERT(ctx.numConstraints() == 0);
	}

	void testAssertNotSoTriviallySat() {
		LitVec lits = makeLits();
		solver().force(lits[1], 0);
		solver().force(lits[2], 0);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 2));
		CPPUNIT_ASSERT(solver().isTrue(body));
		CPPUNIT_ASSERT(ctx.numConstraints() == 0);
	}

	void testAssertNotSoTriviallyUnSat() {
		LitVec lits = makeLits();
		solver().force(~lits[1], 0);
		solver().force(~lits[3], 0);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 3));
		CPPUNIT_ASSERT(solver().isTrue(~body));
		CPPUNIT_ASSERT(ctx.numConstraints() == 0);
	}

	void testTrivialBackpropTrue() {
		WeightLitVec lits = makeWeightLits();
		solver().force(body, 0);
		CPPUNIT_ASSERT_EQUAL(true,  newWeightConstraint(ctx, body, lits, 7));
		CPPUNIT_ASSERT(ctx.numConstraints() == 1);
		CPPUNIT_ASSERT(solver().isTrue(a));
		CPPUNIT_ASSERT(solver().isTrue(~b));
		solver().propagate();
		solver().assume(~lits[0].first) && solver().propagate();
		CPPUNIT_ASSERT(solver().isTrue(lits[1].first));
	}

	void testTrivialBackpropFalse() {
		LitVec lits = makeLits();
		solver().force(~body, 0);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 1));
		CPPUNIT_ASSERT(ctx.numConstraints() == 0);
		CPPUNIT_ASSERT(solver().isFalse(lits[1]));
		CPPUNIT_ASSERT(solver().isFalse(lits[2]));
		CPPUNIT_ASSERT(solver().isFalse(lits[3]));
		CPPUNIT_ASSERT(solver().isFalse(lits[4]));
	}

	void testTrivialBackpropFalseWeight() {
		WeightLitVec lits = makeWeightLits();
		solver().force(~body, 0);
		CPPUNIT_ASSERT_EQUAL(true,  newWeightConstraint(ctx, body, lits, 2));
		CPPUNIT_ASSERT(ctx.numConstraints() == 1);
		CPPUNIT_ASSERT(solver().isFalse(a));
		CPPUNIT_ASSERT(solver().isFalse(~b));
	}

	void testForwardTrue() {
		LitVec assume, expected;
		assume.push_back(a);
		assume.push_back(~c);
		expected.push_back(body);
		propCard(assume, expected);
	}

	void testForwardFalse() {
		LitVec assume;
		assume.push_back(~a);
		assume.push_back(c);
		assume.push_back(~d);

		LitVec expect;
		expect.push_back(~body);

		propCard(assume, expect);
	}

	void testBackwardTrue() {
		LitVec assume, expect;
		assume.push_back(body);
		assume.push_back(c);
		assume.push_back(~d);
		expect.push_back(a);
		expect.push_back(~b);
		propCard(assume, expect);

	}

	void testBackwardFalse() {
		LitVec assume, expect;
		assume.push_back(~body);
		assume.push_back(d);
		expect.push_back( ~a );
		expect.push_back( b );
		expect.push_back( c );
		propCard(assume, expect);
	}

	void testForwardTrueConflict() {
		LitVec assume;
		assume.push_back(a);
		assume.push_back(~c);
		propConflictTest(assume, ~body);
	}

	void testForwardFalseConflict() {
		LitVec assume;
		assume.push_back(~a);
		assume.push_back(c);
		assume.push_back(~d);
		propConflictTest(assume, body);

	}

	void testBackwardTrueConflict() {
		LitVec assume;
		assume.push_back(body);
		assume.push_back(c);
		assume.push_back(~d);
		propConflictTest(assume, b);
	}

	void testBackwardFalseConflict() {
		LitVec assume, expect;
		assume.push_back(~body);
		assume.push_back(d);
		propConflictTest(assume, ~b);
	}

	void testReasonBug() {
		LitVec lits = makeLits();
		lits.push_back(~e);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 3));
		LitVec assume, reason;
		assume.push_back(a);
		assume.push_back(~b);
		assume.push_back(~d);
		assume.push_back(e);
		for (uint32 i = 0; i < assume.size(); ++i) {
			CPPUNIT_ASSERT_EQUAL(true, solver().assume(assume[i]));
			CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		}
		CPPUNIT_ASSERT(assume.size() == solver().numAssignedVars());

		// B -> ~c because of: ~d, e, B
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(body));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(~c));
		//CPPUNIT_ASSERT(con == solver().reason(c.var()).constraint());
		solver().reason(~c, reason);
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(3), reason.size());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~d) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), e) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), body) != reason.end());
		solver().undoUntil(solver().decisionLevel()-1);
		reason.clear();

		// ~B -> c because of: a, ~b, ~B
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(~body));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(c));
		// CPPUNIT_ASSERT(con == solver().reason(c.var()).constraint());
		solver().reason(c, reason);
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(3), reason.size());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), a) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~b) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~body) != reason.end());
		solver().undoUntil(solver().decisionLevel()-1);
		reason.clear();

		// ~c -> B because of: a, ~b, ~c
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(~c));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(body));
		//CPPUNIT_ASSERT(con == solver().reason(body.var()).constraint());
		solver().reason(body, reason);
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(3), reason.size());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), a) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~b) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~c) != reason.end());
		solver().undoUntil(solver().decisionLevel()-1);

		// c -> ~B because of: ~d, e, c
		CPPUNIT_ASSERT_EQUAL(true, solver().assume(c));
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(~body));
		//CPPUNIT_ASSERT(con == solver().reason(body.var()).constraint());
		solver().reason(~body, reason);
		CPPUNIT_ASSERT_EQUAL(LitVec::size_type(3), reason.size());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~d) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), e) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), c) != reason.end());
		solver().undoUntil(solver().decisionLevel()-1);
		reason.clear();
	}

	void testWeightReasonAfterBackprop() {
		WeightLitVec lits = makeWeightLits();
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		solver().assume(~body) && solver().propagate();
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(~a));
		solver().assume(d) && solver().propagate();
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(b));
		LitVec r;
		solver().reason(~a, r);
		CPPUNIT_ASSERT(r.size() == 1 && r[0] == ~body);
		solver().reason(b, r);
		CPPUNIT_ASSERT(r.size() == 2 && r[0] == ~body && r[1] == d);
		solver().undoUntil(solver().decisionLevel()-1);
		solver().reason(~a, r);
		CPPUNIT_ASSERT(r.size() == 1 && r[0] == ~body);
		solver().undoUntil(solver().decisionLevel()-1);
	}

	void testOrderBug() {
		LitVec lits;
		lits.push_back(body);
		lits.push_back(a);
		lits.push_back(b);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 1));
		solver().assume(e) && solver().propagate();

		solver().force(~a, 0);
		solver().force(body, 0);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(b));
		LitVec reason;
		solver().reason(b, reason);
		CPPUNIT_ASSERT(LitVec::size_type(2) == reason.size());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), body) != reason.end());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), ~a) != reason.end());

	}

	void testBackwardAfterForward() {
		LitVec lits;
		lits.push_back(body);
		lits.push_back(a);
		lits.push_back(b);
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 1));
		solver().assume(a);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(body));
		LitVec reason;
		solver().reason(body, reason);
		CPPUNIT_ASSERT(LitVec::size_type(1) == reason.size());
		CPPUNIT_ASSERT(std::find(reason.begin(), reason.end(), a) != reason.end());

		solver().assume(~b);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(body));
	}

	void testOnlyBTB() {
		ctx.endInit(true);
		Solver& s = *ctx.master();
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, 1));
		lits.push_back(WeightLiteral(b, 1));
		lits.push_back(WeightLiteral(c, 1));
		lits.push_back(WeightLiteral(d, 1));
		WeightConstraint::CPair res = WeightConstraint::create(s, body, lits, 2, WeightConstraint::create_only_btb);
		CPPUNIT_ASSERT(res.first());
		s.assume(a) && s.propagate();
		s.assume(b) && s.propagate();
		// FTB_BFB not added
		CPPUNIT_ASSERT(s.value(body.var()) == value_free);
		s.undoUntil(0);
		s.assume(~a) && s.propagate();
		s.assume(~b) && s.propagate();
		uint32 dl = s.decisionLevel();
		s.assume(body) && s.propagate();
		CPPUNIT_ASSERT(s.isTrue(c) && s.isTrue(d));
		s.undoUntil(dl);
		s.assume(~c) && s.propagate();
		CPPUNIT_ASSERT(s.isFalse(body));
	}
	void testOnlyBFB() {
		ctx.endInit(true);
		Solver& s = *ctx.master();
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, 1));
		lits.push_back(WeightLiteral(b, 1));
		lits.push_back(WeightLiteral(c, 1));
		lits.push_back(WeightLiteral(d, 1));
		WeightConstraint::CPair res = WeightConstraint::create(s, body, lits, 2, WeightConstraint::create_only_bfb);
		CPPUNIT_ASSERT(res.first());
		s.assume(a) && s.propagate();
		uint32 dl = s.decisionLevel();
		s.assume(b) && s.propagate();
		CPPUNIT_ASSERT(s.isTrue(body));
		s.undoUntil(dl);
		s.assume(~body) && s.propagate();
		CPPUNIT_ASSERT(s.isFalse(b) && s.isFalse(c) && s.isFalse(d));
		s.undoUntil(0);
		s.assume(~a) && s.propagate();
		s.assume(~b) && s.propagate();
		s.assume(~b) && s.propagate();
		CPPUNIT_ASSERT(s.value(body.var()) == value_free);
	}
	void testSimplify() {
		LitVec lits = makeLits();
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 2));
		CPPUNIT_ASSERT_EQUAL(true, solver().simplify());
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numConstraints());
		solver().force(a, 0);
		solver().simplify();
		CPPUNIT_ASSERT_EQUAL(1u, ctx.numConstraints());
		solver().force(~c, 0);
		solver().simplify();
		CPPUNIT_ASSERT_EQUAL(0u, ctx.numConstraints());
	}

	void testSimplifyCardinality() {
		LitVec lits = makeLits();
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 2));
		ctx.addUnary(~a);
		ctx.addUnary(~d);
		ctx.addUnary(~b);
		solver().simplify();
		solver().assume(~c);
		solver().propagate();
		CPPUNIT_ASSERT(solver().isTrue(body));
		LitVec out;
		solver().reason(body, out);
		// a, d, and ~b were removed from constraint
		CPPUNIT_ASSERT(out.size() == 1 && out[0] == ~c);
	}
	void testSimplifyWeight() {
		WeightLitVec lits = makeWeightLits();
		lits[2].second    = 2;
		lits.push_back(WeightLiteral(e, 1));
		lits.push_back(WeightLiteral(f, 1));
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 2));
		ctx.addUnary(body);
		ctx.addUnary(~a);
		ctx.addUnary(~d);
		ctx.addUnary(~e);
		ctx.addUnary(~f);
		solver().simplify();
		CPPUNIT_ASSERT(solver().value(b.var()) == value_free);
		solver().assume(c);
		solver().propagate();
		CPPUNIT_ASSERT(solver().isTrue(~b));
		LitVec out;
		solver().reason(~b, out);
		CPPUNIT_ASSERT(out.size() == 1 && out[0] == c);
	}

	void testSimplifyWatches() {
		LitVec lits = makeLits();
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 2));
		uint32 nw3  = solver().numWatches(lits[3]) + solver().numWatches(~lits[3]);
		solver().pushRoot(body);
		CPPUNIT_ASSERT(nw3 >= solver().numWatches(lits[3]) + solver().numWatches(~lits[3]));
		solver().popRootLevel(1);
		CPPUNIT_ASSERT(nw3 == solver().numWatches(lits[3]) + solver().numWatches(~lits[3]));
	}

	void testAssertWeightTriviallySat() {
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, 2));
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 0));
		CPPUNIT_ASSERT(solver().isTrue(body));
	}
	void testAssertWeightTriviallyUnSat() {
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, 2));
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		CPPUNIT_ASSERT(solver().isFalse(body));
	}

	void testAssertWeightNotSoTriviallySat() {
		WeightLitVec lits = makeWeightLits();
		solver().force(lits[1].first, 0);
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body,lits, 2));
		CPPUNIT_ASSERT(solver().isTrue(body));
	}

	void testAssertWeightNotSoTriviallyUnSat() {
		WeightLitVec lits = makeWeightLits();
		solver().force(~lits[0].first, 0);
		solver().force(~lits[2].first, 0);
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 4));
		CPPUNIT_ASSERT(solver().isTrue(~body));
	}

	void testWeightForwardTrue() {
		LitVec assume, expect;
		assume.push_back(a);
		expect.push_back(body);
		propWeight(assume, expect);

		assume.clear();
		assume.push_back(~b);
		assume.push_back(~c);
		propImpl(assume, expect);

		assume.clear();
		assume.push_back(~b);
		assume.push_back(d);
		propImpl(assume, expect);
	}

	void testWeightForwardFalse() {
		LitVec assume, expect;
		assume.push_back(~a);
		assume.push_back(b);
		expect.push_back(~body);
		propWeight(assume, expect);
	}

	void testWeightBackwardTrue() {
		WeightLitVec lits = makeWeightLits();
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		solver().assume(~a);
		solver().force(body, 0);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(~b));
		CPPUNIT_ASSERT_EQUAL(value_free, solver().value(c.var()));
		LitVec r;
		solver().reason(~b, r);
		CPPUNIT_ASSERT(r.size() == 2);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~a) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), body) != r.end());

		solver().assume(~d);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(~c));

		solver().reason(~c, r);
		CPPUNIT_ASSERT(r.size() == 3);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~a) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), body) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~d) != r.end());

		solver().undoUntil(solver().decisionLevel()-1);
		solver().reason(~b, r);
		CPPUNIT_ASSERT(r.size() == 2);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~a) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), body) != r.end());
	}

	void testWeightBackwardFalse() {
		WeightLitVec lits = makeWeightLits();
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		solver().assume(~body);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(~a));
		LitVec r;
		solver().reason(~a, r);
		CPPUNIT_ASSERT(r.size() == 1);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~body) != r.end());

		solver().force(~b, 0);
		CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(c));
		CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(~d));

		LitVec r2;
		solver().reason(c, r);
		solver().reason(~d, r2);
		CPPUNIT_ASSERT(r == r2);
		CPPUNIT_ASSERT(r.size() == 2);
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~body) != r.end());
		CPPUNIT_ASSERT(std::find(r.begin(), r.end(), ~b) != r.end());
	}

	void testWeightConflict() {
		WeightLitVec lits = makeWeightLits();
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		LitVec assume;
		assume.push_back(body);
		assume.push_back(~a);
		assume.push_back(b);
		std::sort(assume.begin(), assume.end());
		do {
			CPPUNIT_ASSERT_EQUAL(true, solver().assume(assume[0]));
			for (uint32 i = 1; i < assume.size(); ++i) {
				CPPUNIT_ASSERT_EQUAL(true, solver().force(assume[i],0));
			}
			CPPUNIT_ASSERT_EQUAL(false, solver().propagate());
			solver().undoUntil(0);
		} while (std::next_permutation(assume.begin(), assume.end()));
	}

	void testCloneWeight() {
		ctx.setConcurrency(2);
		WeightLitVec lits = makeWeightLits();
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		solver().force(~a, 0);
		Solver& solver2 = ctx.pushSolver();
		ctx.endInit(true);

		CPPUNIT_ASSERT(solver2.numConstraints() == 1);

		CPPUNIT_ASSERT(solver2.numWatches(a) == 0 && solver2.numWatches(~a) == 0);
		solver2.assume(body);
		solver2.propagate();
		solver2.assume(~d);
		solver2.propagate();
		CPPUNIT_ASSERT(solver2.isTrue(~b));
		CPPUNIT_ASSERT(solver2.isTrue(~c));
		LitVec out;
		solver2.reason(~b, out);
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), body) != out.end());
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), ~a) != out.end());
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), ~d) == out.end());
		out.clear();
		solver2.reason(~c, out);
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), ~d) != out.end());
	}

	void testCloneWeightShared() {
		ctx.setConcurrency(2);
		ctx.setShareMode(ContextParams::share_problem);
		WeightLitVec lits = makeWeightLits();
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		solver().force(~a, 0);
		Solver& solver2 = ctx.pushSolver();
		ctx.endInit(true);

		CPPUNIT_ASSERT(solver2.numConstraints() == 1);

		CPPUNIT_ASSERT(solver2.numWatches(a) == 0 && solver2.numWatches(~a) == 0);
		solver2.assume(body);
		solver2.propagate();
		solver2.assume(~d);
		solver2.propagate();
		CPPUNIT_ASSERT(solver2.isTrue(~b));
		CPPUNIT_ASSERT(solver2.isTrue(~c));
		LitVec out;
		solver2.reason(~b, out);
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), body) != out.end());
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), ~a) != out.end());
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), ~d) == out.end());
		out.clear();
		solver2.reason(~c, out);
		CPPUNIT_ASSERT(std::find(out.begin(), out.end(), ~d) != out.end());
	}

	void testAddOnLevel() {
		ctx.endInit(true);
		WeightLitVec lits = makeWeightLits();
		uint32 sz = sizeVec(lits) + 1;
		Solver& s = *ctx.master();
		s.pushRoot(f);
		WeightConstraint::CPair res = WeightConstraint::create(s, body, lits, 2, WeightConstraint::create_no_add);
		CPPUNIT_ASSERT(res.ok() && res.first() != 0);
		CPPUNIT_ASSERT(res.first()->size() == sz && lits.size() == sz-1);
		s.force(body);
		s.force(~lits[0].first);
		s.force(~lits[1].first,0);
		s.propagate();
		CPPUNIT_ASSERT(s.isTrue(lits[2].first) && s.isTrue(lits[3].first));
		res.first()->destroy(&s, true);
	}
	void testCreateSat() {
		ctx.endInit(true);
		WeightLitVec lits = makeWeightLits();
		Solver& s = *ctx.master();

		s.force(lits[0].first);
		s.force(lits[1].first);
		WeightConstraint::CPair res = WeightConstraint::create(s, body, lits, 2, WeightConstraint::create_no_add|WeightConstraint::create_sat);
		CPPUNIT_ASSERT(res.ok() && res.first() != 0);
		CPPUNIT_ASSERT(s.isTrue(body));
		s.propagate();
		CPPUNIT_ASSERT(s.isTrue(body));
		while (!lits.empty()) {
			CPPUNIT_ASSERT(s.force(~lits.back().first) && s.propagate());
			lits.pop_back();
		}
		res.first()->destroy(&s, true);
	}
	void testCreateSatOnRoot() {
		ctx.endInit(true);
		Solver& s = *ctx.master();
		s.pushRoot(f);
		CPPUNIT_ASSERT(s.rootLevel() == 1);
		s.force(a, 0);
		s.force(b, 0);
		s.propagate();
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, 1));
		lits.push_back(WeightLiteral(b, 1));
		lits.push_back(WeightLiteral(c, 1));
		lits.push_back(WeightLiteral(d, 1));
		WeightLitsRep rep           = WeightLitsRep::create(s, lits, 2);
		WeightConstraint::CPair res = WeightConstraint::create(s, body, rep, WeightConstraint::create_no_add|WeightConstraint::create_sat);
		CPPUNIT_ASSERT(res.ok() && res.first());
		CPPUNIT_ASSERT(s.isTrue(body));
		CPPUNIT_ASSERT(s.reason(body) == res.first());
		s.popRootLevel(1);
		CPPUNIT_ASSERT(s.value(body.var()) == value_free);
		res.first()->destroy(&s, true);
	}
	void testCreateSatOnRootNoProp() {
		ctx.endInit(true);
		Solver& s = *ctx.master();
		s.pushRoot(f);
		CPPUNIT_ASSERT(s.rootLevel() == 1);
		s.force(a, 0);
		s.force(b, 0);
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, 1));
		lits.push_back(WeightLiteral(b, 1));
		lits.push_back(WeightLiteral(c, 1));
		lits.push_back(WeightLiteral(d, 1));
		WeightLitsRep rep           = WeightLitsRep::create(s, lits, 2);
		WeightConstraint::CPair res = WeightConstraint::create(s, body, rep, WeightConstraint::create_no_add|WeightConstraint::create_sat);
		CPPUNIT_ASSERT(res.ok() && res.first());
		CPPUNIT_ASSERT(!s.isTrue(body));
		CPPUNIT_ASSERT(s.propagate());
		CPPUNIT_ASSERT(s.isTrue(body));
		CPPUNIT_ASSERT(s.reason(body) == res.first());
		s.popRootLevel(1);
		CPPUNIT_ASSERT(s.value(body.var()) == value_free);
		res.first()->destroy(&s, true);
	}
	void testMergeNegativeWeight() {
		WeightLitVec lits;
		lits.push_back(WeightLiteral(a, -1));
		lits.push_back(WeightLiteral(a, -1));
		lits.push_back(WeightLiteral(b, -2));
		WeightLitsRep rep = WeightLitsRep::create(*ctx.master(), lits, -2);
		CPPUNIT_ASSERT(rep.size == 2);
		CPPUNIT_ASSERT(rep.bound == 1);
		CPPUNIT_ASSERT(rep.reach == 2);
		CPPUNIT_ASSERT(rep.lits[0].second == 1);
		CPPUNIT_ASSERT(rep.lits[1].second == 1);
	}
private:
	static bool newCardinalityConstraint(SharedContext& ctx, const LitVec& lits, int bound) {
		CPPUNIT_ASSERT(lits.size() >  1);
		WeightLitVec wlits;
		for (LitVec::size_type i = 1; i < lits.size(); ++i) {
			wlits.push_back(WeightLiteral(lits[i], 1));
		}
		return newWeightConstraint(ctx, lits[0], wlits, bound);
	}
	static bool newWeightConstraint(SharedContext& ctx, Literal W, WeightLitVec& lits, weight_t bound) {
		return WeightConstraint::create(*ctx.master(), W, lits, bound).ok();
	}
	void propCard(LitVec& assumptions, const LitVec& expected) {
		LitVec lits = makeLits();
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 2));
		propImpl(assumptions, expected);
	}
	void propWeight(LitVec& assume, LitVec& expect) {
		WeightLitVec lits = makeWeightLits();
		CPPUNIT_ASSERT_EQUAL(true, newWeightConstraint(ctx, body, lits, 3));
		propImpl(assume, expect);
	}
	void propImpl(LitVec& assumptions, const LitVec& expected) {
		std::sort(assumptions.begin(), assumptions.end());
		do {
			for (uint32 i = 0; i < assumptions.size(); ++i) {
				CPPUNIT_ASSERT_EQUAL(true, solver().assume(assumptions[i]));
				CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
			}
			for (uint32 i = 0; i < expected.size(); ++i) {
				CPPUNIT_ASSERT_EQUAL(true, solver().isTrue(expected[i]));
				LitVec reason;
				solver().reason(expected[i], reason);
				CPPUNIT_ASSERT_EQUAL(assumptions.size(), reason.size());
				for (uint32 j = 0; j < assumptions.size(); ++j) {
					CPPUNIT_ASSERT(find(reason.begin(), reason.end(), assumptions[j]) != reason.end());
				}

			}
			solver().undoUntil(0);
		} while (std::next_permutation(assumptions.begin(), assumptions.end()));
	}
	void propConflictTest(LitVec& assumptions, Literal cflLit) {
		LitVec lits = makeLits();
		CPPUNIT_ASSERT_EQUAL(true, newCardinalityConstraint(ctx, lits, 2));
		do {
			for (uint32 i = 0; i < assumptions.size()-1; ++i) {
				CPPUNIT_ASSERT_EQUAL(true, solver().assume(assumptions[i]));
				CPPUNIT_ASSERT_EQUAL(true, solver().propagate());
			}
			CPPUNIT_ASSERT_EQUAL(true, solver().assume(assumptions.back()));
			CPPUNIT_ASSERT_EQUAL(true, solver().force(cflLit, 0));
			CPPUNIT_ASSERT_EQUAL(false, solver().propagate());
			LitVec cfl = solver().conflict();
			CPPUNIT_ASSERT_EQUAL(assumptions.size() + 1, cfl.size());
			for (uint32 i = 0; i < assumptions.size(); ++i) {
				CPPUNIT_ASSERT(std::find(cfl.begin(), cfl.end(), assumptions[i]) != cfl.end());
			}
			CPPUNIT_ASSERT(std::find(cfl.begin(), cfl.end(), cflLit) != cfl.end());
			solver().undoUntil(0);
		}while (std::next_permutation(assumptions.begin(), assumptions.end()));
	}

	LitVec makeLits() {
		LitVec res;
		res.push_back(body);
		res.push_back(a);
		res.push_back(~b);
		res.push_back(~c);
		res.push_back(d);
		return res;
	}
	WeightLitVec makeWeightLits() {
		WeightLitVec res;
		res.push_back(WeightLiteral(a, 4));
		res.push_back(WeightLiteral(~b, 2));
		res.push_back(WeightLiteral(~c, 1));
		res.push_back(WeightLiteral(d, 1));
		return res;
	}
	SharedContext ctx;
	Literal body;
	Literal a, b, c, d, e, f;
};
CPPUNIT_TEST_SUITE_REGISTRATION(WeightConstraintTest);
} }
clasp-3.2.2/liblp/000077500000000000000000000000001304134206100137145ustar00rootroot00000000000000clasp-3.2.2/liblp/CMakeLists.txt000066400000000000000000000006021304134206100164520ustar00rootroot00000000000000file(GLOB LIBLP_SRC src/*.cpp)
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
SET(LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/lib)
add_library(lp STATIC ${LIBLP_SRC})
enable_testing ()
add_test (NAME LpTest COMMAND lpTest)
file(GLOB LIBLP_TEST tests/*.cpp)
if(NOT MSVC)
	add_definitions (-std=c++11)
endif()
add_executable (lpTest ${LIBLP_TEST})
target_link_libraries(lpTest lp)

clasp-3.2.2/liblp/Doxyfile000066400000000000000000002250561304134206100154340ustar00rootroot00000000000000# Doxyfile 1.8.1.2

# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project.
#
# All text after a hash (#) is considered a comment and will be ignored.
# The format is:
#       TAG = value [value, ...]
# For lists items can also be appended using:
#       TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ").

#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------

# This tag specifies the encoding used for all characters in the config file
# that follow. The default is UTF-8 which is also the encoding used for all
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
# iconv built into libc) for the transcoding. See
# http://www.gnu.org/software/libiconv for the list of possible encodings.

DOXYFILE_ENCODING      = UTF-8

# The PROJECT_NAME tag is a single word (or sequence of words) that should
# identify the project. Note that if you do not use Doxywizard you need
# to put quotes around the project name if it contains spaces.

PROJECT_NAME           = "liblp"

# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or
# if some version control system is used.

PROJECT_NUMBER         = 

# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer
# a quick idea about the purpose of the project. Keep the description short.

PROJECT_BRIEF          = 

# With the PROJECT_LOGO tag one can specify an logo or icon that is
# included in the documentation. The maximum height of the logo should not
# exceed 55 pixels and the maximum width should not exceed 200 pixels.
# Doxygen will copy the logo to the output directory.

PROJECT_LOGO           =

# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
# If a relative path is entered, it will be relative to the location
# where doxygen was started. If left blank the current directory will be used.

OUTPUT_DIRECTORY       = "doc"

# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
# 4096 sub-directories (in 2 levels) under the output directory of each output
# format and will distribute the generated files over these directories.
# Enabling this option can be useful when feeding doxygen a huge amount of
# source files, where putting all generated files in the same directory would
# otherwise cause performance problems for the file system.

CREATE_SUBDIRS         = NO

# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# The default language is English, other supported languages are:
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.

OUTPUT_LANGUAGE        = English

# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
# include brief member descriptions after the members that are listed in
# the file and class documentation (similar to JavaDoc).
# Set to NO to disable this.

BRIEF_MEMBER_DESC      = YES

# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
# the brief description of a member or function before the detailed description.
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.

REPEAT_BRIEF           = YES

# This tag implements a quasi-intelligent brief description abbreviator
# that is used to form the text in various listings. Each string
# in this list, if found as the leading text of the brief description, will be
# stripped from the text and the result after processing the whole list, is
# used as the annotated text. Otherwise, the brief description is used as-is.
# If left blank, the following values are used ("$name" is automatically
# replaced with the name of the entity): "The $name class" "The $name widget"
# "The $name file" "is" "provides" "specifies" "contains"
# "represents" "a" "an" "the"

ABBREVIATE_BRIEF       =

# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# Doxygen will generate a detailed section even if there is only a brief
# description.

ALWAYS_DETAILED_SEC    = NO

# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
# inherited members of a class in the documentation of that class as if those
# members were ordinary class members. Constructors, destructors and assignment
# operators of the base classes will not be shown.

INLINE_INHERITED_MEMB  = NO

# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
# path before files name in the file list and in the header files. If set
# to NO the shortest path that makes the file name unique will be used.

FULL_PATH_NAMES        = YES

# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
# can be used to strip a user-defined part of the path. Stripping is
# only done if one of the specified strings matches the left-hand part of
# the path. The tag can be used to show relative paths in the file list.
# If left blank the directory from which doxygen is run is used as the
# path to strip.

STRIP_FROM_PATH        = liblp

# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
# the path mentioned in the documentation of a class, which tells
# the reader which header file to include in order to use a class.
# If left blank only the name of the header file containing the class
# definition is used. Otherwise one should specify the include paths that
# are normally passed to the compiler using the -I flag.

STRIP_FROM_INC_PATH    =

# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
# (but less readable) file names. This can be useful if your file system
# doesn't support long names like on DOS, Mac, or CD-ROM.

SHORT_NAMES            = NO

# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
# will interpret the first line (until the first dot) of a JavaDoc-style
# comment as the brief description. If set to NO, the JavaDoc
# comments will behave just like regular Qt-style comments
# (thus requiring an explicit @brief command for a brief description.)

JAVADOC_AUTOBRIEF      = YES

# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
# interpret the first line (until the first dot) of a Qt-style
# comment as the brief description. If set to NO, the comments
# will behave just like regular Qt-style comments (thus requiring
# an explicit \brief command for a brief description.)

QT_AUTOBRIEF           = NO

# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
# comments) as a brief description. This used to be the default behaviour.
# The new default is to treat a multi-line C++ comment block as a detailed
# description. Set this tag to YES if you prefer the old behaviour instead.

MULTILINE_CPP_IS_BRIEF = NO

# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# re-implements.

INHERIT_DOCS           = YES

# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
# a new page for each member. If set to NO, the documentation of a member will
# be part of the file/class/namespace that contains it.

SEPARATE_MEMBER_PAGES  = NO

# The TAB_SIZE tag can be used to set the number of spaces in a tab.
# Doxygen uses this value to replace tabs by spaces in code fragments.

TAB_SIZE               = 8

# This tag can be used to specify a number of aliases that acts
# as commands in the documentation. An alias has the form "name=value".
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
# put the command \sideeffect (or @sideeffect) in the documentation, which
# will result in a user-defined paragraph with heading "Side Effects:".
# You can put \n's in the value part of an alias to insert newlines.

ALIASES                =

# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding
# "class=itcl::class" will allow you to use the command class in the
# itcl::class meaning.

TCL_SUBST              =

# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
# sources only. Doxygen will then generate output that is more tailored for C.
# For instance, some of the names that are used will be different. The list
# of all members will be omitted, etc.

OPTIMIZE_OUTPUT_FOR_C  = NO

# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
# sources only. Doxygen will then generate output that is more tailored for
# Java. For instance, namespaces will be presented as packages, qualified
# scopes will look different, etc.

OPTIMIZE_OUTPUT_JAVA   = NO

# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources only. Doxygen will then generate output that is more tailored for
# Fortran.

OPTIMIZE_FOR_FORTRAN   = NO

# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
# sources. Doxygen will then generate output that is tailored for
# VHDL.

OPTIMIZE_OUTPUT_VHDL   = NO

# Doxygen selects the parser to use depending on the extension of the files it
# parses. With this tag you can assign which parser to use for a given extension.
# Doxygen has a built-in mapping, but you can override or extend it using this
# tag. The format is ext=language, where ext is a file extension, and language
# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.

EXTENSION_MAPPING      =

# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
# comments according to the Markdown format, which allows for more readable
# documentation. See http://daringfireball.net/projects/markdown/ for details.
# The output of markdown processing is further processed by doxygen, so you
# can mix doxygen, HTML, and XML commands with Markdown formatting.
# Disable only in case of backward compatibilities issues.

MARKDOWN_SUPPORT       = YES

# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
# to include (a tag file for) the STL sources as input, then you should
# set this tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
# func(std::string) {}). This also makes the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.

BUILTIN_STL_SUPPORT    = YES

# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.

CPP_CLI_SUPPORT        = NO

# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
# Doxygen will parse them like normal C++ but will assume all classes use public
# instead of private inheritance when no explicit protection keyword is present.

SIP_SUPPORT            = NO

# For Microsoft's IDL there are propget and propput attributes to indicate getter
# and setter methods for a property. Setting this option to YES (the default)
# will make doxygen replace the get and set methods by a property in the
# documentation. This will only work if the methods are indeed getting or
# setting a simple type. If this is not the case, or you want to show the
# methods anyway, you should set this option to NO.

IDL_PROPERTY_SUPPORT   = YES

# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.

DISTRIBUTE_GROUP_DOC   = NO

# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
# the same type (for instance a group of public functions) to be put as a
# subgroup of that type (e.g. under the Public Functions section). Set it to
# NO to prevent subgrouping. Alternatively, this can be done per class using
# the \nosubgrouping command.

SUBGROUPING            = YES

# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
# unions are shown inside the group in which they are included (e.g. using
# @ingroup) instead of on a separate page (for HTML and Man pages) or
# section (for LaTeX and RTF).

INLINE_GROUPED_CLASSES = NO

# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
# unions with only public data fields will be shown inline in the documentation
# of the scope in which they are defined (i.e. file, namespace, or group
# documentation), provided this scope is documented. If set to NO (the default),
# structs, classes, and unions are shown on a separate page (for HTML and Man
# pages) or section (for LaTeX and RTF).

INLINE_SIMPLE_STRUCTS  = NO

# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
# is documented as struct, union, or enum with the name of the typedef. So
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
# with name TypeT. When disabled the typedef will appear as a member of a file,
# namespace, or class. And the struct will be named TypeS. This can typically
# be useful for C code in case the coding convention dictates that all compound
# types are typedef'ed and only the typedef is referenced, never the tag name.

TYPEDEF_HIDES_STRUCT   = NO

# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penalty.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will roughly double the
# memory usage. The cache size is given by this formula:
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols.

SYMBOL_CACHE_SIZE      = 0

# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
# their name and scope. Since this can be an expensive process and often the
# same symbol appear multiple times in the code, doxygen keeps a cache of
# pre-resolved symbols. If the cache is too small doxygen will become slower.
# If the cache is too large, memory is wasted. The cache size is given by this
# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols.

LOOKUP_CACHE_SIZE      = 0

#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------

# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
# documentation are documented, even if no documentation was available.
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES

EXTRACT_ALL            = NO

# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.

EXTRACT_PRIVATE        = NO

# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal scope will be included in the documentation.

EXTRACT_PACKAGE        = NO

# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.

EXTRACT_STATIC         = NO

# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
# defined locally in source files will be included in the documentation.
# If set to NO only classes defined in header files are included.

EXTRACT_LOCAL_CLASSES  = YES

# This flag is only useful for Objective-C code. When set to YES local
# methods, which are defined in the implementation section but not in
# the interface are included in the documentation.
# If set to NO (the default) only methods in the interface are included.

EXTRACT_LOCAL_METHODS  = NO

# If this flag is set to YES, the members of anonymous namespaces will be
# extracted and appear in the documentation as a namespace called
# 'anonymous_namespace{file}', where file will be replaced with the base
# name of the file that contains the anonymous namespace. By default
# anonymous namespaces are hidden.

EXTRACT_ANON_NSPACES   = NO

# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
# undocumented members of documented classes, files or namespaces.
# If set to NO (the default) these members will be included in the
# various overviews, but no documentation section is generated.
# This option has no effect if EXTRACT_ALL is enabled.

HIDE_UNDOC_MEMBERS     = NO

# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy.
# If set to NO (the default) these classes will be included in the various
# overviews. This option has no effect if EXTRACT_ALL is enabled.

HIDE_UNDOC_CLASSES     = NO

# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
# friend (class|struct|union) declarations.
# If set to NO (the default) these declarations will be included in the
# documentation.

HIDE_FRIEND_COMPOUNDS  = NO

# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
# documentation blocks found inside the body of a function.
# If set to NO (the default) these blocks will be appended to the
# function's detailed documentation block.

HIDE_IN_BODY_DOCS      = NO

# The INTERNAL_DOCS tag determines if documentation
# that is typed after a \internal command is included. If the tag is set
# to NO (the default) then the documentation will be excluded.
# Set it to YES to include the internal documentation.

INTERNAL_DOCS          = NO

# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
# file names in lower-case letters. If set to YES upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# and Mac users are advised to set this option to NO.

CASE_SENSE_NAMES       = YES

# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
# will show members with their full class and namespace scopes in the
# documentation. If set to YES the scope will be hidden.

HIDE_SCOPE_NAMES       = NO

# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
# will put a list of the files that are included by a file in the documentation
# of that file.

SHOW_INCLUDE_FILES     = YES

# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
# will list include files with double quotes in the documentation
# rather than with sharp brackets.

FORCE_LOCAL_INCLUDES   = NO

# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
# is inserted in the documentation for inline members.

INLINE_INFO            = YES

# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
# will sort the (detailed) documentation of file and class members
# alphabetically by member name. If set to NO the members will appear in
# declaration order.

SORT_MEMBER_DOCS       = YES

# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
# brief documentation of file, namespace and class members alphabetically
# by member name. If set to NO (the default) the members will appear in
# declaration order.

SORT_BRIEF_DOCS        = NO

# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
# will sort the (brief and detailed) documentation of class members so that
# constructors and destructors are listed first. If set to NO (the default)
# the constructors will appear in the respective orders defined by
# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.

SORT_MEMBERS_CTORS_1ST = NO

# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
# hierarchy of group names into alphabetical order. If set to NO (the default)
# the group names will appear in their defined order.

SORT_GROUP_NAMES       = NO

# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
# sorted by fully-qualified names, including namespaces. If set to
# NO (the default), the class list will be sorted only by class name,
# not including the namespace part.
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
# Note: This option applies only to the class list, not to the
# alphabetical list.

SORT_BY_SCOPE_NAME     = NO

# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
# do proper type resolution of all parameters of a function it will reject a
# match between the prototype and the implementation of a member function even
# if there is only one candidate or it is obvious which candidate to choose
# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
# will still accept a match between prototype and implementation in such cases.

STRICT_PROTO_MATCHING  = NO

# The GENERATE_TODOLIST tag can be used to enable (YES) or
# disable (NO) the todo list. This list is created by putting \todo
# commands in the documentation.

GENERATE_TODOLIST      = YES

# The GENERATE_TESTLIST tag can be used to enable (YES) or
# disable (NO) the test list. This list is created by putting \test
# commands in the documentation.

GENERATE_TESTLIST      = YES

# The GENERATE_BUGLIST tag can be used to enable (YES) or
# disable (NO) the bug list. This list is created by putting \bug
# commands in the documentation.

GENERATE_BUGLIST       = YES

# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
# disable (NO) the deprecated list. This list is created by putting
# \deprecated commands in the documentation.

GENERATE_DEPRECATEDLIST= YES

# The ENABLED_SECTIONS tag can be used to enable conditional
# documentation sections, marked by \if sectionname ... \endif.

ENABLED_SECTIONS       =

# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
# the initial value of a variable or macro consists of for it to appear in
# the documentation. If the initializer consists of more lines than specified
# here it will be hidden. Use a value of 0 to hide initializers completely.
# The appearance of the initializer of individual variables and macros in the
# documentation can be controlled using \showinitializer or \hideinitializer
# command in the documentation regardless of this setting.

MAX_INITIALIZER_LINES  = 30

# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
# at the bottom of the documentation of classes and structs. If set to YES the
# list will mention the files that were used to generate the documentation.

SHOW_USED_FILES        = YES

# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
# This will remove the Files entry from the Quick Index and from the
# Folder Tree View (if specified). The default is YES.

SHOW_FILES             = YES

# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
# Namespaces page.
# This will remove the Namespaces entry from the Quick Index
# and from the Folder Tree View (if specified). The default is YES.

SHOW_NAMESPACES        = YES

# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
# popen()) the command  , where  is the value of
# the FILE_VERSION_FILTER tag, and  is the name of an input file
# provided by doxygen. Whatever the program writes to standard output
# is used as the file version. See the manual for examples.

FILE_VERSION_FILTER    =

# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
# by doxygen. The layout file controls the global structure of the generated
# output files in an output format independent way. To create the layout file
# that represents doxygen's defaults, run doxygen with the -l option.
# You can optionally specify a file name after the option, if omitted
# DoxygenLayout.xml will be used as the name of the layout file.

LAYOUT_FILE            =

# The CITE_BIB_FILES tag can be used to specify one or more bib files
# containing the references data. This must be a list of .bib files. The
# .bib extension is automatically appended if omitted. Using this command
# requires the bibtex tool to be installed. See also
# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
# feature you need bibtex and perl available in the search path.

CITE_BIB_FILES         =

#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------

# The QUIET tag can be used to turn on/off the messages that are generated
# by doxygen. Possible values are YES and NO. If left blank NO is used.

QUIET                  = NO

# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated by doxygen. Possible values are YES and NO. If left blank
# NO is used.

WARNINGS               = YES

# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
# automatically be disabled.

WARN_IF_UNDOCUMENTED   = YES

# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some
# parameters in a documented function, or documenting parameters that
# don't exist or using markup commands wrongly.

WARN_IF_DOC_ERROR      = YES

# The WARN_NO_PARAMDOC option can be enabled to get warnings for
# functions that are documented, but have no documentation for their parameters
# or return value. If set to NO (the default) doxygen will only warn about
# wrong or incomplete parameter documentation, but not about the absence of
# documentation.

WARN_NO_PARAMDOC       = NO

# The WARN_FORMAT tag determines the format of the warning messages that
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text. Optionally the format may contain
# $version, which will be replaced by the version of the file (if it could
# be obtained via FILE_VERSION_FILTER)

WARN_FORMAT            = "$file:$line: $text"

# The WARN_LOGFILE tag can be used to specify a file to which warning
# and error messages should be written. If left blank the output is written
# to stderr.

WARN_LOGFILE           =

#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------

# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.

INPUT                  = potassco

# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
# also the default input encoding. Doxygen uses libiconv (or the iconv built
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
# the list of possible encodings.

INPUT_ENCODING         = UTF-8

# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank the following patterns are tested:
# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
# *.f90 *.f *.for *.vhd *.vhdl

FILE_PATTERNS          =

# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
# If left blank NO is used.

RECURSIVE              = NO

# The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
# Note that relative paths are relative to the directory from which doxygen is
# run.

EXCLUDE                =

# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.

EXCLUDE_SYMLINKS       = NO

# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*

EXCLUDE_PATTERNS       =

# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test

EXCLUDE_SYMBOLS        =

# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see
# the \include command).

EXAMPLE_PATH           =

# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.

EXAMPLE_PATTERNS       =

# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude
# commands irrespective of the value of the RECURSIVE tag.
# Possible values are YES and NO. If left blank NO is used.

EXAMPLE_RECURSIVE      = NO

# The IMAGE_PATH tag can be used to specify one or more files or
# directories that contain image that are included in the documentation (see
# the \image command).

IMAGE_PATH             =

# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command  , where 
# is the value of the INPUT_FILTER tag, and  is the name of an
# input file. Doxygen will then use the output that the filter program writes
# to standard output.
# If FILTER_PATTERNS is specified, this tag will be
# ignored.

INPUT_FILTER           =

# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis.
# Doxygen will compare the file name with each pattern and apply the
# filter if there is a match.
# The filters are a list of the form:
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
# info on how filters are used. If FILTER_PATTERNS is empty or if
# non of the patterns match the file name, INPUT_FILTER is applied.

FILTER_PATTERNS        =

# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will be used to filter the input files when producing source
# files to browse (i.e. when SOURCE_BROWSER is set to YES).

FILTER_SOURCE_FILES    = NO

# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
# and it is also possible to disable source filtering for a specific pattern
# using *.ext= (so without naming a filter). This option only has effect when
# FILTER_SOURCE_FILES is enabled.

FILTER_SOURCE_PATTERNS =

#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------

# If the SOURCE_BROWSER tag is set to YES then a list of source files will
# be generated. Documented entities will be cross-referenced with these sources.
# Note: To get rid of all source code in the generated output, make sure also
# VERBATIM_HEADERS is set to NO.

SOURCE_BROWSER         = NO

# Setting the INLINE_SOURCES tag to YES will include the body
# of functions and classes directly in the documentation.

INLINE_SOURCES         = NO

# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
# doxygen to hide any special comment blocks from generated source code
# fragments. Normal C, C++ and Fortran comments will always remain visible.

STRIP_CODE_COMMENTS    = YES

# If the REFERENCED_BY_RELATION tag is set to YES
# then for each documented function all documented
# functions referencing it will be listed.

REFERENCED_BY_RELATION = NO

# If the REFERENCES_RELATION tag is set to YES
# then for each documented function all documented entities
# called/used by that function will be listed.

REFERENCES_RELATION    = NO

# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
# link to the source code.
# Otherwise they will link to the documentation.

REFERENCES_LINK_SOURCE = YES

# If the USE_HTAGS tag is set to YES then the references to source code
# will point to the HTML generated by the htags(1) tool instead of doxygen
# built-in source browser. The htags tool is part of GNU's global source
# tagging system (see http://www.gnu.org/software/global/global.html). You
# will need version 4.8.6 or higher.

USE_HTAGS              = NO

# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
# will generate a verbatim copy of the header file for each class for
# which an include is specified. Set to NO to disable this.

VERBATIM_HEADERS       = YES

#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------

# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.

ALPHABETICAL_INDEX     = YES

# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])

COLS_IN_ALPHA_INDEX    = 5

# In case all classes in a project start with a common prefix, all
# classes will be put under the same header in the alphabetical index.
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
# should be ignored while generating the index headers.

IGNORE_PREFIX          =

#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------

# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
# generate HTML output.

GENERATE_HTML          = YES

# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `html' will be used as the default path.

HTML_OUTPUT            = html

# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
# doxygen will generate files with .html extension.

HTML_FILE_EXTENSION    = .html

# The HTML_HEADER tag can be used to specify a personal HTML header for
# each generated HTML page. If it is left blank doxygen will generate a
# standard header. Note that when using a custom header you are responsible
#  for the proper inclusion of any scripts and style sheets that doxygen
# needs, which is dependent on the configuration options used.
# It is advised to generate a default header using "doxygen -w html
# header.html footer.html stylesheet.css YourConfigFile" and then modify
# that header. Note that the header is subject to change so you typically
# have to redo this when upgrading to a newer version of doxygen or when
# changing the value of configuration settings such as GENERATE_TREEVIEW!

HTML_HEADER            =

# The HTML_FOOTER tag can be used to specify a personal HTML footer for
# each generated HTML page. If it is left blank doxygen will generate a
# standard footer.

HTML_FOOTER            =

# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
# style sheet that is used by each HTML page. It can be used to
# fine-tune the look of the HTML output. If the tag is left blank doxygen
# will generate a default style sheet. Note that doxygen will try to copy
# the style sheet file to the HTML output directory, so don't put your own
# style sheet in the HTML output directory as well, or it will be erased!

HTML_STYLESHEET        =

# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
# files. In the HTML_STYLESHEET file, use the file name only. Also note that
# the files will be copied as-is; there are no commands or markers available.

HTML_EXTRA_FILES       =

# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
# Doxygen will adjust the colors in the style sheet and background images
# according to this color. Hue is specified as an angle on a colorwheel,
# see http://en.wikipedia.org/wiki/Hue for more information.
# For instance the value 0 represents red, 60 is yellow, 120 is green,
# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
# The allowed range is 0 to 359.

HTML_COLORSTYLE_HUE    = 220

# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
# the colors in the HTML output. For a value of 0 the output will use
# grayscales only. A value of 255 will produce the most vivid colors.

HTML_COLORSTYLE_SAT    = 100

# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
# the luminance component of the colors in the HTML output. Values below
# 100 gradually make the output lighter, whereas values above 100 make
# the output darker. The value divided by 100 is the actual gamma applied,
# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
# and 100 does not change the gamma.

HTML_COLORSTYLE_GAMMA  = 80

# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
# page will contain the date and time when the page was generated. Setting
# this to NO can help when comparing the output of multiple runs.

HTML_TIMESTAMP         = YES

# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded.

HTML_DYNAMIC_SECTIONS  = NO

# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
# entries shown in the various tree structured indices initially; the user
# can expand and collapse entries dynamically later on. Doxygen will expand
# the tree to such a level that at most the specified number of entries are
# visible (unless a fully collapsed tree already exceeds this amount).
# So setting the number of entries 1 will produce a full collapsed tree by
# default. 0 is a special value representing an infinite number of entries
# and will result in a full expanded tree by default.

HTML_INDEX_NUM_ENTRIES = 100

# If the GENERATE_DOCSET tag is set to YES, additional index files
# will be generated that can be used as input for Apple's Xcode 3
# integrated development environment, introduced with OSX 10.5 (Leopard).
# To create a documentation set, doxygen will generate a Makefile in the
# HTML output directory. Running make will produce the docset in that
# directory and running "make install" will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
# it at startup.
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
# for more information.

GENERATE_DOCSET        = NO

# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
# feed. A documentation feed provides an umbrella under which multiple
# documentation sets from a single provider (such as a company or product suite)
# can be grouped.

DOCSET_FEEDNAME        = "Doxygen generated docs"

# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
# should uniquely identify the documentation set bundle. This should be a
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
# will append .docset to the name.

DOCSET_BUNDLE_ID       = org.doxygen.Project

# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
# the documentation publisher. This should be a reverse domain-name style
# string, e.g. com.mycompany.MyDocSet.documentation.

DOCSET_PUBLISHER_ID    = org.doxygen.Publisher

# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.

DOCSET_PUBLISHER_NAME  = Publisher

# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
# of the generated HTML documentation.

GENERATE_HTMLHELP      = NO

# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
# be used to specify the file name of the resulting .chm file. You
# can add a path in front of the file if the result should not be
# written to the html output directory.

CHM_FILE               =

# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
# be used to specify the location (absolute path including file name) of
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
# the HTML help compiler on the generated index.hhp.

HHC_LOCATION           =

# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
# controls if a separate .chi index file is generated (YES) or that
# it should be included in the master .chm file (NO).

GENERATE_CHI           = NO

# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
# content.

CHM_INDEX_ENCODING     =

# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
# controls whether a binary table of contents is generated (YES) or a
# normal table of contents (NO) in the .chm file.

BINARY_TOC             = NO

# The TOC_EXPAND flag can be set to YES to add extra items for group members
# to the contents of the HTML help documentation and to the tree view.

TOC_EXPAND             = NO

# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
# that can be used as input for Qt's qhelpgenerator to generate a
# Qt Compressed Help (.qch) of the generated HTML documentation.

GENERATE_QHP           = NO

# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
# be used to specify the file name of the resulting .qch file.
# The path specified is relative to the HTML output folder.

QCH_FILE               =

# The QHP_NAMESPACE tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#namespace

QHP_NAMESPACE          = org.doxygen.Project

# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#virtual-folders

QHP_VIRTUAL_FOLDER     = doc

# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
# add. For more information please see
# http://doc.trolltech.com/qthelpproject.html#custom-filters

QHP_CUST_FILTER_NAME   =

# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see
# 
# Qt Help Project / Custom Filters.

QHP_CUST_FILTER_ATTRS  =

# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's
# filter section matches.
# 
# Qt Help Project / Filter Attributes.

QHP_SECT_FILTER_ATTRS  =

# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
# be used to specify the location of Qt's qhelpgenerator.
# If non-empty doxygen will try to run qhelpgenerator on the generated
# .qhp file.

QHG_LOCATION           =

# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
#  will be generated, which together with the HTML files, form an Eclipse help
# plugin. To install this plugin and make it available under the help contents
# menu in Eclipse, the contents of the directory containing the HTML and XML
# files needs to be copied into the plugins directory of eclipse. The name of
# the directory within the plugins directory should be the same as
# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
# the help appears.

GENERATE_ECLIPSEHELP   = NO

# A unique identifier for the eclipse help plugin. When installing the plugin
# the directory name containing the HTML and XML files should also have
# this name.

ECLIPSE_DOC_ID         = org.doxygen.Project

# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
# at top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it. Since the tabs have the same information as the
# navigation tree you can set this option to NO if you already set
# GENERATE_TREEVIEW to YES.

DISABLE_INDEX          = NO

# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information.
# If the tag value is set to YES, a side panel will be generated
# containing a tree-like index structure (just like the one that
# is generated for HTML Help). For this to work a browser that supports
# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
# Windows users are probably better off using the HTML help feature.
# Since the tree basically has the same information as the tab index you
# could consider to set DISABLE_INDEX to NO when enabling this option.

GENERATE_TREEVIEW      = NO

# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
# (range [0,1..20]) that doxygen will group on one line in the generated HTML
# documentation. Note that a value of 0 will completely suppress the enum
# values from appearing in the overview section.

ENUM_VALUES_PER_LINE   = 4

# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
# used to set the initial width (in pixels) of the frame in which the tree
# is shown.

TREEVIEW_WIDTH         = 250

# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
# links to external symbols imported via tag files in a separate window.

EXT_LINKS_IN_WINDOW    = NO

# Use this tag to change the font size of Latex formulas included
# as images in the HTML documentation. The default is 10. Note that
# when you change the font size after a successful doxygen run you need
# to manually remove any form_*.png images from the HTML output directory
# to force them to be regenerated.

FORMULA_FONTSIZE       = 10

# Use the FORMULA_TRANPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are
# not supported properly for IE 6.0, but are supported on all modern browsers.
# Note that when changing this option you need to delete any form_*.png files
# in the HTML output before the changes have effect.

FORMULA_TRANSPARENT    = YES

# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
# (see http://www.mathjax.org) which uses client side Javascript for the
# rendering instead of using prerendered bitmaps. Use this if you do not
# have LaTeX installed or if you want to formulas look prettier in the HTML
# output. When enabled you may also need to install MathJax separately and
# configure the path to it using the MATHJAX_RELPATH option.

USE_MATHJAX            = NO

# When MathJax is enabled you need to specify the location relative to the
# HTML output directory using the MATHJAX_RELPATH option. The destination
# directory should contain the MathJax.js script. For instance, if the mathjax
# directory is located at the same level as the HTML output directory, then
# MATHJAX_RELPATH should be ../mathjax. The default value points to
# the MathJax Content Delivery Network so you can quickly see the result without
# installing MathJax.
# However, it is strongly recommended to install a local
# copy of MathJax from http://www.mathjax.org before deployment.

MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest

# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
# names that should be enabled during MathJax rendering.

MATHJAX_EXTENSIONS     =

# When the SEARCHENGINE tag is enabled doxygen will generate a search box
# for the HTML output. The underlying search engine uses javascript
# and DHTML and should work on any modern browser. Note that when using
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
# (GENERATE_DOCSET) there is already a search function so this one should
# typically be disabled. For large projects the javascript based search engine
# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.

SEARCHENGINE           = YES

# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a PHP enabled web server instead of at the web client
# using Javascript. Doxygen will generate the search PHP script and index
# file to put on the web server. The advantage of the server
# based approach is that it scales better to large projects and allows
# full text search. The disadvantages are that it is more difficult to setup
# and does not have live searching capabilities.

SERVER_BASED_SEARCH    = NO

#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------

# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
# generate Latex output.

GENERATE_LATEX         = NO

# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `latex' will be used as the default path.

LATEX_OUTPUT           = latex

# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked. If left blank `latex' will be used as the default command name.
# Note that when enabling USE_PDFLATEX this option is only used for
# generating bitmaps for formulas in the HTML output, but not in the
# Makefile that is written to the output directory.

LATEX_CMD_NAME         = latex

# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
# generate index for LaTeX. If left blank `makeindex' will be used as the
# default command name.

MAKEINDEX_CMD_NAME     = makeindex

# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
# LaTeX documents. This may be useful for small projects and may help to
# save some trees in general.

COMPACT_LATEX          = NO

# The PAPER_TYPE tag can be used to set the paper type that is used
# by the printer. Possible values are: a4, letter, legal and
# executive. If left blank a4wide will be used.

PAPER_TYPE             = a4

# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
# packages that should be included in the LaTeX output.

EXTRA_PACKAGES         =

# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
# the generated latex document. The header should contain everything until
# the first chapter. If it is left blank doxygen will generate a
# standard header. Notice: only use this tag if you know what you are doing!

LATEX_HEADER           =

# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
# the generated latex document. The footer should contain everything after
# the last chapter. If it is left blank doxygen will generate a
# standard footer. Notice: only use this tag if you know what you are doing!

LATEX_FOOTER           =

# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
# contain links (just like the HTML output) instead of page references
# This makes the output suitable for online browsing using a pdf viewer.

PDF_HYPERLINKS         = YES

# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
# plain latex in the generated Makefile. Set this option to YES to get a
# higher quality PDF documentation.

USE_PDFLATEX           = YES

# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
# command to the generated LaTeX files. This will instruct LaTeX to keep
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.

LATEX_BATCHMODE        = NO

# If LATEX_HIDE_INDICES is set to YES then doxygen will not
# include the index chapters (such as File Index, Compound Index, etc.)
# in the output.

LATEX_HIDE_INDICES     = NO

# If LATEX_SOURCE_CODE is set to YES then doxygen will include
# source code with syntax highlighting in the LaTeX output.
# Note that which sources are shown also depends on other settings
# such as SOURCE_BROWSER.

LATEX_SOURCE_CODE      = NO

# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
# http://en.wikipedia.org/wiki/BibTeX for more info.

LATEX_BIB_STYLE        = plain

#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------

# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
# The RTF output is optimized for Word 97 and may not look very pretty with
# other RTF readers or editors.

GENERATE_RTF           = NO

# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `rtf' will be used as the default path.

RTF_OUTPUT             = rtf

# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
# RTF documents. This may be useful for small projects and may help to
# save some trees in general.

COMPACT_RTF            = NO

# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
# will contain hyperlink fields. The RTF file will
# contain links (just like the HTML output) instead of page references.
# This makes the output suitable for online browsing using WORD or other
# programs which support those fields.
# Note: wordpad (write) and others do not support links.

RTF_HYPERLINKS         = NO

# Load style sheet definitions from file. Syntax is similar to doxygen's
# config file, i.e. a series of assignments. You only have to provide
# replacements, missing definitions are set to their default value.

RTF_STYLESHEET_FILE    =

# Set optional variables used in the generation of an rtf document.
# Syntax is similar to doxygen's config file.

RTF_EXTENSIONS_FILE    =

#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------

# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
# generate man pages

GENERATE_MAN           = NO

# The MAN_OUTPUT tag is used to specify where the man pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `man' will be used as the default path.

MAN_OUTPUT             = man

# The MAN_EXTENSION tag determines the extension that is added to
# the generated man pages (default is the subroutine's section .3)

MAN_EXTENSION          = .3

# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
# then it will generate one additional man file for each entity
# documented in the real man page(s). These additional files
# only source the real man page, but without them the man command
# would be unable to find the correct page. The default is NO.

MAN_LINKS              = NO

#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------

# If the GENERATE_XML tag is set to YES Doxygen will
# generate an XML file that captures the structure of
# the code including all documentation.

GENERATE_XML           = NO

# The XML_OUTPUT tag is used to specify where the XML pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `xml' will be used as the default path.

XML_OUTPUT             = xml

# The XML_SCHEMA tag can be used to specify an XML schema,
# which can be used by a validating XML parser to check the
# syntax of the XML files.

XML_SCHEMA             =

# The XML_DTD tag can be used to specify an XML DTD,
# which can be used by a validating XML parser to check the
# syntax of the XML files.

XML_DTD                =

# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
# dump the program listings (including syntax highlighting
# and cross-referencing information) to the XML output. Note that
# enabling this will significantly increase the size of the XML output.

XML_PROGRAMLISTING     = YES

#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------

# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
# generate an AutoGen Definitions (see autogen.sf.net) file
# that captures the structure of the code including all
# documentation. Note that this feature is still experimental
# and incomplete at the moment.

GENERATE_AUTOGEN_DEF   = NO

#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------

# If the GENERATE_PERLMOD tag is set to YES Doxygen will
# generate a Perl module file that captures the structure of
# the code including all documentation. Note that this
# feature is still experimental and incomplete at the
# moment.

GENERATE_PERLMOD       = NO

# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
# to generate PDF and DVI output from the Perl module output.

PERLMOD_LATEX          = NO

# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
# nicely formatted so it can be parsed by a human reader.
# This is useful
# if you want to understand what is going on.
# On the other hand, if this
# tag is set to NO the size of the Perl module output will be much smaller
# and Perl will parse it just the same.

PERLMOD_PRETTY         = YES

# The names of the make variables in the generated doxyrules.make file
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
# This is useful so different doxyrules.make files included by the same
# Makefile don't overwrite each other's variables.

PERLMOD_MAKEVAR_PREFIX =

#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------

# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
# evaluate all C-preprocessor directives found in the sources and include
# files.

ENABLE_PREPROCESSING   = YES

# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
# names in the source code. If set to NO (the default) only conditional
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.

MACRO_EXPANSION        = NO

# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_DEFINED tags.

EXPAND_ONLY_PREDEF     = NO

# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# pointed to by INCLUDE_PATH will be searched when a #include is found.

SEARCH_INCLUDES        = YES

# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by
# the preprocessor.

INCLUDE_PATH           =

# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will
# be used.

INCLUDE_FILE_PATTERNS  =

# The PREDEFINED tag can be used to specify one or more macro names that
# are defined before the preprocessor is started (similar to the -D option of
# gcc). The argument of the tag is a list of macros of the form: name
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed. To prevent a macro definition from being
# undefined via #undef or recursively expanded use the := operator
# instead of the = operator.

PREDEFINED             =

# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition that
# overrules the definition found in the source code.

EXPAND_AS_DEFINED      =

# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all references to function-like macros
# that are alone on a line, have an all uppercase name, and do not end with a
# semicolon, because these will confuse the parser if not removed.

SKIP_FUNCTION_MACROS   = YES

#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------

# The TAGFILES option can be used to specify one or more tagfiles. For each
# tag file the location of the external documentation should be added. The
# format of a tag file without this location is as follows:
#
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
#
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where "loc1" and "loc2" can be relative or absolute paths
# or URLs. Note that each tag file must have a unique name (where the name does
# NOT include the path). If a tag file is not located in the directory in which
# doxygen is run, you must also specify the path to the tagfile here.

TAGFILES               =

# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.

GENERATE_TAGFILE       =

# If the ALLEXTERNALS tag is set to YES all external classes will be listed
# in the class index. If set to NO only the inherited external classes
# will be listed.

ALLEXTERNALS           = NO

# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will
# be listed.

EXTERNAL_GROUPS        = YES

# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of `which perl').

PERL_PATH              = /usr/bin/perl

#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------

# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
# or super classes. Setting the tag to NO turns the diagrams off. Note that
# this option also works with HAVE_DOT disabled, but it is recommended to
# install and use dot, since it yields more powerful graphs.

CLASS_DIAGRAMS         = YES

# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.

MSCGEN_PATH            =

# If set to YES, the inheritance and collaboration graphs will hide
# inheritance and usage relations if the target is undocumented
# or is not a class.

HIDE_UNDOC_RELATIONS   = YES

# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz, a graph visualization
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
# have no effect if this option is set to NO (the default)

HAVE_DOT               = NO

# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
# allowed to run in parallel. When set to 0 (the default) doxygen will
# base this on the number of processors available in the system. You can set it
# explicitly to a value larger than 0 to get control over the balance
# between CPU load and processing speed.

DOT_NUM_THREADS        = 0

# By default doxygen will use the Helvetica font for all dot files that
# doxygen generates. When you want a differently looking font you can specify
# the font name using DOT_FONTNAME. You need to make sure dot is able to find
# the font, which can be done by putting it in a standard location or by setting
# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
# directory containing the font.

DOT_FONTNAME           = Helvetica

# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
# The default size is 10pt.

DOT_FONTSIZE           = 10

# By default doxygen will tell dot to use the Helvetica font.
# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
# set the path where dot can find it.

DOT_FONTPATH           =

# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
# CLASS_DIAGRAMS tag to NO.

CLASS_GRAPH            = YES

# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect implementation dependencies (inheritance, containment, and
# class references variables) of the class with other documented classes.

COLLABORATION_GRAPH    = YES

# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for groups, showing the direct groups dependencies

GROUP_GRAPHS           = YES

# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.

UML_LOOK               = NO

# If the UML_LOOK tag is enabled, the fields and methods are shown inside
# the class node. If there are many fields or methods and many nodes the
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
# threshold limits the number of items for each type to make the size more
# managable. Set this to 0 for no limit. Note that the threshold may be
# exceeded by 50% before the limit is enforced.

UML_LIMIT_NUM_FIELDS   = 10

# If set to YES, the inheritance and collaboration graphs will show the
# relations between templates and their instances.

TEMPLATE_RELATIONS     = NO

# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
# tags are set to YES then doxygen will generate a graph for each documented
# file showing the direct and indirect include dependencies of the file with
# other documented files.

INCLUDE_GRAPH          = YES

# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
# documented header file showing the documented files that directly or
# indirectly include this file.

INCLUDED_BY_GRAPH      = YES

# If the CALL_GRAPH and HAVE_DOT options are set to YES then
# doxygen will generate a call dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable call graphs
# for selected functions only using the \callgraph command.

CALL_GRAPH             = NO

# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
# doxygen will generate a caller dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable caller
# graphs for selected functions only using the \callergraph command.

CALLER_GRAPH           = NO

# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will generate a graphical hierarchy of all classes instead of a textual one.

GRAPHICAL_HIERARCHY    = YES

# If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
# then doxygen will show the dependencies a directory has on other directories
# in a graphical way. The dependency relations are determined by the #include
# relations between the files in the directories.

DIRECTORY_GRAPH        = YES

# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. Possible values are svg, png, jpg, or gif.
# If left blank png will be used. If you choose svg you need to set
# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible in IE 9+ (other browsers do not have this requirement).

DOT_IMAGE_FORMAT       = png

# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.
# Note that this requires a modern browser other than Internet Explorer.
# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible. Older versions of IE do not have SVG support.

INTERACTIVE_SVG        = NO

# The tag DOT_PATH can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.

DOT_PATH               =

# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the
# \dotfile command).

DOTFILE_DIRS           =

# The MSCFILE_DIRS tag can be used to specify one or more directories that
# contain msc files that are included in the documentation (see the
# \mscfile command).

MSCFILE_DIRS           =

# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# nodes that will be shown in the graph. If the number of nodes in a graph
# becomes larger than this value, doxygen will truncate the graph, which is
# visualized by representing a node as a red box. Note that doxygen if the
# number of direct children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.

DOT_GRAPH_MAX_NODES    = 50

# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
# graphs generated by dot. A depth value of 3 means that only nodes reachable
# from the root by following a path via at most 3 edges will be shown. Nodes
# that lay further from the root node will be omitted. Note that setting this
# option to 1 or 2 may greatly reduce the computation time needed for large
# code bases. Also note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.

MAX_DOT_GRAPH_DEPTH    = 0

# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. Warning: Depending on the platform used,
# enabling this option may lead to badly anti-aliased labels on the edges of
# a graph (i.e. they become hard to read).

DOT_TRANSPARENT        = NO

# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10)
# support this, this feature is disabled by default.

DOT_MULTI_TARGETS      = YES

# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
# generate a legend page explaining the meaning of the various boxes and
# arrows in the dot generated graphs.

GENERATE_LEGEND        = YES

# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
# remove the intermediate dot files that are used to generate
# the various graphs.

DOT_CLEANUP            = YES
clasp-3.2.2/liblp/potassco/000077500000000000000000000000001304134206100155475ustar00rootroot00000000000000clasp-3.2.2/liblp/potassco/aspif.h000066400000000000000000000116071304134206100170270ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_ASPIF_H_INCLUDED
#define LIBLP_ASPIF_H_INCLUDED
#include 
namespace Potassco {
/*!
 * \addtogroup ParseType
 */
///@{
/*!
 * Parses the given program in asp intermediate format and calls ctx on each parsed element.
 * The error handler h is called on error. If h is 0, ParseError exceptions are used to signal errors.
 */
int readAspif(std::istream& prg, AbstractProgram& out, ErrorHandler h = 0);

//! Class for parsing logic programs in asp intermediate format.
class AspifInput : public ProgramReader {
public:
	//! Creates a new parser object that calls out on each parsed element.
	AspifInput(AbstractProgram& out);
	virtual ~AspifInput();
protected:
	//! Checks whether stream starts with aspif header.
	virtual bool doAttach(bool& inc);
	//! Parses the current step and throws exception on error.
	/*!
	 * The function calls beginStep()/endStep() on the associated
	 * output object before/after parsing the current step.
	 */
	virtual bool doParse();
	//! Attempts to parse a theory directive of type t.
	/*!
	 * \see Potassco::Theory_t
	 */
	virtual void matchTheory(unsigned t);
private:
	uint32_t matchAtoms();
	uint32_t matchLits();
	uint32_t matchWLits(int32_t minW);
	uint32_t matchString();
	uint32_t matchTermList();
	AbstractProgram& out_;
	BasicStack*      data_;
};
///@}

//! Writes a program in potassco's asp intermediate format to the given output stream.
/*!
 * \ingroup WriteType
 */
class AspifOutput : public AbstractProgram {
public:
	//! Creates a new object and associates it with the given output stream.
	AspifOutput(std::ostream& os);
	//! Writes an aspif header to the stream.
	virtual void initProgram(bool incremental);
	//! Prepares the object for a new program step.
	virtual void beginStep();
	//! Writes an aspif rule directive.
	virtual void rule(Head_t ht, const AtomSpan& head, const LitSpan& body);
	//! Writes an aspif rule directive.
	virtual void rule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& lits);
	//! Writes an aspif minimize directive.
	virtual void minimize(Weight_t prio, const WeightLitSpan& lits);
	//! Writes an aspif output directive.
	virtual void output(const StringSpan& str, const LitSpan& cond);
	//! Writes an aspif external directive.
	virtual void external(Atom_t a, Value_t v);
	//! Writes an aspif assumption directive.
	virtual void assume(const LitSpan& lits);
	//! Writes an aspif projection directive.
	virtual void project(const AtomSpan& atoms);
	//! Writes an aspif edge directive.
	virtual void acycEdge(int s, int t, const LitSpan& condition);
	//! Writes an aspif heuristic directive.
	virtual void heuristic(Atom_t a, Heuristic_t t, int bias, unsigned prio, const LitSpan& condition);
	
	//! Writes an aspif theory number term.
	virtual void theoryTerm(Id_t termId, int number);
	//! Writes an aspif theory symbolic term.
	virtual void theoryTerm(Id_t termId, const StringSpan& name);
	//! Writes an aspif theory compound term.
	virtual void theoryTerm(Id_t termId, int compound, const IdSpan& args);
	//! Writes an aspif theory element directive.
	virtual void theoryElement(Id_t elementId, const IdSpan& terms, const LitSpan& cond);
	//! Writes an aspif theory atom directive.
	virtual void theoryAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements);
	//! Writes an aspif theory atom directive with guard.
	virtual void theoryAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements, Id_t op, Id_t rhs);
	//! Writes the aspif step terminator.
	virtual void endStep();
protected:
	//! Starts writing an aspif directive.
	AspifOutput& startDir(Directive_t r);
	//! Writes x.
	AspifOutput& add(int x);
	//! Writes size(lits) followed by the elements in lits.
	AspifOutput& add(const WeightLitSpan& lits);
	//! Writes size(lits) followed by the literals in lits.
	AspifOutput& add(const LitSpan& lits);
	//! Writes size(atoms) followed by the atoms in atoms.
	AspifOutput& add(const AtomSpan& atoms);
	//! Writes size(str) followed by the characters in str.
	AspifOutput& add(const StringSpan& str);
	//! Terminates the active directive by writing a newline.
	AspifOutput& endDir();
private:
	AspifOutput(const AspifOutput&);
	AspifOutput& operator=(const AspifOutput&);
	std::ostream& os_;
};
}
#endif
clasp-3.2.2/liblp/potassco/aspif_text.h000066400000000000000000000042441304134206100200720ustar00rootroot00000000000000// 
// Copyright (c) 2016, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_ASPIF_TEXT_H_INCLUDED
#define LIBLP_ASPIF_TEXT_H_INCLUDED
#include 
namespace Potassco {

//! Class for parsing logic programs in ground text format.
/*!
 * \addtogroup ParseType
 */
class AspifTextInput : public ProgramReader {
public:
	//! Creates a new object and associates it with the given output if any.
	AspifTextInput(AbstractProgram* out);
	//! Sets the program to which parsed elements should be output.
	void setOutput(AbstractProgram& out);
protected:
	//! Checks whether stream starts with a valid token.
	virtual bool doAttach(bool& inc);
	//! Attempts to parses the current step or throws an exception on error.
	/*!
	 * The function calls beginStep()/endStep() on the associated
	 * output object before/after parsing the current step.
	 */
	virtual bool doParse();
	//! Parses statements until next step directive or input is exhausted.
	bool parseStatements();
private:
	void   skipws();
	bool   matchDirective();
	void   matchRule(char peek);
	void   matchAtoms(const char* seps);
	void   matchLits();
	void   matchCondition();
	void   matchAgg();
	bool   match(const char* ts, bool required = true);
	Atom_t matchId();
	Lit_t  matchLit();
	int    matchInt();
	void   matchTerm();
	void   matchAtomArg();
	void   matchStr();
	void   startString();
	void   push(char c);
	void   endString();
	AbstractProgram* out_;
	BasicStack       data_;
	uint32_t         strStart_;
	uint32_t         strPos_;
};

}
#endif
clasp-3.2.2/liblp/potassco/basic_types.h000066400000000000000000000305131304134206100202270ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_BASIC_TYPES_H_INCLUDED
#define LIBLP_BASIC_TYPES_H_INCLUDED
/*!
 * \mainpage liblp
 * A small library for parsing and converting logic programs in aspif and smodels format.
 *
 * The library contains parsers and writers for aspif and smodels format
 * as well as functions and types for converting between the two formats
 * to the extentpossible.
 * 
 * A specification of aspif can be found in Appendix A of:
 * http://www.cs.uni-potsdam.de/wv/pdfformat/gekakaosscwa16b.pdf
 */
#include 
#include 
#include 

//! Root namespace for all types and functions of liblp.
namespace Potassco {

/*!
 * \defgroup WriteType Program writer types
 * \brief Types and functions for writing logic programs.
 */

/*!
 * \defgroup ParseType Program parser types
 * \brief Types and functions for parsing logic programs.
 */

/*!
 * \defgroup BasicTypes Basic Data Types
 * \brief Basic types for working with logic programs.
 */
///@{

//! Macro for defining a set of constants similar to a C++11 strong enum.
#define POTASSCO_ENUM_CONSTANTS_T(TypeName, BaseType, minVal, ...) \
	enum E { __VA_ARGS__, __eEnd, eMin = minVal, eMax = __eEnd - 1 };\
	TypeName(E x = eMin) : val_(x) {}\
	explicit TypeName(BaseType x) : val_(static_cast(x)) {assert(x <= eMax);}\
	operator BaseType() const { return static_cast(val_); } \
	E val_

//! Macro for defining a set of constants starting at 0.
#define POTASSCO_ENUM_CONSTANTS(TypeName, ...) \
	POTASSCO_ENUM_CONSTANTS_T(TypeName, unsigned, 0u, __VA_ARGS__)

//! Ids are non-negative integers in the range [0..idMax].
typedef uint32_t Id_t;
//! Maximum value for ids.
const Id_t idMax = static_cast(-1);
//! Atom ids are positive integers in the range [atomMin..atomMax].
typedef uint32_t Atom_t;
//! Minimum value for atom ids (must not be 0).
const Atom_t atomMin = static_cast(1);
//! Maximum value for atom ids.
const Atom_t atomMax = static_cast(((1u)<<31)-1);
//! Literals are signed atoms.
typedef int32_t Lit_t;
//! (Literal) weights are integers.
typedef int32_t Weight_t;
//! A literal with an associated weight.
struct WeightLit_t {
	Lit_t    lit;    /**< Literal. */
	Weight_t weight; /**< Associated weight. */
};
//! Supported rule head types.
struct Head_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Head_t, Disjunctive = 0, Choice = 1);
};
//! Supported rule body types.
struct Body_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Body_t, Normal = 0, Sum = 1, Count = 2);
};
//! Type representing an external value.
struct Value_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Value_t,
		Free  = 0, True    = 1,
		False = 2, Release = 3
	);
};

//! A span consists of a starting address and a length.
/*!
 * A span does not own the data and it is in general not safe to store a span.
 */
template 
struct Span {
	//! Iterator type for iterating over the elements of a span.
	typedef const T*    iterator;
	typedef std::size_t size_t;
	//! Returns the element at the given position, which shall be < size.
	const T& operator[](std::size_t pos) const { assert(pos < size); return first[pos]; }

	const T* first; /**< Pointer to first element of this span. */
	size_t   size;  /**< Number of elements in this span. */
};
typedef Span        IdSpan;
typedef Span      AtomSpan;
typedef Span       LitSpan;
typedef Span WeightLitSpan;
typedef Span        StringSpan;

//! Supported modifications for domain heuristic.
struct Heuristic_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Heuristic_t,
		Level = 0, Sign = 1, Factor = 2,
		Init  = 3, True = 4, False  = 5
	);
	static const StringSpan pred; /**< zero-terminated predicate name. */
};
//! Supported aspif directives.
struct Directive_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Directive_t,
		End       = 0,
		Rule      = 1, Minimize = 2,
		Project   = 3, Output   = 4,
		External  = 5, Assume   = 6,
		Heuristic = 7, Edge     = 8,
		Theory    = 9, Comment  = 10
	);
};

//! Basic callback interface for constructing a logic program.
class AbstractProgram {
public:
	virtual ~AbstractProgram();
	//! Called once to prepare for a new logic program.
	virtual void initProgram(bool incremental);
	//! Called once before rules and directives of the current program step are added.
	virtual void beginStep();
	
	//! Add the given rule to the program.
	virtual void rule(Head_t ht, const AtomSpan& head, const LitSpan& body) = 0;
	//! Add the given sum rule to the program.
	virtual void rule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body) = 0;
	//! Add the given minimize statement to the program.
	virtual void minimize(Weight_t prio, const WeightLitSpan& lits) = 0;
	
	/*!
	* \name Advanced
	* Functions for adding advanced constructs.
	* By default, functions in this group throw a std::logic_error()
	* to signal that advanced constructs are not supported.
	*/
	//@{
	//! Mark the given list of atoms as projection atoms.
	virtual void project(const AtomSpan& atoms);
	//! Output str whenever condition is true in a stable model.
	virtual void output(const StringSpan& str, const LitSpan& condition);
	//! If v is not equal to Value_t::Release, mark a as external and assume value v. Otherwise, treat a as regular atom.
	virtual void external(Atom_t a, Value_t v);
	//! Assume the given literals to true during solving.
	virtual void assume(const LitSpan& lits);
	//! Apply the given heuristic modification to atom a whenever condition is true.
	virtual void heuristic(Atom_t a, Heuristic_t t, int bias, unsigned prio, const LitSpan& condition);
	//! Assume an edge between s and t whenever condition is true.
	virtual void acycEdge(int s, int t, const LitSpan& condition);
	//@}

	/*!
	 * \name Theory data
	 * Functions for adding theory statements.
	 * By default, all theory function throw a std::logic_error().
	 * Note, ids shall be unique within one step.
	 */
	//@{
	//! Add a new number term.
	virtual void theoryTerm(Id_t termId, int number);
	//! Add a new symbolic term.
	virtual void theoryTerm(Id_t termId, const StringSpan& name);
	//! Add a new compound (function or tuple) term.
	virtual void theoryTerm(Id_t termId, int cId, const IdSpan& args);
	//! Add a new theory atom element.
	virtual void theoryElement(Id_t elementId, const IdSpan& terms, const LitSpan& cond);
	//! Add a new theory atom consisting of the given elements, which have to be added eventually.
	virtual void theoryAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements);
	//! Add a new theory atom with guard and right hand side.
	virtual void theoryAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements, Id_t op, Id_t rhs);
	//@}

	//! Called once after all rules and directives of the current program step were added.
	virtual void endStep();
};
typedef int(*ErrorHandler)(int line, const char* what);

/*!
 * \defgroup BasicFunc Basic functions
 * \brief Additional functions over with basic types.
 * \ingroup BasicTypes
 */
///@{
//! Returns the id of the given atom.
inline Id_t        id(Atom_t a)                  { return static_cast(a); }
//! Returns the id of the given literal.
inline Id_t        id(Lit_t lit)                 { return static_cast(lit); }
//! Returns the atom of the given literal.
inline Atom_t      atom(Lit_t lit)               { return static_cast(lit >= 0 ? lit : -lit); }
//! Returns the atom of the given weight literal.
inline Atom_t      atom(const WeightLit_t& w)    { return atom(w.lit); }
//! Converts the given id back to a literal.
inline Lit_t       lit(Id_t a)                   { return static_cast(a); }
//! Identity function for literals.
inline Lit_t       lit(Lit_t lit)                { return lit; }
//! Returns the literal of the given weight literal.
inline Lit_t       lit(const WeightLit_t& w)     { return w.lit; }
//! Returns the negative literal of the given atom.
inline Lit_t       neg(Atom_t a)                 { return -lit(a); }
//! Returns the complement of the given literal.
inline Lit_t       neg(Lit_t lit)                { return -lit; }
//! Returns the weight of the given atom, which is always 1.
inline Weight_t    weight(Atom_t)                { return 1; }
//! Returns the weight of the given literal, which is always 1.
inline Weight_t    weight(Lit_t)                 { return 1; }
//! Returns the weight of the given weight literal.
inline Weight_t    weight(const WeightLit_t& w)  { return w.weight; }
//! Returns whether the given span is empty, i.e. has size 0.
template 
inline bool        empty(const Span& s)       { return s.size == 0; }
//! Returns the size of the given span.
template 
inline std::size_t size(const Span& s)        { return s.size; }
//! Returns a pointer to the first element of the given span.
template  
inline const T*    begin(const Span& s)       { return s.first; }
//! Returns a pointer one past the end of the given span.
template  
inline const T*    end(const Span& s)         { return begin(s) + s.size; }
//! Returns the element at the given position of the given span.
/*!
 * \pre pos < size(s)
 */
template 
inline const T&    at(const Span& s, std::size_t pos) { return s[pos]; }

inline bool operator==(const WeightLit_t& lhs, const WeightLit_t& rhs) { return lit(lhs) == lit(rhs) && weight(lhs) == weight(rhs); }
inline bool operator==(Lit_t lhs, const WeightLit_t& rhs) { return lit(lhs) == lit(rhs) && weight(rhs) == 1; }
inline bool operator==(const WeightLit_t& lhs, Lit_t rhs) { return rhs == lhs; }
inline bool operator!=(const WeightLit_t& lhs, const WeightLit_t& rhs) { return !(lhs == rhs); }
inline bool operator!=(Lit_t lhs, const WeightLit_t& rhs) { return !(lhs == rhs); }
inline bool operator!=(const WeightLit_t& lhs, Lit_t rhs) { return rhs != lhs; }
inline bool operator<(const WeightLit_t& lhs, const WeightLit_t& rhs) { return lhs.lit != rhs.lit ? lhs.lit < rhs.lit : lhs.weight < rhs.weight; }

//! Creates a span from an array of size s.
template 
inline Span toSpan(const T* x, std::size_t s) {
	Span r = {x, s};
	return r;
}
//! Creates an empty span.
template 
inline Span toSpan() { return toSpan(static_cast(0), 0); }
//! Creates a span from a sequential (STL) container c.
template 
inline Span toSpan(const C& c) {
	return !c.empty() ? toSpan(&c[0], c.size()) : toSpan();
}
//! Returns the string representation of the given heuristic modifier.
inline const char* toString(Heuristic_t t) {
	switch (t) {
		case Heuristic_t::Level: return "level";
		case Heuristic_t::Sign:  return "sign";
		case Heuristic_t::Factor:return "factor";
		case Heuristic_t::Init:  return "init";
		case Heuristic_t::True:  return "true";
		case Heuristic_t::False: return "false";
		default: return "";
	}
}

///@}
///@}

//! A (dynamic-sized) raw memory stack.
/*!
 * \ingroup ParseType
 */
class RawStack {
public:
	RawStack();
	RawStack(const RawStack& other);
	RawStack& operator=(const RawStack& other);
	//! Swaps this and other.
	void     swap(RawStack& other);
	//! Reserves space for at least cap bytes or throws std::bad_alloc on out of memory.
	void     reserve(uint32_t cap);
	//! Returns the current stack capacity in bytes.
	uint32_t capacity() const;
	//! Returns the top position of the stack.
	uint32_t top() const;
	//! Returns the data beginning at the given index.
	void*    get(uint32_t idx) const;
	//! Same as pop(top()).
	void     clear();
	//! Moves top to idx.
	void     setTop(uint32_t idx);
protected:
	~RawStack();
	//! Pushes n bytes and returns the position of the first byte pushed.
	uint32_t push_(uint32_t n);
	//! Pops n bytes and returns the new top.
	uint32_t pop_(uint32_t n);
private:
	unsigned char* mem_;
	uint32_t       top_;
	uint32_t       cap_;
};

}
#endif
clasp-3.2.2/liblp/potassco/clingo.h000066400000000000000000000170521304134206100172000ustar00rootroot00000000000000// 
// Copyright (c) 2015-2016, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_CLINGO_H_INCLUDED
#define LIBLP_CLINGO_H_INCLUDED
#include 
namespace Potassco {

/*!
 * \defgroup Clingo Clingo
 * \brief Interfaces for communicating with a solver.
 */
///@{

//! Supported clause types in theory propagation.
struct Clause_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Clause_t,
		Learnt         = 0, /**< Cumulative removable (i.e. subject to nogood deletion) clause. */
		Static         = 1, /**< Cumulative unremovable clause. */
		Volatile       = 2, /**< Removable clause associated with current solving step.   */
		VolatileStatic = 3  /**< Unremovable clause associated with current solving step. */
	);
	//! Returns whether p is either Volatile or VolatileStatic.
	static bool isVolatile(Clause_t p) { return (static_cast(p)& static_cast(Volatile)) != 0; }
	//! Returns whether p is either Static or VolatileStatic.
	static bool isStatic(Clause_t p)   { return (static_cast(p)& static_cast(Static)) != 0; }
};
//! Supported statistics types.
struct Statistics_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Statistics_t,
		Empty = 0, /**< Empty (invalid) object. */
		Value = 1, /**< Single statistic value that is convertible to a double.    */
		Array = 2, /**< Composite object mapping int keys to statistics types.   */
		Map   = 3  /**< Composite object mapping string keys to statistics types.*/
	);
};

//! Represents an assignment of a particular solver.
class AbstractAssignment {
public:
	typedef Potassco::Value_t Value_t;
	typedef Potassco::Lit_t   Lit_t;
	virtual ~AbstractAssignment();
	//! Returns whether the current assignment is conflicting.
	virtual bool     hasConflict()     const = 0;
	//! Returns the number of decision literals in the assignment.
	virtual uint32_t level()           const = 0;
	//! Returns whether lit is a valid literal in this assignment.
	virtual bool     hasLit(Lit_t lit) const = 0;
	//! Returns the truth value that is currently assigned to lit or Value_t::Free if lit is unassigned.
	virtual Value_t  value(Lit_t lit)  const = 0;
	//! Returns the decision level on which lit was assigned or uint32_t(-1) if lit is unassigned.
	virtual uint32_t level(Lit_t lit)  const = 0;
	//! Returns the decision literal of the given decision level.
	virtual Lit_t    decision(uint32_t)const = 0;
	//! Returns whether the given literal is irrevocably assigned on the top level.
	bool isFixed(Lit_t lit) const;
	//! Returns whether the given literal is true wrt the current assignment. 
	bool isTrue(Lit_t lit)  const;
	//! Returns whether the given literal is false wrt the current assignment. 
	bool isFalse(Lit_t lit) const;
};

//! Represents one particular solver instance.
class AbstractSolver {
public:
	typedef Potassco::Lit_t Lit;
	virtual ~AbstractSolver();
	//! Returns the id of the solver that is associated with this object.
	virtual Id_t id() const = 0;
	//! Returns the current assignment of the solver.
	virtual const AbstractAssignment& assignment() const = 0;

	//! Adds the given clause to the solver if possible.
	/*!
	 * If the function is called during propagation, the return value
	 * indicates whether propagation may continue (true) or shall be
	 * aborted (false).
	 *
	 * \param clause The literals that make up the clause.
	 * \param prop   Properties to be associated with the new clause.
	 *
	 * \note If clause contains a volatile variable, i.e., a variable
	 * that was created with Solver::addVariable(), it is also considered volatile.
	 * 
	 */
	virtual bool addClause(const Potassco::LitSpan& clause, Clause_t prop = Clause_t::Learnt) = 0;
	
	//! Adds a new volatile variable to this solver instance.
	/*!
	 * The new variable is volatile, i.e., only valid within the current solving step,
	 * and only added to this one particular solver instance.
	 *
	 * \return The positive literal of the new variable.
	 */
	virtual Lit  addVariable() = 0;
	//! Propagates any newly implied literals.
	virtual bool propagate() = 0;

	/*!
	 * \name Propagate control
	 * \brief Functions that must only be called in the context of a propagator.
	 *
	 * @{ */

	//! Returns whether the active propagator watches lit in this solver instance.
	virtual bool hasWatch(Lit lit) const = 0;

	//! Adds the active propagator to the list of propagators to be notified when the given literal is assigned in this solver instance.
	/*!
	 * \post hasWatch(lit) returns true.
	 */
	virtual void addWatch(Lit lit) = 0;
	//! Removes the active propagator from the list of propagators watching p in the given solver.
	/*!
	 * \post hasWatch(lit) returns false.
	 */
	virtual void removeWatch(Lit lit) = 0;
	//@}
};

//! Base class for implementing propagators.
class AbstractPropagator {
public:
	//! Type for representing a set of literals that have recently changed.
	typedef Potassco::LitSpan ChangeList;
	virtual ~AbstractPropagator();
	//! Shall propagate the newly assigned literals given in changes.
	virtual void propagate(AbstractSolver& solver,  const ChangeList& changes) = 0;
	//! May update internal state of the newly unassigned literals given in undo.
	virtual void undo(const AbstractSolver& solver, const ChangeList& undo) = 0;
	//! Similar to propagate but called on total assignment without a list of changes.
	virtual void check(AbstractSolver& solver) = 0;
};

//! Base class for providing (solver) statistics.
/*!
 * Functions in this interface taking a key as parameter
 * assume that the key is valid and throw a std::logic_error
 * if this precondition is violated.
 */
class AbstractStatistics {
public:
	//! Opaque type for representing (sub) keys.
	typedef uint64_t Key_t;
	
	virtual ~AbstractStatistics();

	//! Returns the root key of this statistic object.
	virtual Key_t        root()         const = 0;
	//! Returns the type of the object with the given key.
	virtual Statistics_t type(Key_t key) const = 0;
	//! Returns the child count of the object with the given key or 0 if it is a value.
	virtual size_t       size(Key_t key) const = 0;
	/*!
	 * \name Array
	 * Functions in this group shall only be called on Array objects.
	 */
	//@{
	//! Returns the element at the given zero-based index.
	/*!
	 * \pre index < size(key)
	 */
	virtual Key_t at(Key_t arr, size_t index) const = 0;
	//@}

	/*!
	 * \name Map
	 * Functions in this group shall only be called on Map objects.
	 */
	//@{
	//! Returns the i'th key of the given map.
	/*!
	 * \pre i < size(mapK)
	 * \note The order of keys in a map is unspecified and might change
	 * after a solve operation.
	 */
	virtual const char* key(Key_t mapK, size_t i) const = 0;
	//! Returns the element stored in the map under the given name.
	virtual Key_t       get(Key_t mapK, const char* at) const = 0;
	//@}
	/*!
	 * \name Value
	 * Functions in this group shall only be called on Value objects.
	 */
	//@{
	//! Returns the statistic value associated with the given key.
	virtual double value(Key_t key) const = 0;
	//@}
};
///@}

}
#endif
clasp-3.2.2/liblp/potassco/convert.h000066400000000000000000000075441304134206100174120ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_CONVERT_H_INCLUDED
#define LIBLP_CONVERT_H_INCLUDED

#include 
namespace Potassco {

//! Converts a given program so that it can be expressed in smodels format.
/*!
 * \ingroup WriteType
 */
class SmodelsConvert : public AbstractProgram {
public:
	//! Creates a new object that passes converted programs to out.
	/*!
	 * The parameter enableClaspExt determines how heuristic, edge, and external 
	 * directives are handled.
	 * If true, heuristic and edge directives are converted to _heuristic and
	 * _edge predicates, while external directives passed to out. 
	 * Otherwise, heuristic and edge directives are not converted but 
	 * directly passed to out, while external directives are mapped to
	 * choice rules or integrity constraints.
	 */
	SmodelsConvert(AbstractProgram& out, bool enableClaspExt);
	~SmodelsConvert();
	//! Calls initProgram() on the associated output program.
	virtual void initProgram(bool incremental);
	//! Calls beginStep() on the associated output program.
	virtual void beginStep();
	//! Converts the given rule into one or more smodels rules.
	virtual void rule(Head_t t, const AtomSpan& head, const LitSpan& body);
	//! Converts the given rule into one or more smodels rules.
	virtual void rule(Head_t t, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body);
	//! Converts literals associated with a priority to a set of corresponding smodels minimize rules.
	virtual void minimize(Weight_t prio, const WeightLitSpan& lits);
	//! Adds an atom named str that is equivalent to the condition to the symbol table.
	virtual void output(const StringSpan& str, const LitSpan& cond);
	//! Marks the atom that is equivalent to a as external.
	virtual void external(Atom_t a, Value_t v);
	//! Adds an _heuristic predicate over the given atom to the symbol table that is equivalent to condition.
	virtual void heuristic(Atom_t a, Heuristic_t t, int bias, unsigned prio, const LitSpan& condition);
	//! Adds an _edge(s,t) predicate to the symbol table that is equivalent to condition.
	virtual void acycEdge(int s, int t, const LitSpan& condition);

	//! Finalizes conversion and calls endStep() on the associated output program.
	virtual void endStep();

	//! Returns the output literal associated to in.
	Lit_t       get(Lit_t in) const;
	//! Returns the name associated with the given (output) smodels atom or 0 if no name exists.
	const char* getName(Atom_t a) const;
	//! Returns the max used smodels atom (valid atoms are [1..n]).
	unsigned    maxAtom() const;
protected:
	//! Creates a (named) atom that is equivalent to the given condition.
	Atom_t makeAtom(const LitSpan& lits, bool named);
	//! Processes all outstanding conversions.
	void flush();
	//! Converts external atoms.
	void flushExternal();
	//! Converts minimize statements.
	void flushMinimize();
	//! Converts heuristic directives to _heuristic predicates.
	void flushHeuristic();
	//! Converts (atom,name) pairs to output directives.
	void flushSymbols();
private:
	SmodelsConvert(const SmodelsConvert&);
	SmodelsConvert& operator=(const SmodelsConvert&);
	struct SmData;
	AbstractProgram& out_;
	SmData*          data_;
	bool             ext_;
};

}
#endif
clasp-3.2.2/liblp/potassco/match_basic_types.h000066400000000000000000000271071304134206100214100ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_MATCH_BASIC_TYPES_H
#define LIBLP_MATCH_BASIC_TYPES_H
#include 
#include 
#include 
#include 
#include 
namespace Potassco {

/*!
 * \addtogroup ParseType
 */
///@{

//! Exception type used to signal errors during parsing.
class ParseError : public std::logic_error {
public:
	//! Constructs a ParseError from the given line and message.
	ParseError(unsigned a_line, const char* msg);
	unsigned line; /**< Line in which error occurred. */
};
//! A wrapper around an std::istream that provides buffering and a simple interface for extracting characters and integers.
class BufferedStream {
public:
	enum { BUF_SIZE = 4096 };
	//! Creates a new object wrapping the given stream.
	explicit BufferedStream(std::istream& str);
	~BufferedStream();
	//! Returns the next character in the input stream, without extracting it.
	char peek() const { return buf_[rpos_]; }
	//! Returns whether the end of the input stream was reached.
	bool end()  const { return peek() == 0; }
	//! Extracts the next character from the input stream or returns 0 if the end was reached.
	char get();
	//! Attempts to put back the given character into the read buffer.
	bool unget(char c);
	//! Attempts to read an integer from the input stream optionally skipping initial whitespace.
	bool match(int64_t& i, bool noSkipWs = false);
	//! Attempts to extract the given string from the input stream.
	/*!
	 * If the function returns false, no characters were extracted from the stream.
	 * \pre std::strlen(tok) <= BUF_SIZE
	 */
	bool match(const char* tok);
	//! Extracts initial whitespace from the input stream.
	void skipWs();
	//! Extracts up to max characters from the input stream and copies them into bufferOut.
	/*!
	 * \return The number of characters copied to bufferOut.
	 */
	int  copy(char* bufferOut, int max);
	//! Returns the current line number in the input stream, i.e. the number of '\n' characters extracted so far.
	unsigned line() const;
	//! Returns whether the given character is a decimal digit.
	static inline bool isDigit(char c) { return c >= '0' && c <= '9'; }
	//! Converts the given character to a decimal digit.
	static inline int  toDigit(char c) { return static_cast(c - '0'); }
private:
	char rget();
	enum { ALLOC_SIZE = BUF_SIZE + 1 };
	BufferedStream& operator=(const BufferedStream&);
	void underflow(bool up = true);
	typedef char* BufferType;
	std::istream& str_;
	BufferType    buf_;
	std::size_t   rpos_;
	unsigned      line_;
};

/*!
 * \name Match
 * Match functions for extracting tokens from a stream/string.
 */
///@{
//! Attempts to extract the given string from the stream optionally skipping leading whitespace first.
inline bool match(BufferedStream& str, const char* word, bool skipWs) {
	if (skipWs) str.skipWs();
	return str.match(word);
}
//! Extracts an int in the given range or throws a ParseError if this fails.
inline int matchInt(BufferedStream& str, int min = INT_MIN, int max = INT_MAX, const char* err = "integer expected") {
	int64_t x;
	if (str.match(x) && x >= min && x <= max) { return static_cast(x); }
	throw ParseError(str.line(), err);
}
//! Extracts a positive integer in the range [0;max] or throws a ParseError if this fails.
inline unsigned matchPos(BufferedStream& str, unsigned max, const char* err) {
	int64_t x;
	if (str.match(x) && x >= 0 && static_cast(x) <= max) { return static_cast(x); }
	throw ParseError(str.line(), err);
}
//! Extracts a positive integer or throws a ParseError if this fails.
inline unsigned matchPos(BufferedStream& str, const char* err = "non-negative integer expected") {
	return matchPos(str, static_cast(-1), err);
}
//! Extracts an atom (i.e. a positive integer > 0) or throws a ParseError if this fails.
inline Atom_t matchAtom(BufferedStream& str, unsigned aMax = atomMax, const char* err = "atom expected") {
	int64_t x; int64_t max = static_cast(aMax);
	if (str.match(x) && x >= atomMin && x <= max) { return static_cast(x); }
	throw ParseError(str.line(), err);
}
//! Extracts a literal (i.e. a signed integer != 0) or throws a ParseError if this fails.
inline Lit_t matchLit(BufferedStream& str, unsigned aMax = atomMax, const char* err = "literal expected") {
	int64_t x; int64_t max = static_cast(aMax);
	if (str.match(x) && x != 0 && x >= -max && x <= max) { return static_cast(x); }
	throw ParseError(str.line(), err);
}
//! Extracts a weight literal (i.e. a literal followed by an integer) or throws a ParseError if this fails.
inline WeightLit_t matchWLit(BufferedStream& str, unsigned aMax = atomMax, Weight_t minW = 0, const char* err = "weight literal expected") {
	WeightLit_t wl;
	wl.lit = matchLit(str, aMax, err);
	wl.weight = matchInt(str, minW, INT_MAX, "invalid weight literal weight");
	return wl;
}
//! Returns whether input starts with word and if so sets input to input + std::strlen(word).
bool match(const char*& input, const char* word);
//! Returns whether input starts with a string representation of a heuristic modifier and if so extracts it.
/*!
 * \see toString(Heuristic_t)
 */
bool match(const char*& input, Heuristic_t& heuType);
//! Attempts to extract the next argument of a predicate.
bool matchAtomArg(const char*& input, StringSpan& arg);
//! Attempts to extract an integer from input and sets input to the first character after the integer.
bool match(const char*& input, int& out);
//! Tries to match potassco's special _heuristic/3 or _heuristic/4 predicate.
/*!
 * \return > 1 on match, 0 if in does not start with _heuristic, < 0 if in has wrong arity or parameters.
 */
int  matchDomHeuPred(const char*& in
	, StringSpan&  atom
	, Heuristic_t& type
	, int&         bias
	, unsigned&    prio);
//! Tries to match an _edge/2 or _acyc_/0 predicate.
int matchEdgePred(const char*& in, StringSpan& n0, StringSpan& n1);
///@}

//! Base class for input parsers.
class ProgramReader {
public:
	//! Enumeration type for supported read modes.
	enum ReadMode { Incremental, Complete };
	//! Creates a reader that is not yet associated with any input stream.
	ProgramReader();
	virtual ~ProgramReader();
	//! Associates the reader with the given input stream and returns whether the stream has the right format.
	bool accept(std::istream& str);
	//! Returns whether the input stream represents an incremental program.
	bool incremental() const;
	//! Attempts to parse the previously accepted input stream.
	/*!
	 * Depending on the given read mode, the function either parses the complete program
	 * or only the next incremental step.
	 */
	bool parse(ReadMode r = Incremental);
	//! Returns whether the input stream has more data or is exhausted.
	bool more();
	//! Resets this object to the state after default construction.
	void reset();
	//! Returns the current line number in the input stream.
	unsigned line() const;
	//! Sets the largest possible variable number.
	/*!
	 * The given value is used when matching atoms or literals.
	 * If a larger value is found in the input stream, a ParseError exception
	 * is thrown.
	 */
	void setMaxVar(unsigned v) { varMax_ = v; }
protected:
	typedef BufferedStream StreamType;
	typedef WeightLit_t WLit_t;
	//! Shall return true if the format of the input stream is supported by this object.
	/*!
	 * \param[out] inc Whether the input stream represents an incremental program.
	 */
	virtual bool doAttach(bool& inc) = 0;
	//! Shall parse the next program step.
	virtual bool doParse() = 0;
	//! Shall reset any parsing state.
	virtual void doReset();
	//! Returns the associated input stream.
	StreamType*  stream() const;
	//! Returns the next character in the input stream, without extracting it.
	char     peek(bool skipws) const;
	//! Throws a ParseError with the current line and given message if cnd is false.
	bool     require(bool cnd, const char* msg) const;
	//! Attempts to match the given string.
	bool     match(const char* word, bool skipWs = true) { return Potassco::match(*stream(), word, skipWs); }
	//! Extracts an int in the given range or throws a ParseError if this fails.
	int      matchInt(int min = INT_MIN, int max = INT_MAX, const char* err = "integer expected") { return Potassco::matchInt(*stream(), min, max, err); }
	//! Extracts a positive integer in the range [0;max] or throws a ParseError if this fails.
	unsigned matchPos(unsigned max = static_cast(-1), const char* err = "unsigned integer expected") { return Potassco::matchPos(*stream(), max, err); }
	//! Extracts a positive integer or throws a ParseError if this fails.
	unsigned matchPos(const char* err) { return matchPos(static_cast(-1), err); }
	//! Extracts an atom (i.e. a positive integer > 0) or throws a ParseError if this fails.
	/*!
	 * \see setMaxVar(unsigned)
	 */
	Atom_t   matchAtom(const char* err = "atom expected") { return Potassco::matchAtom(*stream(), varMax_, err); }
	//! Extracts a literal (i.e. a signed integer != 0) or throws a ParseError if this fails.
	Lit_t    matchLit(const char* err = "literal expected") { return Potassco::matchLit(*stream(), varMax_, err); }
	//! Extracts a weight literal (i.e. a literal followed by an integer) or throws a ParseError if this fails.
	WLit_t   matchWLit(int min, const char* err = "weight literal expected") { return Potassco::matchWLit(*stream(), varMax_, min, err); }
	//! Extracts and discards characters up to and including the next newline.
	void     skipLine();
private:
	ProgramReader(const ProgramReader&);
	ProgramReader& operator=(const ProgramReader&);
	StreamType* str_;
	unsigned    varMax_;
	bool        inc_;
};

//! A (dynamic-sized) stack for storing basic types like literals and atoms.
class BasicStack : public RawStack {
public:
	//! Pushes the given integer or literal onto the stack.
	void push(int32_t x) { push(static_cast(x)); }
	//! Pushes the given unsigned integer or atom onto the stack.
	void push(uint32_t x);
	//! Pushes the given weight literal onto the stack.
	void push(WeightLit_t x);
	//! Pops an object, which shall be of type T, from the stack.
	template  T       pop() { const T* x;  pop(&x, 1); return *x; }
	//! Allocates space for len objects of type T on the stack and returns the starting address of the allocated range.
	template  T*      makeSpan(uint32_t len) { T* x; push(&x, len); return x; }
	//! Pops a range of len objects of type T from the stack.
	template  Span popSpan(uint32_t len) { const T* x; pop(&x, len); return toSpan(x, len); }
protected:
	//! Pops len objects of type T from the stack.
	template 
	void pop(const T**, uint32_t len);
	//! Pops len characters from the stack.
	void pop(const char**, uint32_t len);
	//! Allocates space for len objects of type T.
	template 
	void push(T**, uint32_t len);
	//! Allocates space for len characters.
	void push(char**, uint32_t len);
};

//! Attaches the given stream to r and calls ProgramReader::parse() with the read mode set to ProgramReader::Complete.
int readProgram(std::istream& str, ProgramReader& r, ErrorHandler err);
}
///@}

#endif
clasp-3.2.2/liblp/potassco/rule_utils.h000066400000000000000000000113301304134206100201050ustar00rootroot00000000000000// 
// Copyright (c) 2016, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_RULE_UTILS_H_INCLUDED
#define LIBLP_RULE_UTILS_H_INCLUDED
#include 
#include 
namespace Potassco {
/*!
 * \addtogroup BasicTypes
 */
///@{

//! A sum aggregate with a lower bound.
struct Sum_t {
	WeightLitSpan lits;  /**< Weight literals of the aggregate. */
	Weight_t      bound; /**< Lower bound of the aggregate. */
};
//! A type that can represent an aspif rule.
struct Rule_t {
	Head_t   ht;   /**< Head type of the rule. */
	AtomSpan head; /**< Head atoms of the rule. */
	Body_t   bt;   /**< Type of rule body. */
	union {
		LitSpan cond;
		Sum_t   agg;
	};
	//! Named constructor for creating a rule.
	static Rule_t normal(Head_t ht, const AtomSpan& head, const LitSpan& body);
	//! Named constructor for creating a sum rule.
	static Rule_t sum(Head_t ht, const AtomSpan& head, const Sum_t& sum);
	//! Named constructor for creating a sum rule.
	static Rule_t sum(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& lits);
	//! Returns whether the rule has a normal body, i.e. whether the body is a conjunction of literals.
	bool normal() const { return bt == Body_t::Normal; }
	//! Returns whether the body of the rule is a sum aggregate.
	bool sum()    const { return bt != Body_t::Normal; }
};

//! A builder class for creating a rule.
class RuleBuilder {
public:
	RuleBuilder();
	/*!
	 * \name Start functions
	 * Functions for starting the definition of a rule's head or body.
	 * If the active rule is frozen (i.e. end() was called), the active
	 * rule is discarded.
	 * \note The body of a rule can be defined before or after its head is defined
	 * but definitions of head and body must not be mixed.
	 */
	//@{
	//! Start definition of the rule's head, which can be either disjunctive or a choice.
	RuleBuilder& start(Head_t ht = Head_t::Disjunctive);
	//! Start definition of a minimize rule. No head allowed.
	RuleBuilder& startMinimize(Weight_t prio);
	//! Start definition of a conjunction to be used as the rule's body.
	RuleBuilder& startBody();
	//! Start definition of a sum aggregate to be used as the rule's body.
	RuleBuilder& startSum(Weight_t bound);
	//@}

	/*!
	 * \name Update functions
	 * Functions for adding elements to the active rule.
	 * \note Update function shall not be called once a rule is frozen.
	 * \note Calling an update function implicitly starts the definition of the
	 * corresponding rule part.
	 */
	//@{
	//! Add a to the rule's head.
	RuleBuilder& addHead(Atom_t a);
	//! Add lit to the rule's body.
	RuleBuilder& addGoal(Lit_t lit);
	//! Add lit with given weight to rule's body if body is a sum aggregate or rule is a minimize rule.
	RuleBuilder& addGoal(Lit_t lit, Weight_t w);
	RuleBuilder& addGoal(WeightLit_t lit);
	//! Update lower bound of sum aggregate.
	RuleBuilder& setBound(Weight_t bound);
	//@}
	
	//! Stop definition of rule and add rule to out if given.
	/*!
	 * Once end() was called, the active rule is considered frozen.
   */
	RuleBuilder& end(AbstractProgram* out = 0);
	//! Discard active rule.
	RuleBuilder& clear();
	//! Discard body of active rule but keep head if any.
	RuleBuilder& clearBody();
	//! Weaken active sum aggregate body to a normal body or count aggregate.
	RuleBuilder& weaken(Body_t to, bool resetWeights = true);
	
	/*!
	 * \name Query functions
	 * Functions for accessing parts of the active rule.
	 * \note The result of these functions is only valid until the next call to
	 * an update function.
	 */
	//@{
	uint32_t     headSize() const;
	Atom_t*      head()     const;
	uint32_t     bodySize() const;
	Body_t       bodyType() const;
	Lit_t*       body()     const;
	WeightLit_t* sum()      const;
	Weight_t     bound()    const;
	Rule_t       rule()     const;
	//@}
private:
	struct RuleInfo;
	struct Data : RawStack {
		template 
		T* push() { return new (this->get(this->push_(sizeof(T)))) T(); }
	};
	void require(bool, const char*) const;
	void endHead();
	void endBody();
	RuleInfo* startBody(Body_t bt, Weight_t bnd);
	RuleInfo* init();
	RuleInfo* info() const;
	Data data_;
};
///@}

}
#endif
clasp-3.2.2/liblp/potassco/smodels.h000066400000000000000000000157611304134206100174000ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_SMODELS_H_INCLUDED
#define LIBLP_SMODELS_H_INCLUDED
#include 
namespace Potassco {

/*!
 * \addtogroup ParseType
 */
///@{

//! Interface representing an smodels-style symbol table.
class AtomTable {
public:
	virtual ~AtomTable();
	//! Associate a name with the given (output) atom.
	virtual void   add(Atom_t id, const StringSpan& name, bool output) = 0;
	//! Return the atom with the given name or 0 if no such atom was previously added.
	virtual Atom_t find(const StringSpan& name) = 0;
};

//! Class for parsing logic programs in (extended) smodels format.
class SmodelsInput : public ProgramReader {
public:
	//! Options for configuring reading of smodels format.
	struct Options {
		Options() : claspExt(false), cEdge(false), cHeuristic(false), filter(false) {}
		//! Enable clasp extensions for handling incremental programs.
		Options& enableClaspExt() { claspExt = true; return *this; }
		//! Convert _edge/_acyc_ atoms to edge directives.
		Options& convertEdges() { cEdge = true; return *this; }
		//! Convert _heuristic atoms to heuristic directives.
		Options& convertHeuristic() { cHeuristic = true; return *this; }
		//! Remove converted atoms from output.
		Options& dropConverted() { filter = true; return *this; }
		bool claspExt;
		bool cEdge;
		bool cHeuristic;
		bool filter;
	};
	//! Creates a new parser object that calls out on each parsed element.
	SmodelsInput(AbstractProgram& out, const Options& opts, AtomTable* symTab = 0);
	virtual ~SmodelsInput();
protected:
	//! Checks whether stream starts with a valid smodels token.
	virtual bool doAttach(bool& inc);
	//! Parses the current step and throws exception on error.
	/*!
	 * The function calls beginStep()/endStep() on the associated
	 * output object before/after parsing the current step.
	 */
	virtual bool doParse();
	//! Resets internal parsing state.
	virtual void doReset();
	//! Reads the current rule block.
	virtual bool readRules();
	//! Reads the current smodels symbol table block.
	virtual bool readSymbols();
	//! Reads the current part of the compute statement.
	virtual bool readCompute(const char* sec, bool val);
	//! Reads an optional external block and the number of models.
	virtual bool readExtra();
	
	//! Pushes literals to stack and returns the number of pushed literals.
	uint32_t matchBody(BasicStack& stack);
	//! Pushes literals and bound to stack and returns the number of pushed literals.
	uint32_t matchSum(BasicStack& stack, bool weights);
private:
	struct NodeTab;
	struct SymTab;
	AbstractProgram& out_;
	AtomTable*       atoms_;
	NodeTab*         nodes_;
	Options          opts_;
	bool             delSyms_;
};

/*!
 * Parses the given program in smodels format and calls out on each parsed element.
 * The error handler h is called on error. If h is 0, ParseError exceptions are used to signal errors.
 */
int readSmodels(std::istream& prg, AbstractProgram& out, ErrorHandler h = 0, const SmodelsInput::Options& opts = SmodelsInput::Options());

///@}

/*!
 * \addtogroup WriteType
 */
///@{

//! Returns a non-zero value if head can be represented in smodels format (i.e. is not empty).
int isSmodelsHead(Head_t ht, const AtomSpan& head);
//! Returns a non-zero value if rule can be represented in smodels format.
int isSmodelsRule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body);

//! Writes a program in smodels numeric format to the given output stream.
/*!
 * \note The class only supports program constructs that can be directly
 * expressed in smodels numeric format.
 */
class SmodelsOutput : public AbstractProgram {
public:
	//! Creates a new object and associates it with the given output stream.
	/*!
	 * If enableClaspExt is true, rules with numbers 90, 91, and 92
	 * are used to enable incremental programs and external atoms.
	 *
	 * The falseAtom is used to write integrity constraints and can be
	 * set to 0 if integrity constraints are not used.
	 */
	SmodelsOutput(std::ostream& os, bool enableClaspExt, Atom_t falseAtom);
	//! Prepares the object for a new program.
	/*!
	 * Requires enableClaspExt or inc must be false.
	 */
	virtual void initProgram(bool inc);
	//! Starts a new step.
	virtual void beginStep();
	//! Writes the given rule provided that isSmodelsHead(head) returns a non-zero value.
	virtual void rule(Head_t t, const AtomSpan& head, const LitSpan& body);
	//! Writes the given rule provided that isSmodelsRule(head, bound, body) returns a non-zero value.
	virtual void rule(Head_t t, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body);
	//! Writes the given minimize rule while ignoring its priority.
	virtual void minimize(Weight_t prio, const WeightLitSpan& lits);
	//! Writes the entry (a, str) to the symbol table provided that condition equals a.
	/*!
	 * \note Symbols shall only be added once after all rules were added.
	 */
	virtual void output(const StringSpan& str, const LitSpan& cond);
	//! Writes lits as a compute statement.
	/*!
	 * \note The function shall be called at most once per step and only after all rules and symbols were added.
	 */
	virtual void assume(const LitSpan& lits);
	//! Requires enableClaspExt or throws exception.
	virtual void external(Atom_t a, Value_t v);
	//! Terminates the current step.
	virtual void endStep();
protected:
	//! Starts writing an smodels-rule of type rt.
	SmodelsOutput& startRule(int rt);
	//! Writes the given head.
	SmodelsOutput& add(Head_t ht, const AtomSpan& head);
	//! Writes the given normal body in smodels format, i.e. size(lits) size(B-) atoms in B- atoms in B+
	SmodelsOutput& add(const LitSpan&  lits);
	//! Writes the given extended body in smodels format.
	SmodelsOutput& add(Weight_t bound, const WeightLitSpan& lits, bool card);
	//! Writes i.
	SmodelsOutput& add(unsigned i);
	//! Terminates the active rule by writing a newline.
	SmodelsOutput& endRule();
	//! Throws an std::logic_error if cnd is false.
	void require(bool cnd, const char* msg) const;
	//! Returns whether the current program is incremental.
	bool incremental() const { return inc_; }
	//! Returns whether clasp extensions are enabled.
	bool extended()    const { return ext_; }
private:
	SmodelsOutput(const SmodelsOutput&);
	SmodelsOutput& operator=(const SmodelsOutput&);
	std::ostream& os_;
	Atom_t       false_;
	int          sec_;
	bool         ext_;
	bool         inc_;
	bool         fHead_;
};
///@}

}
#endif
clasp-3.2.2/liblp/potassco/theory_data.h000066400000000000000000000371551304134206100202360ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef LIBLP_THEORY_DATA_H_INCLUDED
#define LIBLP_THEORY_DATA_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#pragma warning (push)
#pragma warning (disable : 4200) // zero-sized array
#elif __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wzero-length-array"
#elif __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-pedantic"
#endif
#include 
#include 
#include 
#include 
namespace Potassco {

class TheoryData;
struct FuncData;

/*!
 * \addtogroup BasicTypes
 */
///@{
//! Supported aspif theory directives.
struct Theory_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS(Theory_t,
		Number  = 0, Symbol = 1, Compound = 2, Reserved = 3,
		Element = 4,
		Atom    = 5, AtomWithGuard = 6
	);
};

//! Supported aspif theory tuple types.
struct Tuple_t {
	//! Named constants.
	POTASSCO_ENUM_CONSTANTS_T(Tuple_t, int, -3, Bracket = -3, Brace = -2, Paren = -1);
};
//! Returns starting and ending delimiters of the given tuple type.
inline const char* toString(Tuple_t t) {
	static const char* p = "()\0{}\0[]";
	int off = (-static_cast(t)-1) * 3;
	return p + off;
}

//! A term is either a number, symbolic, or compound term (function or tuple).
class TheoryTerm {
public:
	//! Iterator type for iterating over arguments of a compound term.
	typedef const Id_t* iterator;
	//! Creates an invalid term.
	TheoryTerm();
	//! Creates a number term.
	explicit TheoryTerm(int num);
	//! Creates a symbolic term.
	explicit TheoryTerm(const char* sym);
	//! Creates a compound term.
	explicit TheoryTerm(const FuncData* c);
	//! Returns whether this object holds a valid number, symbol or compound.
	bool        valid()      const;
	//! Returns the type of this term.
	Theory_t    type()       const;
	//! Returns the number stored in this or throws if type() != Number.
	int         number()     const;
	//! Returns the symbol stored in this or throws if type() != Symbol.
	const char* symbol()     const;
	//! Returns the compound id (either term id or tuple type) stored in this or throws if type() != Compound.
	int         compound()   const;
	//! Returns whether this is a function.
	bool        isFunction() const;
	//! Returns the function id stored in this or throws if !isFunction().
	Id_t        function()   const;
	//! Returns whether this is a tuple.
	bool        isTuple()    const;
	//! Returns the tuple id stored in this or throws if !isTuple().
	Tuple_t     tuple()      const;
	//! Returns the number of arguments in this term.
	uint32_t    size()       const;
	//! Returns an iterator pointing to the first argument of this term.
	iterator    begin()      const;
	//! Returns an iterator marking the end of the arguments of this term.
	iterator    end()        const;
	//! Returns the range [begin(), end()).
	IdSpan      terms()      const { return toSpan(begin(), size()); }
private:
	friend class TheoryData;
	uint64_t  assertPtr(const void*) const;
	void      assertType(Theory_t) const;
	uintptr_t getPtr() const;
	FuncData* func() const;
	uint64_t data_;
};

//! A basic building block for a theory atom.
class TheoryElement {
public:
	//! Iterator type for iterating over the terms of an element.
	typedef const Id_t* iterator;
	//! Creates a new TheoryElement over the given terms.
	static TheoryElement* newElement(const IdSpan& terms, Id_t condition);
	//! Destroys the given TheoryElement.
	static void destroy(TheoryElement* a);
	//! Returns the number of terms belonging to this element.
	uint32_t size()  const { return nTerms_; }
	//! Returns an iterator pointing to the first term of this element.
	iterator begin() const { return term_; }
	//! Returns an iterator one past the last term of this element.
	iterator end()   const { return begin() + size(); }
	//! Returns the terms of this element.
	IdSpan   terms() const { return toSpan(begin(), size()); }
	//! Returns the condition associated with this element.
	Id_t     condition() const;
private:
	friend class TheoryData;
	TheoryElement(const IdSpan& terms, Id_t c);
	TheoryElement(const TheoryElement&);
	TheoryElement& operator=(const TheoryElement&);
	void setCondition(Id_t c);
	uint32_t nTerms_ : 31;
	uint32_t nCond_  :  1;
	Id_t     term_[0];
};

//! A theory atom.
class TheoryAtom {
public:
	//! Iterator type for iterating over the elements of a theory atom.
	typedef const Id_t* iterator;
	//! Creates a new theory atom.
	static TheoryAtom* newAtom(Id_t atom, Id_t term, const IdSpan& elements);
	//! Creates a new theory atom with guard.
	static TheoryAtom* newAtom(Id_t atom, Id_t term, const IdSpan& elements, Id_t op, Id_t rhs);
	//! Destroys the given theory atom.
	static void  destroy(TheoryAtom* a);
	
	//! Returns the associated program atom or 0 if this originated from a directive.
	Id_t       atom()       const { return static_cast(atom_); }
	//! Returns the term that is associated with this atom.
	Id_t       term()       const { return termId_; }
	//! Returns the number of elements in this atom.
	uint32_t   size()       const { return nTerms_; }
	//! Returns an iterator pointing to the first element of this atom.
	iterator   begin()      const { return term_; }
	//! Returns an iterator marking the end of elements of this atoms.
	iterator   end()        const { return begin() + size(); }
	//! Returns the range [begin(), end()).
	IdSpan     elements()   const { return toSpan(begin(), size()); }
	//! Returns a pointer to the id of the theory operator associated with this atom or 0 if atom has no guard.
	const Id_t* guard()     const;
	//! Returns a pointer to the term id of the right hand side of the theory operator or 0 if atom has no guard.
	const Id_t* rhs()       const;
private:
	TheoryAtom(Id_t atom, Id_t term, const IdSpan& elements, Id_t* op, Id_t* rhs);
	TheoryAtom(const TheoryAtom&);
	TheoryAtom& operator=(const TheoryAtom&);
	uint32_t atom_ : 31;
	uint32_t guard_:  1;
	Id_t     termId_;
	uint32_t nTerms_;
	Id_t     term_[0]; 
};

//! A type for storing and looking up theory atoms and their elements and terms.
class TheoryData {
public:
	//! Iterator type for iterating over the theory atoms of a TheoryData object.
	typedef const TheoryAtom*const* atom_iterator;
	typedef TheoryTerm    Term;
	typedef TheoryElement Element;
	TheoryData();
	~TheoryData();
	//! Sentinel for marking a condition to be set later.
	static const Id_t COND_DEFERRED = static_cast(-1);
	
	//! Resets this object to the state after default construction.
	void reset();
	//! May be called to distinguish between the current and a previous incremental step.
	void update();

	//! Adds a new theory atom.
	/*!
	 * Each element in elements shall be an id associated with an atom element 
	 * eventually added via addElement().
	 */
	const TheoryAtom& addAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements);
	//! Adds a new theory atom with guard and right hand side.
	const TheoryAtom& addAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements, Id_t op, Id_t rhs);

	//! Adds a new theory atom element with the given id.
	/*!
	 * Each element in terms shall be an id of a theory term 
	 * eventually added via one of the addTerm() overloads.
	 * \note If cond is COND_DEFERRED, the condition may later be changed via a call to setCondition().
	 */
	const TheoryElement& addElement(Id_t elementId, const IdSpan& terms, Id_t cond = COND_DEFERRED);
	//! Changes the condition of the element with the given id.
	/*!
	 * \pre The element was previously added with condition COND_DEFERRED.
	 */
	void setCondition(Id_t elementId, Id_t newCond);

	//! Adds a new number term with the given id.
	const TheoryTerm& addTerm(Id_t termId, int number);
	//! Adds a new symbolic term with the given name and id.
	const TheoryTerm& addTerm(Id_t termId, const StringSpan& name);
	//! Adds a new symbolic term with the given name and id.
	const TheoryTerm& addTerm(Id_t termId, const char* name);
	//! Adds a new function term with the given id.
	/*!
	 * The parameter funcSym represents the name of the function and shall be the id of a symbolic term.
	 * Each element in args shall be an id of a theory term.
	 */
	const TheoryTerm& addTerm(Id_t termId, Id_t funcSym, const IdSpan& args);
	//! Adds a new tuple term with the given id.
	const TheoryTerm& addTerm(Id_t termId, Tuple_t type, const IdSpan& args);

	//! Removes the term with the given id.
	/*!
	 * \note It is the caller's responsibility to ensure that the removed term is not referenced
	 * by any theory element.
	 * \note The term id of a removed term may be reused in a subsequent call to addTerm().
	 */
	void removeTerm(Id_t termId);

	//! Returns the number of stored theory atoms.
	uint32_t       numAtoms()           const;
	//! Returns an iterator pointing to the first theory atom.
	atom_iterator  begin()              const;
	//! Returns an iterator pointing to the first theory atom added after last call to update.
	atom_iterator  currBegin()          const;
	//! Returns an iterator marking the end of the range of theory atoms.
	atom_iterator  end()                const;
	//! Returns whether this object stores a term with the given id.
	bool           hasTerm(Id_t t)      const;
	//! Returns whether the given term was added after last call to update.
	bool           isNewTerm(Id_t t)    const;
	//! Returns whether this object stores an atom element with the given id.
	bool           hasElement(Id_t e)   const;
	//! Returns whether the given element was added after last call to update.
	bool           isNewElement(Id_t e) const;
	//! Returns the term with the given id or throws if no such term exists.
	const Term&    getTerm(Id_t t)      const;
	//! Returns the element with the given id or throws if no such element exists.
	const Element& getElement(Id_t e)   const;

	//! Removes all theory atoms a for which f(a) returns true.
	template 
	void filter(const F& f) {
		TheoryAtom** j = atoms() + frame_.atom;
		uint32_t pop = 0;
		for (atom_iterator it = j, end = atoms() + numAtoms(); it != end; ++it) {
			Id_t atom = (*it)->atom();
			if (!atom || !f(**it)) {
				*j++ = const_cast(*it);
			}
			else {
				pop += sizeof(*it);
				TheoryAtom::destroy(const_cast(*it));
			}
		}
		atoms_.setTop(atoms_.top() - pop);
	}
	//! Interface for visiting a theory.
	class Visitor {
	public:
		virtual ~Visitor();
		//! Visit a theory term. Should call data.accept(t, *this) to visit any arguments of the term.
		virtual void visit(const TheoryData& data, Id_t termId, const TheoryTerm& t) = 0;
		//! Visit a theory element. Should call data.accept(e, *this) to visit the terms of the element.
		virtual void visit(const TheoryData& data, Id_t elemId, const TheoryElement& e) = 0;
		//! Visit the theory atom. Should call data.accept(a, *this) to visit the elements of the atom.
		virtual void visit(const TheoryData& data, const TheoryAtom& a) = 0;
	};
	//! Calls out.visit(*this, a) for all atoms a in [currBegin(), end()).
	void accept(Visitor& out) const;
	//! Visits all terms and elements of a added in the current step.
	void accept(const TheoryAtom& a, Visitor& out) const;
	//! Visits all terms of e added in the current step.
	void accept(const TheoryElement& e, Visitor& out) const;
	//! If t is a compound term, visits subterms added in the current step.
	void accept(const TheoryTerm& t, Visitor& out) const;
private:
	struct PtrStack : public RawStack {
		typedef void* value_type;
		void push(void* ptr) { new (get(push_(sizeof(value_type)))) value_type(ptr); }
	};
	struct TermStack : public RawStack {
		void push(const TheoryTerm& t) { new (get(push_(sizeof(TheoryTerm)))) TheoryTerm(t); }
	};
	TheoryData(const TheoryData&);
	TheoryData& operator=(const TheoryData&);
	struct DestroyT;
	TheoryTerm&     setTerm(Id_t);
	TheoryTerm*     terms()    const;
	TheoryElement** elems()    const;
	TheoryAtom**    atoms()    const;
	uint32_t        numTerms() const;
	uint32_t        numElems() const;
	PtrStack  atoms_;
	PtrStack  elems_;
	TermStack terms_;
	struct Up {
		Up() : atom(0), term(0), elem(0) {}
		uint32_t atom;
		uint32_t term;
		uint32_t elem;
	} frame_;
};

/*!
 * Adaptor that couples an iterator returned from a theory atom, element, or term
 * with a TheoryData object so that dereferencing yields an object instead of an id.
 */
template 
class IteratorAdaptor : public std::iterator {
public:
	typedef IteratorAdaptor this_type;
	typedef std::iterator base_type;
	typedef typename base_type::reference reference;
	typedef typename base_type::pointer   pointer;
	IteratorAdaptor(const TheoryData& t, const Id_t* e) : data_(&t), elem_(e) {}
	IteratorAdaptor() : data_(0), elem_(0) {}
	this_type& operator++() { ++elem_; return *this; }
	this_type  operator++(int) {
		this_type t(*this);
		++*this;
		return t;
	}
	this_type& operator--() { --elem_; return *this; }
	this_type  operator--(int) {
		this_type t(*this);
		--*this;
		return t;
	}
	reference  operator*()  const { return (data_->*get)(*raw()); }
	pointer    operator->() const { return &**this; }
	
	friend void swap(this_type& lhs, this_type& rhs) {
		std::swap(lhs.data_, rhs.data_);
		std::swap(lhs.elem_, rhs.elem_);
	}
	friend bool operator==(const this_type& lhs, const this_type& rhs) {
		return lhs.data_ == rhs.data_ && lhs.elem_ == rhs.elem_;
	}
	friend bool operator!=(const this_type& lhs, const this_type& rhs) {
		return !(lhs == rhs);
	}
	const Id_t*       raw()    const { return elem_; }
	const TheoryData& theory() const { return *data_; }
private:
	const TheoryData* data_;
	const Id_t*       elem_;
};

typedef IteratorAdaptor TheoryElementIterator;
typedef IteratorAdaptor       TheoryTermIterator;

inline TheoryElementIterator begin(const TheoryData& t, const TheoryAtom& a)   { return TheoryElementIterator(t, a.begin()); }
inline TheoryElementIterator end(const TheoryData& t, const TheoryAtom& a)     { return TheoryElementIterator(t, a.end()); }
inline TheoryTermIterator    begin(const TheoryData& t, const TheoryElement& e){ return TheoryTermIterator(t, e.begin()); }
inline TheoryTermIterator    end(const TheoryData& t, const TheoryElement& e)  { return TheoryTermIterator(t, e.end()); }

StringSpan toSpan(const char* x);

inline void print(AbstractProgram& out, Id_t termId, const TheoryTerm& term) {
	switch (term.type()) {
		case Potassco::Theory_t::Number  : out.theoryTerm(termId, term.number()); break;
		case Potassco::Theory_t::Symbol  : out.theoryTerm(termId, Potassco::toSpan(term.symbol())); break;
		case Potassco::Theory_t::Compound: out.theoryTerm(termId, term.compound(), term.terms()); break;
	}
}
inline void print(AbstractProgram& out, const TheoryAtom& a) {
	if (a.guard()) { out.theoryAtom(a.atom(), a.term(), a.elements(), *a.guard(), *a.rhs()); }
	else           { out.theoryAtom(a.atom(), a.term(), a.elements()); }
}
///@}
}
#ifdef _MSC_VER
#pragma warning (pop)
#elif __GNUC__
#pragma GCC diagnostic pop
#endif
#endif
clasp-3.2.2/liblp/src/000077500000000000000000000000001304134206100145035ustar00rootroot00000000000000clasp-3.2.2/liblp/src/aspif.cpp000066400000000000000000000240111304134206100163070ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 

#include 
#include 
#include 
#include 
#include 
#include 
#if defined(_MSC_VER)
#pragma warning (disable : 4996)
#endif
namespace Potassco {
/////////////////////////////////////////////////////////////////////////////////////////
// AspifInput
/////////////////////////////////////////////////////////////////////////////////////////
AspifInput::AspifInput(AbstractProgram& out) : out_(out), data_(0) {}
AspifInput::~AspifInput() {  }

bool AspifInput::doAttach(bool& inc) {
	if (!match("asp ")) { return false; }
	require(matchPos() == 1, "unsupported major version");
	require(matchPos() == 0, "unsupported minor version");
	matchPos("revision number expected");
	while (match(" ", false)) { ; }
	inc  = match("incremental", false);
	out_.initProgram(inc);
	return require(stream()->get() == '\n', "invalid extra characters in problem line");
}
bool AspifInput::doParse() {
#define CR(r) Directive_t::r
	BasicStack data;
	data_ = &data;
	out_.beginStep();
	for (unsigned rt; (rt = matchPos(Directive_t::eMax, "rule type or 0 expected")) != 0; ) {
		data.clear();
		switch (rt) {
			default: require(false, "unrecognized rule type");
			{case CR(Rule):
				Head_t  ht = static_cast(matchPos(Head_t::eMax, "invalid head type"));
				uint32_t n = matchAtoms();
				Body_t  bt = static_cast(matchPos(Body_t::eMax, "invalid body type"));
				if (bt == Body_t::Normal) {
					LitSpan body = data.popSpan(matchLits());
					out_.rule(ht, data.popSpan(n), body);
				}
				else {
					Weight_t bound = matchInt();
					WeightLitSpan body = data.popSpan(matchWLits(0));
					out_.rule(ht, data.popSpan(n), bound, body);
				}
				break;}
			{case CR(Minimize):
				Weight_t prio = matchInt();
				out_.minimize(prio, data.popSpan(matchWLits(INT_MIN)));
				break;}
			case CR(Project):
				out_.project(data.popSpan(matchAtoms()));
				break;
			{case CR(Output): 
				uint32_t len = matchString();
				LitSpan lits = data.popSpan(matchLits());
				out_.output(data.popSpan(len), lits);
				break;}
			case CR(External): 
				if (Atom_t atom = matchAtom()) {
					Value_t val = static_cast(matchPos(Value_t::eMax, "value expected"));
					out_.external(atom, val);
				}
				break;
			case CR(Assume):
				out_.assume(data.popSpan(matchLits()));
				break;
			{case CR(Heuristic):
				Heuristic_t type = static_cast(matchPos(Heuristic_t::eMax, "invalid heuristic modifier"));	
				Atom_t      atom = matchAtom();
				int         bias = matchInt();
				unsigned    prio = matchPos(INT_MAX, "invalid heuristic priority");
				out_.heuristic(atom, type, bias, prio, data.popSpan(matchLits()));
				break;}
			{case CR(Edge): 
				unsigned start = matchPos(INT_MAX, "invalid edge, start node expected");
				unsigned end   = matchPos(INT_MAX, "invalid edge, end node expected");
				out_.acycEdge((int)start, (int)end, data.popSpan(matchLits()));
				break;}
			case CR(Theory): matchTheory(matchPos()); break;
			case CR(Comment): skipLine(); break;
		}
	}
#undef CR
	out_.endStep();
	data_ = 0;
	return true;
}	

uint32_t AspifInput::matchAtoms() {
	uint32_t len = matchPos("number of atoms expected");
	for (Atom_t* ptr = data_->makeSpan(len), *end = ptr + len; ptr != end;) { *ptr++ = matchAtom(); }
	return len;
}
uint32_t AspifInput::matchLits() {
	uint32_t len = matchPos("number of literals expected");
	for (Lit_t* ptr = data_->makeSpan(len), *end = ptr + len; ptr != end;) { *ptr++ = matchLit(); }
	return len;
}
uint32_t AspifInput::matchWLits(int32_t minW) {
	uint32_t len = matchPos("number of literals expected");
	for (WLit_t* ptr = data_->makeSpan(len), *end = ptr + len; ptr != end;) { *ptr++ = matchWLit(minW); }
	return len;
}
uint32_t AspifInput::matchTermList() {
	uint32_t len = matchPos("number of terms expected");
	for (Id_t* ptr = data_->makeSpan(len), *end = ptr + len; ptr != end;) { *ptr++ = matchPos(); }
	return len;
}
uint32_t AspifInput::matchString() {
	uint32_t len = matchPos("non-negative string length expected");
	stream()->get();
	require(stream()->copy(data_->makeSpan(len), (int)len) == (int)len, "invalid string");
	return len;
}

void AspifInput::matchTheory(unsigned rt) {
	Id_t tId = matchPos();
	switch (rt) {
		default: require(false, "unrecognized theory directive type");
		case Theory_t::Number: 
			out_.theoryTerm(tId, matchInt());
			break;
		case Theory_t::Symbol:
			out_.theoryTerm(tId, data_->popSpan(matchString()));
			break;
		case Theory_t::Compound: {
			int type = matchInt(Tuple_t::eMin, INT_MAX, "unrecognized compound term type");
			out_.theoryTerm(tId, type, data_->popSpan(matchTermList()));
			break; 
		}
		case Theory_t::Element: {
			uint32_t nt = matchTermList();
			LitSpan lits = data_->popSpan(matchLits());
			out_.theoryElement(tId, data_->popSpan(nt), lits);
			break;
		}
		case Theory_t::Atom: // fall through
		case Theory_t::AtomWithGuard: {
			Id_t termId = matchPos();
			uint32_t nt = matchTermList();
			if (rt == Theory_t::Atom) {
				out_.theoryAtom(tId, termId, data_->popSpan(nt));
			}
			else {
				Id_t opId = matchPos();
				out_.theoryAtom(tId, termId, data_->popSpan(nt), opId, matchPos());
			}
			break;
		}
	}
}

int readAspif(std::istream& in, AbstractProgram& out, ErrorHandler err) {
	AspifInput reader(out);
	return readProgram(in, reader, err);
}
/////////////////////////////////////////////////////////////////////////////////////////
// AspifOutput
/////////////////////////////////////////////////////////////////////////////////////////
AspifOutput::AspifOutput(std::ostream& os) : os_(os) {
}

AspifOutput& AspifOutput::startDir(Directive_t r) {
	os_ << static_cast(r);
	return *this;
}
AspifOutput& AspifOutput::add(int x) {
	os_ << " " << x;
	return *this;
}
AspifOutput& AspifOutput::add(const WeightLitSpan& lits) {
	os_ << " " << size(lits);
	for (const WeightLit_t* x = begin(lits); x != end(lits); ++x) {
		os_ << " " << lit(*x) << " " << weight(*x);
	}
	return *this;
}
AspifOutput& AspifOutput::add(const LitSpan& lits) {
	os_ << " " << size(lits);
	for (const Lit_t* x = begin(lits); x != end(lits); ++x) {
		os_ << " " << lit(*x);
	}
	return *this;
}
AspifOutput& AspifOutput::add(const AtomSpan& atoms) {
	os_ << " " << size(atoms);
	for (const Atom_t* x = begin(atoms); x != end(atoms); ++x) { os_ << " " << *x; }
	return *this;
}
AspifOutput& AspifOutput::add(const StringSpan& str) {
	os_ << " " << size(str) << " ";
	os_.write(begin(str), size(str));
	return *this;
}
AspifOutput& AspifOutput::endDir() {
	os_ << "\n";
	return *this;
}
void AspifOutput::initProgram(bool inc) {
	os_ << "asp 1 0 0";
	if (inc) os_ << " incremental";
	os_ << "\n";
}
void AspifOutput::rule(Head_t ht, const AtomSpan& head, const LitSpan& body) {
	startDir(Directive_t::Rule).add(static_cast(ht)).add(head)
		.add(static_cast(Body_t::Normal)).add(body)
		.endDir();
}
void AspifOutput::rule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body) {
	startDir(Directive_t::Rule).add(static_cast(ht)).add(head)
		.add(static_cast(Body_t::Sum)).add(static_cast(bound)).add(body)
		.endDir();
}
void AspifOutput::minimize(Weight_t prio, const WeightLitSpan& lits) {
	startDir(Directive_t::Minimize).add(prio).add(lits).endDir();
}
void AspifOutput::output(const StringSpan& str, const LitSpan& cond) {
	startDir(Directive_t::Output).add(str).add(cond).endDir();
}
void AspifOutput::external(Atom_t a, Value_t v) {
	startDir(Directive_t::External).add(static_cast(a)).add(static_cast(v)).endDir();
}
void AspifOutput::assume(const LitSpan& lits) {
	startDir(Directive_t::Assume).add(lits).endDir();
}
void AspifOutput::project(const AtomSpan& atoms) {
	startDir(Directive_t::Project).add(atoms).endDir();
}
void AspifOutput::acycEdge(int s, int t, const LitSpan& cond) {
	startDir(Directive_t::Edge).add(s).add(t).add(cond).endDir();
}
void AspifOutput::heuristic(Atom_t a, Heuristic_t t, int bias, unsigned prio, const LitSpan& cond) {
	startDir(Directive_t::Heuristic).add(static_cast(t)).add(static_cast(a))
		.add(bias).add(static_cast(prio)).add(cond)
		.endDir();
}
void AspifOutput::theoryTerm(Id_t termId, int number) {
	startDir(Directive_t::Theory).add(Theory_t::Number).add(termId).add(number).endDir();
}
void AspifOutput::theoryTerm(Id_t termId, const StringSpan& name) {
	startDir(Directive_t::Theory).add(Theory_t::Symbol).add(termId).add(name).endDir();
}
void AspifOutput::theoryTerm(Id_t termId, int cId, const IdSpan& args) {
	startDir(Directive_t::Theory).add(Theory_t::Compound).add(termId).add(cId).add(args).endDir();	
}
void AspifOutput::theoryElement(Id_t elementId, const IdSpan& terms, const LitSpan& cond) {
	startDir(Directive_t::Theory).add(Theory_t::Element).add(elementId).add(terms).add(cond).endDir();
}
void AspifOutput::theoryAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements) {
	startDir(Directive_t::Theory).add(Theory_t::Atom).add(atomOrZero).add(termId).add(elements).endDir();
}
void AspifOutput::theoryAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elements, Id_t op, Id_t rhs) {
	startDir(Directive_t::Theory).add(Theory_t::AtomWithGuard).add(atomOrZero).add(termId).add(elements).add(op).add(rhs).endDir();
}

void AspifOutput::beginStep() {
}
void AspifOutput::endStep() {
	os_ << "0\n";
}
}
clasp-3.2.2/liblp/src/aspif_text.cpp000066400000000000000000000206561304134206100173660ustar00rootroot00000000000000// 
// Copyright (c) 2016, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#include 
#include 
#include 
namespace Potassco {
AspifTextInput::AspifTextInput(AbstractProgram* out) : out_(out), strStart_(0), strPos_(0) {}
bool AspifTextInput::doAttach(bool& inc) {
	char n = peek(true);
	if (out_ && (!n || std::islower(static_cast(n)) || std::strchr(".#%{:", n))) {
		while (n == '%') {
			skipLine();
			n = peek(true);
		}
		inc = match("#incremental", false) && require(match("."), "unrecognized directive");
		out_->initProgram(inc);
		return true;
	}
	return false;
}

bool AspifTextInput::doParse() {
	out_->beginStep();
	if (!parseStatements()) { return false; }
	out_->endStep();
	BasicStack().swap(data_);
	return true;
}

bool AspifTextInput::parseStatements() {
	require(out_ != 0, "output not set");
	for (char c; (c = peek(true)) != 0;) {
		data_.clear();
		if      (c == '.') { match("."); }
		else if (c == '#') { if (!matchDirective()) break; }
		else if (c == '%') { skipLine(); }
		else               { matchRule(c); }
	}
	data_.clear();
	return true;
}

void AspifTextInput::matchRule(char c) {
	Head_t ht = Head_t::Disjunctive;
	Body_t bt = Body_t::Normal;
	if (c != ':') {
		if (c == '{') { match("{"); ht = Head_t::Choice; matchAtoms(";,"); match("}"); }
		else          { matchAtoms(";|"); }
	}
	else { data_.push(0u); }
	if (match(":-", false)) {
		c = peek(true);
		if (!StreamType::isDigit(c) && c != '-') {
			matchLits();
		}
		else {
			Weight_t bound = matchInt();
			matchAgg();
			data_.push(bound);
			bt = Body_t::Sum;
		}
	}
	else {
		data_.push(0u);
	}
	match(".");
	if (bt == Body_t::Normal) {
		LitSpan  body = data_.popSpan(data_.pop());
		AtomSpan head = data_.popSpan(data_.pop());
		out_->rule(ht, head, body);
	}
	else {
		typedef WeightLitSpan WLitSpan;
		Weight_t bound = data_.pop();
		WLitSpan body = data_.popSpan(data_.pop());
		AtomSpan head = data_.popSpan(data_.pop());
		out_->rule(ht, head, bound, body);
	}
}

bool AspifTextInput::matchDirective() {
	if (match("#minimize", false)) {
		matchAgg();
		Weight_t prio = match("@", false) ? matchInt() : 0;
		match(".");
		out_->minimize(prio, data_.popSpan(data_.pop()));
	}
	else if (match("#project", false)) {
		uint32_t n = 0;
		if (match("{", false) && !match("}", false)) {
			matchAtoms(",");
			match("}");
			n = data_.pop();
		}
		match(".");
		out_->project(data_.popSpan(n));
	}
	else if (match("#output", false)) {
		matchTerm();
		matchCondition();
		match(".");
		LitSpan   cond = data_.popSpan(data_.pop());
		StringSpan str = data_.popSpan(data_.pop());
		out_->output(str, cond);
	}
	else if (match("#external", false)) {
		Atom_t  a = matchId();
		Value_t v = Value_t::False;
		match(".");
		if (match("[", false)) {
			if      (match("true", false))    { v = Value_t::True; }
			else if (match("free", false))    { v = Value_t::Free; }
			else if (match("release", false)) { v = Value_t::Release; }
			else                              { match("false"); }
			match("]");
		}
		out_->external(a, v);
	}
	else if (match("#assume", false)) {
		uint32_t n = 0;
		if (match("{", false) && !match("}", false)) {
			matchLits();
			match("}");
			n = data_.pop();
		}
		match(".");
		out_->assume(data_.popSpan(n));
	}
	else if (match("#heuristic", false)) {
		Atom_t a = matchId();
		matchCondition();
		match(".");
		match("[");
		int v = matchInt();
		int p = 0;
		if (match("@", false)) { p = matchInt(); require(p >= 0, "positive priority expected"); }
		match(",");
		int h = -1;
		for (unsigned x = 0; x <= static_cast(Heuristic_t::eMax); ++x) {
			if (match(toString(static_cast(x)), false)) {
				h = static_cast(x);
				break;
			}
		}
		require(h >= 0, "unrecognized heuristic modification");
		skipws();
		match("]");
		out_->heuristic(a, static_cast(h), v, static_cast(p), data_.popSpan(data_.pop()));
	}
	else if (match("#edge", false)) {
		int s, t;
		match("("), s = matchInt(), match(","), t = matchInt(), match(")");
		matchCondition();
		match(".");
		out_->acycEdge(s, t, data_.popSpan(data_.pop()));
	}
	else if (match("#step", false)) {
		require(incremental(), "#step requires incremental program");
		match(".");
		return false;
	}
	else if (match("#incremental", false)) {
		match(".");
	}
	else {
		require(false, "unrecognized directive");
	}
	return true;
}

void AspifTextInput::skipws() {
	stream()->skipWs();
}
bool AspifTextInput::match(const char* term, bool req) {
	if (ProgramReader::match(term, false)) { skipws(); return true; }
	else if (!req) { return false; }
	else {
		startString();
		push('\'');
		while (*term) { push(*term++); }
		term = "' expected";
		while (*term) { push(*term++); }
		push('\0');
		endString();
		return require(false, data_.popSpan(data_.pop()).first);
	}
}
void AspifTextInput::matchAtoms(const char* seps) {
	for (uint32_t n = 0;;) {
		data_.push(matchId());
		++n;
		if (!std::strchr(seps, stream()->peek())) {
			data_.push(n);
			break;
		}
		stream()->get();
		skipws();
	}
}
void AspifTextInput::matchLits() {
	uint32_t n = 1;
	do {
		data_.push(matchLit());
	} while (match(",", false) && ++n);
	data_.push(n);
}
void AspifTextInput::matchCondition() {
	if (match(":", false)) { matchLits(); }
	else                   { data_.push(0u); }
}
void AspifTextInput::matchAgg() {
	uint32_t n = 0;
	if (match("{") && !match("}", false)) {
		do {
			WeightLit_t wl = {matchLit(), 1};
			if (match("=", false)) { wl.weight = matchInt(); }
			data_.push(wl);
		}
		while (++n && match(",", false));
		match("}");
	}
	data_.push(n);
}

Lit_t AspifTextInput::matchLit() {
	int s = match("not ", false) ? -1 : 1;
	return static_cast(matchId()) * s;
}

int AspifTextInput::matchInt() {
	int i = ProgramReader::matchInt();
	skipws();
	return i;
}
Atom_t AspifTextInput::matchId() {
	char c = stream()->get();
	char n = stream()->peek();
	require(std::islower(static_cast(c)) != 0, " expected");
	require(std::islower(static_cast(n)) == 0, " expected");
	if (c == 'x' && (BufferedStream::isDigit(n) || n == '_')) {
		if (n == '_') { stream()->get(); }
		int i = matchInt();
		require(i > 0, " expected");
		return static_cast(i);
	}
	else {
		skipws();
		return static_cast(c - 'a') + 1;
	}
}
void AspifTextInput::startString() {
	strStart_ = strPos_ = data_.top();
}
void AspifTextInput::endString() {
	data_.push(uint32_t(strPos_ - strStart_));
}
void AspifTextInput::push(char c) {
	if (strPos_ == data_.top()) { data_.push(0); }
	*(char*)data_.get(strPos_++) = c;
}

void AspifTextInput::matchTerm() {
	startString();
	char c = stream()->peek();
	if (std::islower(static_cast(c)) != 0 || c == '_') {
		do { push(stream()->get()); } while (std::isalnum(static_cast(c = stream()->peek())) != 0 || c == '_');
		skipws();
		if (match("(", false)) {
			push('(');
			for (;;) {
				matchAtomArg();
				if (!match(",", false)) break;
				push(',');
			}
			match(")");
			push(')');
		}
	}
	else if (c == '"') { matchStr(); }
	else { require(false, " expected"); }
	skipws();
	endString();
}
void AspifTextInput::matchAtomArg() {
	char c;
	for (int p = 0; (c = stream()->peek()) != 0; ) {
		if (c == '"') {
			matchStr();
		}
		else {
			if      (c == ')' && --p < 0) { break; }
			else if (c == ',' &&  p == 0) { break; }
			p += int(c == '(');
			push(stream()->get());
			skipws();
		}
	}
}
void AspifTextInput::matchStr() {
	match("\""), push('"');
	bool quoted = false;
	for (char c; (c = stream()->peek()) != 0 && (c != '\"' || quoted);) {
		quoted = !quoted && c == '\\';
		push(stream()->get());
	}
	match("\""), push('"');
}
}
clasp-3.2.2/liblp/src/clingo.cpp000066400000000000000000000023501304134206100164620ustar00rootroot00000000000000// 
// Copyright (c) 2015-2016, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
#include 
namespace Potassco {
AbstractAssignment::~AbstractAssignment() {}
bool AbstractAssignment::isFixed(Lit_t lit) const { return value(lit) != Value_t::Free && level(lit) == 0; }
bool AbstractAssignment::isTrue(Lit_t lit)  const { return value(lit) == Value_t::True; }
bool AbstractAssignment::isFalse(Lit_t lit) const { return value(lit) == Value_t::False; }

AbstractSolver::~AbstractSolver() {}
AbstractPropagator::~AbstractPropagator() {}
AbstractStatistics::~AbstractStatistics() {}

}
clasp-3.2.2/liblp/src/convert.cpp000066400000000000000000000252571304134206100167020ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#if (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER > 1500) || (defined(_LIBCPP_VERSION))
#include 
typedef std::unordered_map SymTab;
#else
#if defined(_MSC_VER)
#include 
#else
#include 
#endif
typedef std::tr1::unordered_map SymTab;
#endif

#if defined(_MSC_VER)
#pragma warning (disable : 4996)
#define snprintf _snprintf
#endif
namespace Potassco {
/////////////////////////////////////////////////////////////////////////////////////////
// SmodelsConvert::SmData
/////////////////////////////////////////////////////////////////////////////////////////
struct SmodelsConvert::SmData {
	struct Atom {
		Atom() : smId(0), head(0), show(0), extn(0) {}
		operator Atom_t() const { return smId; }
		unsigned smId :  28;// corresponding smodels atom
		unsigned head :  1; // atom occurs in a head of a rule
		unsigned show :  1; // atom has a name
		unsigned extn :  2; // value if atom is external
	};
	struct Heuristic {
		Atom_t      atom;
		Heuristic_t type;
		int         bias;
		unsigned    prio;
		unsigned    cond;
	};
	struct Symbol {
		unsigned     atom : 31;
		unsigned     hash :  1;
		const char*  name;
		bool operator<(const Symbol& rhs) const { return atom < rhs.atom; }
	};
	typedef std::vector           AtomMap;
	typedef std::vector         AtomVec;
	typedef std::vector          LitVec;
	typedef std::vector    WLitVec;
	typedef std::vector      HeuVec;
	typedef std::map MinMap;
	typedef std::vector         OutVec;
	SmData() : next_(2) {}
	~SmData() {
		flushStep();
		for (SymTab::iterator it = symTab_.begin(), end = symTab_.end(); it != end; ++it) {
			delete [] it->second;
		}
	}
	Atom_t newAtom()   { return next_++; }
	Atom_t falseAtom() { return 1; }
	bool   mapped(Atom_t a) const {
		return a < atoms_.size() && atoms_[a].smId != 0;
	}
	Atom&  mapAtom(Atom_t a) {
		if (mapped(a)) { return atoms_[a]; }
		if (a >= atoms_.size()) { atoms_.resize(a + 1); }
		atoms_[a].smId = next_++;
		return atoms_[a];
	}
	Lit_t  mapLit(Lit_t in) {
		Lit_t x = static_cast(mapAtom(atom(in)));
		return in < 0 ? -x : x;
	}
	WeightLit_t mapLit(WeightLit_t in) {
		in.lit = mapLit(in.lit);
		return in;
	}
	Atom_t mapHeadAtom(Atom_t a) {
		Atom& x = mapAtom(a);
		x.head = 1;
		return x;
	}
	AtomSpan mapHead(const AtomSpan& h);
	template 
	Span  mapLits(const Span& in, std::vector& out) {
		out.clear();
		for (typename Span::iterator x = begin(in); x != end(in); ++x) { out.push_back(mapLit(*x)); }
		return toSpan(out);
	}
	const char* addOutput(Atom_t atom, const StringSpan&, bool addHash);
	void addMinimize(Weight_t prio, const WeightLitSpan& lits) {
		WLitVec& body = minimize_[prio];
		body.reserve(body.size() + size(lits));
		for (const WeightLit_t* it = begin(lits); it != end(lits); ++it) {
			WeightLit_t x = *it;
			if (weight(x) < 0) {
				x.lit = -x.lit;
				x.weight = -x.weight;
			}
			body.push_back(x);
		}
	}
	void addExternal(Atom_t a, Value_t v) {
		Atom& ma = mapAtom(a);
		if (!ma.head) {
			ma.extn = static_cast(v);
			extern_.push_back(a);
		}
	}
	void addHeuristic(Atom_t a, Heuristic_t t, int bias, unsigned prio, Atom_t cond) {
		Heuristic h = {a, t, bias, prio, cond};
		heuristic_.push_back(h);
	}
	void flushStep() {
		minimize_.clear();
		AtomVec().swap(extern_);
		HeuVec().swap(heuristic_);
		for (; !output_.empty(); output_.pop_back()) {
			if (!output_.back().hash) { delete [] output_.back().name; }
		}
	}
	AtomMap atoms_;    // maps input atoms to output atoms
	MinMap  minimize_; // maps priorities to minimize statements
	AtomVec head_;     // active rule head
	LitVec  lits_;     // active body literals
	WLitVec wlits_;    // active weight body literals
	AtomVec extern_;   // external atoms
	HeuVec  heuristic_;// list of heuristic modifications not yet processed
	SymTab  symTab_;
	OutVec  output_;   // list of output atoms not yet processed
	Atom_t  next_;     // next unused output atom
};
AtomSpan SmodelsConvert::SmData::mapHead(const AtomSpan& h) {
	head_.clear();
	for (const Atom_t* x = begin(h); x != end(h); ++x) {
		head_.push_back(mapHeadAtom(*x));
	}
	if (head_.empty()) { head_.push_back(falseAtom()); }
	return toSpan(head_);
}
const char* SmodelsConvert::SmData::addOutput(Atom_t atom, const StringSpan& str, bool addHash) {
	char* n = new char[str.size + 1];
	*std::copy(begin(str), end(str), n) = 0;
	Symbol s; s.atom = atom; s.name = n; s.hash = 0;
	if (addHash && symTab_.insert(SymTab::value_type(atom, s.name)).second) {
		s.hash = 1;
	}
	output_.push_back(s);
	return s.name;
}
/////////////////////////////////////////////////////////////////////////////////////////
// SmodelsConvert
/////////////////////////////////////////////////////////////////////////////////////////
SmodelsConvert::SmodelsConvert(AbstractProgram& out, bool ext) : out_(out), data_(new SmData), ext_(ext) {}
SmodelsConvert::~SmodelsConvert() {
	delete data_;
}
Lit_t SmodelsConvert::get(Lit_t in) const {
	return data_->mapLit(in);
}
unsigned SmodelsConvert::maxAtom() const {
	return data_->next_ - 1;
}
const char* SmodelsConvert::getName(Atom_t a) const { 
	SymTab::iterator it = data_->symTab_.find(a);
	return it != data_->symTab_.end() ? it->second : 0; 
}
Atom_t SmodelsConvert::makeAtom(const LitSpan& cond, bool named) {
	Atom_t id = 0;
	if (size(cond) != 1 || cond[0] < 0 || (data_->mapAtom(atom(cond[0])).show && named)) {
		// aux :- cond.
		Atom_t aux = (id = data_->newAtom());
		out_.rule(Head_t::Disjunctive, toSpan(&aux, 1), data_->mapLits(cond, data_->lits_));
	}
	else {
		SmData::Atom& ma = data_->mapAtom(atom(*begin(cond)));
		ma.show = static_cast(named);
		id = ma.smId;
	}
	return id;
}
void SmodelsConvert::initProgram(bool inc) {
	out_.initProgram(inc);
}
void SmodelsConvert::beginStep() {
	out_.beginStep();
}
void SmodelsConvert::rule(Head_t ht, const AtomSpan& head, const LitSpan& body) {
	if (!empty(head) || ht == Head_t::Disjunctive) {
		AtomSpan mHead = data_->mapHead(head);
		out_.rule(ht, mHead, data_->mapLits(body, data_->lits_));
	}
}
void SmodelsConvert::rule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body) {
	if (!empty(head) || ht == Head_t::Disjunctive) {
		AtomSpan      mHead = data_->mapHead(head);
		WeightLitSpan mBody = data_->mapLits(body, data_->wlits_);
		if (isSmodelsRule(ht, mHead, bound, mBody)) {
			out_.rule(ht, mHead, bound, mBody);
			return;
		}
		Atom_t aux = data_->newAtom();
		data_->lits_.assign(1, lit(aux));
		out_.rule(Head_t::Disjunctive, toSpan(&aux, 1), bound, mBody);
		out_.rule(ht, mHead, toSpan(data_->lits_));
	}
}

void SmodelsConvert::minimize(Weight_t prio, const WeightLitSpan& lits) {
	data_->addMinimize(prio, lits);
}
void SmodelsConvert::output(const StringSpan& str, const LitSpan& cond) {
	// create a unique atom for cond and set its name to str
	data_->addOutput(makeAtom(cond, true), str, true);
}

void SmodelsConvert::external(Atom_t a, Value_t v) {
	data_->addExternal(a, v);
}
void SmodelsConvert::heuristic(Atom_t a, Heuristic_t t, int bias, unsigned prio, const LitSpan& cond) {
	if (!ext_) { out_.heuristic(a, t, bias, prio, cond); }
	// create unique atom representing _heuristic(...)
	Atom_t heuPred = makeAtom(cond, true);
	data_->addHeuristic(a, t, bias, prio, heuPred);
}
void SmodelsConvert::acycEdge(int s, int t, const LitSpan& condition) {
	if (!ext_) { out_.acycEdge(s, t, condition); }
	char buf[80];
	int n = snprintf(buf, sizeof(buf), "_edge(%d,%d)", s, t);
	if (n > 0 && static_cast(n) < sizeof(buf)) {
		data_->addOutput(makeAtom(condition, true), toSpan(buf, std::strlen(buf)), false);
	}
}

void SmodelsConvert::flush() {
	flushMinimize();
	flushExternal();
	flushHeuristic();
	flushSymbols();
	Lit_t f = -static_cast(data_->falseAtom());
	out_.assume(toSpan(&f, 1));
	data_->flushStep();
}
void SmodelsConvert::endStep() {
	flush();
	out_.endStep();
}
void SmodelsConvert::flushMinimize() {
	for (SmData::MinMap::iterator it = data_->minimize_.begin(), end = data_->minimize_.end(); it != end; ++it) {
		out_.minimize(it->first, data_->mapLits(toSpan(it->second), data_->wlits_));
	}
}
void SmodelsConvert::flushExternal() {
	LitSpan T = toSpan();
	data_->head_.clear();
	for (SmData::AtomVec::const_iterator it = data_->extern_.begin(), end = data_->extern_.end(); it != end; ++it) {
		SmData::Atom& a = data_->mapAtom(*it);
		Value_t vt = static_cast(a.extn);
		if (!ext_) {
			if (a.head) { continue; }
			Atom_t at = a;
			if      (vt == Value_t::Free) { data_->head_.push_back(at); }
			else if (vt == Value_t::True) { out_.rule(Head_t::Disjunctive, toSpan(&at, 1), T); }
		}
		else {
			out_.external(a, vt);
		}
	}
	if (!data_->head_.empty()) {
		out_.rule(Head_t::Choice, toSpan(data_->head_), T);
	}
}
void SmodelsConvert::flushHeuristic() {
	for (SmData::HeuVec::const_iterator it = data_->heuristic_.begin(), end = data_->heuristic_.end(); it != end; ++it) {
		const SmData::Heuristic& heu = *it;
		if (!data_->mapped(heu.atom)) { continue; }
		SmData::Atom& ma = data_->mapAtom(heu.atom);
		const char* name = ma.show ? getName(ma.smId) : 0;
		if (!name) {
			ma.show = 1;
			char buf[80];
			snprintf(buf, sizeof(buf), "_atom(%u)", ma.smId);
			name = data_->addOutput(ma, toSpan(buf, std::strlen(buf)), true);
		}
		std::string heuPred = "_heuristic(";
		heuPred += name;
		char buf[80];
		snprintf(buf, sizeof(buf), ",%s,%d,%u)", toString(heu.type), heu.bias, heu.prio);
		heuPred.append(buf);
		Lit_t c = static_cast(heu.cond);
		out_.output(toSpan(heuPred), toSpan(&c, 1));
	}
}
void SmodelsConvert::flushSymbols() {
	std::sort(data_->output_.begin(), data_->output_.end());
	for (SmData::OutVec::const_iterator it = data_->output_.begin(), end = data_->output_.end(); it != end; ++it) {
		Lit_t x = static_cast(it->atom);
		out_.output(toSpan(it->name, std::strlen(it->name)), toSpan(&x, 1));
	}
}

}
clasp-3.2.2/liblp/src/match_basic_types.cpp000066400000000000000000000300111304134206100206630ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
//
#ifdef _MSC_VER
#pragma warning (disable : 4996) // std::copy unsafe
#endif
#include 
#include 
#include 
#include 
#include 
#include 
namespace Potassco {
static std::string fmterror(const char* msg, unsigned line) {
	char buf[80];
	sprintf(buf, "parse error in line %u: ", line);
	return std::string(buf).append(msg);
}
AbstractProgram::~AbstractProgram() {}
void AbstractProgram::initProgram(bool) {}
void AbstractProgram::beginStep() {}
void AbstractProgram::project(const AtomSpan&) { throw std::logic_error("projection directive not supported"); }
void AbstractProgram::output(const StringSpan&, const LitSpan&) { throw std::logic_error("output directive not supported"); }
void AbstractProgram::external(Atom_t, Value_t) { throw std::logic_error("external directive not supported"); }
void AbstractProgram::assume(const LitSpan&) { throw std::logic_error("assumption directive not supported"); }
void AbstractProgram::heuristic(Atom_t, Heuristic_t, int, unsigned, const LitSpan&) { throw std::logic_error("heuristic directive not supported"); }
void AbstractProgram::acycEdge(int, int, const LitSpan&) { throw std::logic_error("edge directive not supported"); }
void AbstractProgram::theoryTerm(Id_t, int) { throw std::logic_error("theory data not supported"); }
void AbstractProgram::theoryTerm(Id_t, const StringSpan&)  { throw std::logic_error("theory data not supported"); }
void AbstractProgram::theoryTerm(Id_t, int, const IdSpan&) { throw std::logic_error("theory data not supported"); }
void AbstractProgram::theoryElement(Id_t, const IdSpan&, const LitSpan&) { throw std::logic_error("theory data not supported"); }
void AbstractProgram::theoryAtom(Id_t, Id_t, const IdSpan&) { throw std::logic_error("theory data not supported"); }
void AbstractProgram::theoryAtom(Id_t, Id_t, const IdSpan&, Id_t, Id_t) { throw std::logic_error("theory data not supported"); }
void AbstractProgram::endStep() {}
const StringSpan Heuristic_t::pred ={"_heuristic(", 11};
ParseError::ParseError(unsigned a_line, const char* a_msg) 
	: std::logic_error(fmterror(a_msg, a_line))
	, line(a_line) {
}
/////////////////////////////////////////////////////////////////////////////////////////
// BufferedStream
/////////////////////////////////////////////////////////////////////////////////////////
BufferedStream::BufferedStream(std::istream& str) : str_(str), rpos_(0), line_(1) {
	buf_ = new char[ALLOC_SIZE];
	underflow();
}
BufferedStream::~BufferedStream() {
	delete [] buf_;
}
char BufferedStream::rget() {
	char c = peek();
	if (!buf_[++rpos_]) { underflow(); }
	return c;
}
char BufferedStream::get() {
	if (char c = peek()) {
		rget();
		if (c == '\r') {
			c = '\n';
			if (peek() == '\n') rget();
		}
		if (c == '\n') { ++line_; }
		return c;
	}
	return 0;
}
void BufferedStream::skipWs() {
	for (char c; (c = peek()) >= 9 && c < 33;) { get(); }
}

void BufferedStream::underflow(bool upPos) {
	if (!str_) return;
	if (upPos && rpos_) {
		// keep last char for unget
		buf_[0] = buf_[rpos_ - 1];
		rpos_ = 1;
	}
	std::size_t n = ALLOC_SIZE - (1 + rpos_);
	str_.read(buf_ + rpos_, n);
	std::size_t r = static_cast(str_.gcount());
	buf_[r + rpos_] = 0;
}
bool BufferedStream::unget(char c) {
	if (!rpos_) return false;
	if ( (buf_[--rpos_] = c) == '\n') { --line_; }
	return true;
}
bool BufferedStream::match(const char* w) {
	std::size_t wLen = std::strlen(w);
	std::size_t bLen = BUF_SIZE - rpos_;
	if (bLen < wLen) {
		if (wLen > BUF_SIZE) { throw std::logic_error("Token too long - Increase BUF_SIZE!"); }
		std::memcpy(buf_, buf_ + rpos_, bLen);
		rpos_ = bLen;
		underflow(false);
		rpos_ = 0;
	}
	if (std::strncmp(w, buf_ + rpos_, wLen) == 0) {
		if (!buf_[rpos_ += wLen]) { underflow(); }
		return true;
	}
	return false;
}
bool BufferedStream::match(int64_t& res, bool noSkipWs) {
	if (!noSkipWs) { skipWs(); }
	char s = peek();
	if (s == '+' || s == '-') { rget(); }
	if (!isDigit(peek())) { return false; }
	for (res = toDigit(rget()); isDigit(peek()); ) {
		res *= 10;
		res += toDigit(rget());
	}
	if (s == '-') { res = -res; }
	return true;
}
int BufferedStream::copy(char* out, int max) {
	if (max < 0) return max;
	std::size_t os = 0;
	for (std::size_t n = static_cast(max); n && peek();) {
		std::size_t b = (ALLOC_SIZE - rpos_) - 1;
		std::size_t m = std::min(n, b);
		out = std::copy(buf_ + rpos_, buf_ + rpos_ + m, out);
		n -= m;
		os += m;
		rpos_ += m;
		if (!peek()) { underflow(); }
	}
	return static_cast(os);
}
unsigned BufferedStream::line() const { return line_; }
/////////////////////////////////////////////////////////////////////////////////////////
// ProgramReader
/////////////////////////////////////////////////////////////////////////////////////////
ProgramReader::ProgramReader() : str_(0), varMax_(static_cast(INT_MAX)), inc_(false) {}
ProgramReader::~ProgramReader() { delete str_; }
bool ProgramReader::accept(std::istream& str) {
	reset();
	str_ = new StreamType(str);
	inc_ = false;
	return doAttach(inc_);
}
bool ProgramReader::incremental() const {
	return inc_;
}
bool ProgramReader::parse(ReadMode m) {
	if (str_ == 0)  { throw ParseError(1, "no input stream"); }
	do {
		if (!doParse()) { return false; }
		stream()->skipWs();
		require(!more() || incremental(), "invalid extra input");
	} while (m == Complete && more());
	return true;
}
bool ProgramReader::more() {
	return str_ && (str_->skipWs(), !str_->end());
}
void ProgramReader::reset() {
	delete str_; str_ = 0;
	doReset();
}
void ProgramReader::doReset() {}
unsigned ProgramReader::line()   const { return str_ ? str_->line() : 1; }
BufferedStream* ProgramReader::stream() const { return str_; }
bool ProgramReader::require(bool cnd, const char* msg) const { return cnd || (throw ParseError(line(), msg), false); }
char ProgramReader::peek(bool skipws) const { if (skipws) str_->skipWs(); return str_->peek(); }
void ProgramReader::skipLine() {
	while (str_->peek() && str_->get() != '\n') {}
}
int readProgram(std::istream& str, ProgramReader& reader, ErrorHandler err) {
	try {
		if (!reader.accept(str) || !reader.parse(ProgramReader::Complete)) { 
			throw ParseError(reader.line(), "invalid input format"); 
		}
	}
	catch (const ParseError& e) {
		if (!err) { throw; }
		return err(e.line, e.what());
	}
	catch (const std::exception& e) {
		if (!err) { throw; }
		return err(reader.line(), e.what());
	}
	return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// String matching
/////////////////////////////////////////////////////////////////////////////////////////
bool match(const char*& input, const char* word) {
	std::size_t len = std::strlen(word);
	if (std::strncmp(input, word, len) == 0) {
		input += len;
		return true;
	}
	return false;
}
bool matchAtomArg(const char*& input, StringSpan& arg) {
	const char* scan = input;
	for (int p = 0; *scan; ++scan) {
		if      (*scan == '(') { ++p; }
		else if (*scan == ')') { if (--p < 0) { break; } }
		else if (*scan == ',') { if (p == 0) { break; } }
		else if (*scan == '"') {
			bool quoted = false;
			for (++scan; *scan && (*scan != '\"' || quoted); ++scan) {
				quoted = !quoted && *scan == '\\';
			}
			if (!*scan) { return false; }
		}
	}
	arg = toSpan(input, static_cast(scan - input));
	input = scan;
	return arg.size != 0;
}
bool match(const char*& input, Heuristic_t& heuType) {
	for (unsigned x = 0; x <= static_cast(Heuristic_t::eMax); ++x) {
		if (match(input, toString(static_cast(x)))) {
			heuType = static_cast(x);
			return true;
		}
	}
	return false;
}

bool match(const char*& input, int& out) {
	char* eptr;
	long t = std::strtol(input, &eptr, 10);
	if (eptr == input || t < INT_MIN || t > INT_MAX) {
		return false;
	}
	out = static_cast(t);
	input = eptr;
	return true;
}

int matchDomHeuPred(const char*& in, StringSpan& atom, Heuristic_t& type, int& bias, unsigned& prio) {
	int p;
	if (!match(in, begin(Heuristic_t::pred))) { return 0; }
	if (!matchAtomArg(in, atom) || !match(in, ",")) { return -1; }
	if (!match(in, type)        || !match(in, ",")) { return -2; }
	if (!match(in, bias)) { return -3; }
	prio = static_cast(bias < 0 ? -bias : bias);
	if (!match(in, ",")) { return match(in, ")") ? 1 : -3; }
	if (!match(in, p) || p < 0) { return -4; }
	prio = static_cast(p);
	return match(in, ")") ? 1 : -4;
}

int matchEdgePred(const char*& in, StringSpan& n0, StringSpan& n1) {
	int sPos, tPos, ePos = -1;
	if (sscanf(in, "_acyc_%*d_%n%*d_%n%*d%n", &sPos, &tPos, &ePos) == 0 && ePos > 0) {
		n0 = toSpan(in + sPos, (tPos - sPos) - 1);
		n1 = toSpan(in + tPos, ePos - tPos);
		in += ePos;
		return size(n0) > 0 && size(n1) > 0 ? 1 : -1;
	}
	else if (match(in, "_edge(")) {
		if (!matchAtomArg(in, n0) || !match(in, ",")) { return -1; }
		if (!matchAtomArg(in, n1) || !match(in, ")")) { return -2; }
		return 1;
	}
	return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Data stack
/////////////////////////////////////////////////////////////////////////////////////////
RawStack::RawStack() : mem_(0), top_(0), cap_(0) {}
RawStack::~RawStack() { std::free(mem_); }
RawStack::RawStack(const RawStack& other) {
	mem_ = (unsigned char*)std::malloc(other.top());
	std::memcpy(mem_, other.mem_, other.top());
	top_ = cap_ = other.top();
}
RawStack& RawStack::operator=(const RawStack& other) {
	RawStack(other).swap(*this);
	return *this;
}
void RawStack::swap(RawStack& other) {
	std::swap(mem_, other.mem_);
	std::swap(top_, other.top_);
	std::swap(cap_, other.cap_);
}
uint32_t RawStack::top() const {
	return top_;
}
uint32_t RawStack::capacity() const {
	return cap_;
}
void RawStack::clear() {
	top_ = 0;
}
void RawStack::reserve(uint32_t nc) {
	if (nc > capacity()) {
		unsigned char* t = (unsigned char*)std::realloc(mem_, nc);
		if (!t) throw std::bad_alloc();
		mem_ = t;
		cap_ = nc;
	}
}

void RawStack::setTop(uint32_t idx) {
	assert(idx <= cap_);
	top_ = idx;
}
uint32_t RawStack::pop_(uint32_t sz) {
	assert(sz <= top_);
	return top_ -= sz;
}
uint32_t RawStack::push_(uint32_t nSize) {
	uint32_t ret = top_;
	if ((top_ += nSize) >= ret) {
		if (top_ > cap_) {
			uint32_t nc = (capacity() * 3) >> 1;
			if (top_ > nc) { nc = top_ > 64u ? top_ : 64u; }
			reserve(nc);
		}
		return ret;
	}
	else {
		throw std::bad_alloc();
	}
}
void* RawStack::get(uint32_t idx) const {
	assert(idx <= cap_);
	return mem_ + idx;
}

void BasicStack::push(uint32_t obj) {
	uint32_t* x; push(&x, 1);
	*x = obj;
}
void BasicStack::push(WeightLit_t obj) {
	WeightLit_t* x; push(&x, 1);
	*x = obj;
}
template 
void BasicStack::push(T** x, uint32_t len) {
	*x = (T*)get(push_(sizeof(T) * len));
}
void BasicStack::push(char** x, uint32_t len) {
	if (uint32_t mod = (len & (sizeof(uint32_t)-1))) {
		len += sizeof(uint32_t) - mod;
	}
	*x = (char*)get(push_(len));
}
template 
void BasicStack::pop(const T** x, uint32_t len) {
	this->setTop(this->top() - (sizeof(T) * len));
	*x = (T*)this->get(this->top());
}
void BasicStack::pop(const char** x, uint32_t len) {
	if (uint32_t mod = (len & (sizeof(uint32_t)-1))) {
		len += sizeof(uint32_t) - mod;
	}
	setTop(top() - len);
	*x = (char*)this->get(top());
}
#define INSTANTIATE_STACK(T) \
template void BasicStack::push(T**, uint32_t);\
template void BasicStack::pop(const T**, uint32_t)

INSTANTIATE_STACK(uint32_t);
INSTANTIATE_STACK(int32_t);
INSTANTIATE_STACK(WeightLit_t);
#undef INSTANTIATE_STACK
}
clasp-3.2.2/liblp/src/rule_utils.cpp000066400000000000000000000162331304134206100174030ustar00rootroot00000000000000// 
// Copyright (c) 2016, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#include 
#include 
#include 
namespace Potassco {
Rule_t Rule_t::normal(Head_t ht, const AtomSpan& head, const LitSpan& body) {
	Rule_t r = {ht, head, Body_t::Normal, {body}};
	return r;
}
Rule_t Rule_t::sum(Head_t ht, const AtomSpan& head, const Sum_t& sum) {
	Rule_t r = {ht, head, Body_t::Sum, {}};
	r.agg = sum;
	return r;
}
Rule_t Rule_t::sum(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& lits) {
	Sum_t s = {lits, bound};
	return sum(ht, head, s);
}
/////////////////////////////////////////////////////////////////////////////////////////
// RuleBuilder
/////////////////////////////////////////////////////////////////////////////////////////
struct RuleBuilder::RuleInfo {
	enum STATE { active = 1u, done = 2u };
	enum TYPE { rule = 0u, minimize = 1u };
	uint32_t type   : 30;
	uint32_t state  :  2;
	uint32_t head   : 28;
	uint32_t hType  :  2;
	uint32_t hState :  2;
	uint32_t hSize;
	uint32_t body   : 28;
	uint32_t bType  :  2;
	uint32_t bState :  2;
	uint32_t bSize;
	Weight_t bound;
};
RuleBuilder::RuleBuilder() {
	clear();
}
void RuleBuilder::require(bool cnd, const char* msg) const {
	if (!cnd) { throw std::logic_error(msg); }
}
RuleBuilder& RuleBuilder::clear() {
	data_.clear();
	RuleInfo* r = data_.push();
	std::memset(r, 0, sizeof(RuleInfo));
	r->state = RuleInfo::active;
	r->type = Directive_t::Rule;
	return *this;
}
RuleBuilder& RuleBuilder::clearBody() {
	RuleInfo* r = info();
	if (r->body >= r->head) {
		data_.setTop(r->body);
		r->bState = 0;
	}
	r->bSize = 0;
	r->bType = Body_t::Normal;
	return *this;
}

RuleBuilder::RuleInfo* RuleBuilder::info() const {
	return static_cast(data_.get(0));
}
RuleBuilder::RuleInfo* RuleBuilder::init() {
	RuleInfo* r = info();
	if (r->state == RuleInfo::done) {
		clear();
		r = info();
	}
	return r;
}
RuleBuilder& RuleBuilder::start(Head_t ht) {
	RuleInfo* r = init();
	if (r->hState != RuleInfo::active) {
		require(r->hState == 0u && r->type == Directive_t::Rule, "invalid call to start()");
		endBody();
		r->head = data_.top();
		r->hType = ht;
		r->hState = RuleInfo::active;
		r->hSize = 0;
	}
	return *this;
}
RuleBuilder& RuleBuilder::addHead(Atom_t a) {
	RuleInfo* r = init();
	if (r->hState != RuleInfo::active) { start(); }
	++r->hSize;
	*data_.push() = a;
	return *this;
}
RuleBuilder& RuleBuilder::startBody() { startBody(Body_t::Normal, -1); return *this; }
RuleBuilder& RuleBuilder::startSum(Weight_t bound) { startBody(Body_t::Sum, bound); return *this; }
RuleBuilder& RuleBuilder::startMinimize(Weight_t prio) {
	RuleInfo* r = init();
	require(!r->head && !r->body, "invalid call to startMinimize()");
	r->type = Directive_t::Minimize;
	return startSum(prio);
}
RuleBuilder::RuleInfo* RuleBuilder::startBody(Body_t bt, Weight_t bnd) {
	RuleInfo* r = init();
	if (r->bState != RuleInfo::active) {
		require(r->bState == 0u, "invalid call to startBody()");
		endHead();
		r->body = data_.top();
		r->bType = bt;
		r->bState = RuleInfo::active;
		r->bound = bnd;
		r->bSize = 0;
	}
	return r;
}
RuleBuilder& RuleBuilder::addGoal(Lit_t lit) {
	return addGoal(lit, 1);
}
RuleBuilder& RuleBuilder::addGoal(Lit_t lit, Weight_t w) {
	WeightLit_t wl = {lit, w};
	addGoal(wl);
	return *this;
}
RuleBuilder& RuleBuilder::addGoal(WeightLit_t lit) {
	RuleInfo* r = startBody(Body_t::Normal, -1);
	if (lit.weight == 0) { return *this; }
	++r->bSize;
	if (r->bType == Body_t::Normal) {
		*data_.push() = lit.lit;
	}
	else {
		*data_.push() = lit;
	}
	return *this;
}
RuleBuilder& RuleBuilder::setBound(Weight_t bound) {
	info()->bound = bound;
	return *this;
}
void RuleBuilder::endHead() {
	RuleInfo* r = init();
	if (r->hState == RuleInfo::active) { r->hState = RuleInfo::done; }
}
void RuleBuilder::endBody() {
	RuleInfo* r = init();
	if (r->bState == RuleInfo::active) { r->bState = RuleInfo::done; }
}
RuleBuilder& RuleBuilder::end(AbstractProgram* out) {
	RuleInfo* r = info();
	if (r->state != RuleInfo::done) {
		if (!r->head && r->type == Directive_t::Rule) { start(); }
		endHead();
		if (!r->body) { startBody(); }
		endBody();
		r->state = RuleInfo::done;
	}
	if (!out) { return *this; }
	if (r->type == Directive_t::Minimize) {
		out->minimize(r->bound, toSpan(static_cast(data_.get(r->body)), r->bSize));
	}
	else if (r->bType == Body_t::Normal) {
		out->rule(static_cast(r->hType), toSpan(static_cast(data_.get(r->head)), r->hSize),
			toSpan(static_cast(data_.get(r->body)), r->bSize));
	}
	else {
		out->rule(static_cast(r->hType), toSpan(static_cast(data_.get(r->head)), r->hSize),
			r->bound, toSpan(static_cast(data_.get(r->body)), r->bSize));
	}
	return *this;
}
uint32_t     RuleBuilder::bodySize() const { return info()->bSize; }
uint32_t     RuleBuilder::headSize() const { return info()->hSize; }
Body_t       RuleBuilder::bodyType() const { return static_cast(info()->bType); }
Atom_t*      RuleBuilder::head()     const { return static_cast(data_.get(info()->head)); }
Lit_t*       RuleBuilder::body()     const { return static_cast(data_.get(info()->body)); }
WeightLit_t* RuleBuilder::sum()      const { return static_cast(data_.get(info()->body)); }
Weight_t     RuleBuilder::bound()    const { return info()->bound; }
RuleBuilder& RuleBuilder::weaken(Body_t to, bool w) {
	RuleInfo* r = info();
	if (r->bType != Body_t::Normal && to != r->bType) {
		if (to == Body_t::Normal) {
			Lit_t* x = body();
			for (WeightLit_t* w = sum(), *end = w + r->bSize; w != end; ++w) { *x++ = w->lit; }
			data_.setTop(r->body + (r->bSize * sizeof(Lit_t)));
			r->bType = Body_t::Normal;
		}
		else if (to == Body_t::Count) {
			Weight_t min = 1;
			if (w && r->bSize) {
				min = sum()->weight;
				for (WeightLit_t* it = sum(), *end = it + r->bSize; it != end; ++it) {
					if (min > it->weight) { min = it->weight; }
					it->weight = 1;
				}
			}
			r->bound = (r->bound+(min-1))/min;
			r->bType = Body_t::Count;
		}
	}
	return *this;
}
Rule_t RuleBuilder::rule() const {
	RuleInfo* r = info();
	Rule_t ret;
	ret.ht   = static_cast(r->hType);
	ret.head = toSpan(static_cast(data_.get(r->head)), r->hSize);
	ret.bt   = static_cast(r->bType);
	if (r->bType == Body_t::Normal) {
		ret.cond = toSpan(static_cast(data_.get(r->body)), r->bSize);
	}
	else {
		ret.agg.bound = r->bound;
		ret.agg.lits = toSpan(static_cast(data_.get(r->body)), r->bSize);
	}
	return ret;
}
}
clasp-3.2.2/liblp/src/smodels.cpp000066400000000000000000000330761304134206100166660ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#include 
#include 
#include 
#include 
#include 
#if (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER > 1500) || (defined(_LIBCPP_VERSION))
#include 
typedef std::unordered_map StrMap;
#else
#if defined(_MSC_VER)
#include 
#else
#include 
#endif
typedef std::tr1::unordered_map StrMap;
#endif
namespace Potassco {

enum SmodelsRule {
	End         = 0,
	Basic       = 1, Cardinality = 2, Choice   = 3,
	Generate    = 4, Weight      = 5, Optimize = 6, 
	Disjunctive = 8,
	ClaspIncrement = 90, ClaspAssignExt = 91, ClaspReleaseExt = 92
};
int isSmodelsHead(Head_t t, const AtomSpan& head) {
	if (empty(head))         { return End; }
	if (t == Head_t::Choice) { return Choice; }
	return size(head) == 1 ? Basic : Disjunctive;
}

int isSmodelsRule(Head_t t, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body) {
	if (isSmodelsHead(t, head) != Basic || bound < 0) { return End; }
	for (WeightLitSpan::iterator it = begin(body), end = Potassco::end(body); it != end; ++it) {
		if (weight(*it) != 1) { return Weight; }
	}
	return Cardinality;
}
AtomTable::~AtomTable() {}
/////////////////////////////////////////////////////////////////////////////////////////
// SmodelsInput
/////////////////////////////////////////////////////////////////////////////////////////
struct SmodelsInput::SymTab : public AtomTable{
	SymTab(AbstractProgram& o) : out(&o) {}
	virtual void add(Atom_t id, const StringSpan& name, bool output) {
		atoms.insert(StrMap::value_type(std::string(Potassco::begin(name), Potassco::end(name)), id));
		if (output) {
			Lit_t lit = static_cast(id);
			out->output(name, toSpan(&lit, 1));
		}
	}
	virtual Atom_t find(const StringSpan& name) {
		temp.assign(Potassco::begin(name), Potassco::end(name));
		StrMap::const_iterator it = atoms.find(temp);
		return it != atoms.end() ? it->second : 0;
	}
	struct Heuristic {
		std::string atom;
		Heuristic_t type;
		int         bias;
		unsigned    prio;
		Lit_t       cond;
	};
	StrMap           atoms;
	std::string      temp;
	AbstractProgram* out;
};
struct SmodelsInput::NodeTab {
	Id_t add(const StringSpan& n) {
		return nodes.insert(StrMap::value_type(std::string(begin(n), end(n)), (Id_t)nodes.size())).first->second;
	}
	StrMap nodes;
};
SmodelsInput::SmodelsInput(AbstractProgram& out, const Options& opts, AtomTable* syms) : out_(out), atoms_(syms), nodes_(0), opts_(opts), delSyms_(false) {}
SmodelsInput::~SmodelsInput() { if (delSyms_) delete atoms_; delete nodes_; }
void SmodelsInput::doReset() {}
bool SmodelsInput::doAttach(bool& inc) {
	char n = stream()->peek();
	if (BufferedStream::isDigit(n) && ((inc = (n == '9')) == false || opts_.claspExt)) {
		out_.initProgram(inc);
		return true;
	}
	return false;
}

bool SmodelsInput::doParse() {
	out_.beginStep();
	if (readRules() && readSymbols() && readCompute("B+", true) && readCompute("B-", false) && readExtra()) {
		out_.endStep();
		return true;
	}
	return false;
}

uint32_t SmodelsInput::matchBody(BasicStack& stack) {
	uint32_t len = matchPos();
	uint32_t neg = matchPos();
	for (Lit_t* x = stack.makeSpan(len), *end = x + len; x != end; ++x) {
		*x = lit(matchAtom());
		if (neg) { *x *= -1; --neg; }
	}
	return len;
}

uint32_t SmodelsInput::matchSum(BasicStack& stack, bool weights) {
	uint32_t bnd = matchPos();
	uint32_t len = matchPos();
	uint32_t neg = matchPos();
	if (!weights) { std::swap(len, bnd); std::swap(bnd, neg); }
	WeightLit_t* wl = stack.makeSpan(len);
	for (WeightLit_t* x = wl, *end = wl + len; x != end; ++x) {
		WeightLit_t lit = {static_cast(matchAtom()), 1};
		if (neg) { lit.lit *= -1; --neg; }
		*x = lit;
	}
	if (weights) {
		for (WeightLit_t* x = wl, *end = wl + len; x != end; ++x) {
			x->weight = (Weight_t)matchPos("non-negative weight expected");
		}
	}
	stack.push(bnd);
	return len;
}
bool SmodelsInput::readRules() {
	BasicStack data;
	Weight_t minPrio = 0;
	for (unsigned rt; (rt = matchPos("rule type expected")) != 0;) {
		data.clear();
		Atom_t rHead;
		switch (rt) {
			default: require(false, "unrecognized rule type");
			case Choice: case Disjunctive: { // n a1..an
				rHead = matchAtom("positive head size expected");
				for (unsigned i = rHead; i--;) { data.push(matchAtom()); }
				LitSpan  body = data.popSpan(matchBody(data));
				AtomSpan head = data.popSpan(rHead);
				out_.rule(rt == Choice ? Head_t::Choice : Head_t::Disjunctive, head, body);
				break; }
			case Basic:
				rHead = matchAtom();
				out_.rule(Head_t::Disjunctive, toSpan(&rHead, 1), data.popSpan(matchBody(data)));
				break;
			case Cardinality: // fall through
			case Weight:{     // fall through
				rHead = matchAtom();
				uint32_t nLits = matchSum(data, rt != Cardinality);
				Weight_t bound = (Weight_t)data.pop();
				out_.rule(Head_t::Disjunctive, toSpan(&rHead, 1), bound, data.popSpan(nLits));
				break; }
			case Optimize: {
				uint32_t nLits = matchSum(data, true);
				require(data.pop() == 0, "unrecognized type of optimize rule");
				out_.minimize(minPrio++, data.popSpan(nLits));
				break; }
			case ClaspIncrement:
				require(opts_.claspExt && matchPos() == 0, "unrecognized rule type");
				break;
			case ClaspAssignExt:
			case ClaspReleaseExt:
				require(opts_.claspExt, "unrecognized rule type");
				rHead = matchAtom();
				if (rt == ClaspAssignExt) {
					out_.external(rHead, static_cast((matchPos(2, "0..2 expected") ^ 3) - 1));
				}
				else {
					out_.external(rHead, Value_t::Release);
				}
				break;
		}
	}
	return true;
}

bool SmodelsInput::readSymbols() {
	std::string name;
	if (opts_.cEdge && !nodes_) { nodes_ = new NodeTab; }
	if (opts_.cHeuristic && !atoms_) { atoms_ = new SymTab(out_); delSyms_ = true; }
	StringSpan n0, n1;
	SymTab::Heuristic heu;
	std::vector doms;
	for (Lit_t atom; (atom = (Lit_t)matchPos()) != 0;) {
		name.clear();
		stream()->get();
		for (char c; (c = stream()->get()) != '\n';) {
			require(c != 0, "atom name expected!");
			name += c;
		}
		const char* n = name.c_str();
		bool filter = false;
		if (opts_.cEdge && matchEdgePred(n, n0, n1) > 0) {
			Id_t s = nodes_->add(n0);
			Id_t t = nodes_->add(n1);
			out_.acycEdge(static_cast(s), static_cast(t), toSpan(&atom, 1));
			filter = opts_.filter;
		}
		else if (opts_.cHeuristic && matchDomHeuPred(n, n0, heu.type, heu.bias, heu.prio) > 0) {
			heu.cond = atom;
			heu.atom.assign(Potassco::begin(n0), Potassco::end(n0));
			doms.push_back(heu);
			filter = opts_.filter;
		}
		if      (atoms_)  { atoms_->add(atom, toSpan(name), !filter); }
		else if (!filter) { out_.output(toSpan(name), toSpan(&atom, 1)); }
	}
	for (std::vector::const_iterator it = doms.begin(), end = doms.end(); it != end; ++it) {
		if (Atom_t x = atoms_->find(toSpan(it->atom))) {
			out_.heuristic(x, it->type, it->bias, it->prio, toSpan(&it->cond, 1));
		}
	}
	if (!incremental()) {
		delete nodes_;
		if (delSyms_) delete atoms_;
		nodes_ = 0;
		atoms_ = 0;
	}
	return true;
}

bool SmodelsInput::readCompute(const char* comp, bool val) {
	require(match(comp) && stream()->get() == '\n', "compute statement expected");
	for (Lit_t x; (x = (Lit_t)matchPos()) != 0;) {
		if (val) { x = neg(x); }
		out_.rule(Head_t::Disjunctive, toSpan(), toSpan(&x, 1));
	}
	return true;
}

bool SmodelsInput::readExtra() {
	if (match("E")) {
		for (Atom_t atom; (atom = matchPos()) != 0;) {
			out_.external(atom, Value_t::Free);
		}
	}
	matchPos("number of models expected");
	return true;
}

int readSmodels(std::istream& in, AbstractProgram& out, ErrorHandler err, const SmodelsInput::Options& opts) {
	SmodelsInput reader(out, opts);
	return readProgram(in, reader, err);
}
/////////////////////////////////////////////////////////////////////////////////////////
// SmodelsOutput
/////////////////////////////////////////////////////////////////////////////////////////
namespace {
	struct Atom     { template  Atom_t operator()(T x) const { return atom(x); } };
	struct SmWeight { uint32_t operator()(const WeightLit_t& x) const { return static_cast(x.weight >= 0 ? x.weight : -x.weight); } };
	inline Lit_t smLit(const WeightLit_t& x) { return x.weight >= 0 ? x.lit : -x.lit; }
	inline Lit_t smLit(Lit_t x)              { return x; }
	template 
	static unsigned negSize(const Potassco::Span& lits) {
		unsigned r = 0;
		for (const T* it = Potassco::begin(lits), *end = Potassco::end(lits); it != end; ++it) { r += smLit(*it) < 0; }
		return r;
	}
	template 
	static void print(std::ostream& os, const Span& span, unsigned neg, unsigned pos, Op op) {
		for (const T* it = begin(span); neg; ++it) { if (smLit(*it)  < 0) { os << " " << op(*it); --neg; } }
		for (const T* it = begin(span); pos; ++it) { if (smLit(*it) >= 0) { os << " " << op(*it); --pos; } }
	}
}
SmodelsOutput::SmodelsOutput(std::ostream& os, bool ext, Atom_t fAtom) : os_(os), false_(fAtom), sec_(0), ext_(ext), inc_(false), fHead_(false) {}
SmodelsOutput& SmodelsOutput::startRule(int rt) { os_ << rt; return *this; }
SmodelsOutput& SmodelsOutput::add(unsigned i)   { os_ << " " << i; return *this; }
SmodelsOutput& SmodelsOutput::add(Head_t ht, const AtomSpan& head) {
	if (ht == Head_t::Choice || size(head) > 1) { add((unsigned)size(head)); }
	for (const Atom_t* x = begin(head); x != end(head); ++x) { add(*x); }
	return *this;
}

SmodelsOutput& SmodelsOutput::add(const LitSpan& lits) {
	unsigned neg = negSize(lits), size = static_cast(Potassco::size(lits));
	add(size).add(neg);
	print(os_, lits, neg, size - neg, Atom());
	return *this;
}
SmodelsOutput& SmodelsOutput::add(Weight_t bnd, const WeightLitSpan& lits, bool card) {
	unsigned neg = negSize(lits), size = static_cast(Potassco::size(lits));
	if (!card) { add(static_cast(bnd)); }
	add(size).add(neg);
	if (card)  { add(static_cast(bnd)); }
	print(os_, lits, neg, size - neg, Atom());
	if (!card) { print(os_, lits, neg, size - neg, SmWeight()); }
	return *this;
}
SmodelsOutput& SmodelsOutput::endRule() {
	os_ << "\n";
	return *this;
}
void SmodelsOutput::require(bool cnd, const char* msg) const {
	if (!cnd) { throw std::logic_error(msg); }
}
void SmodelsOutput::initProgram(bool b) { 
	inc_ = b;
	require(!inc_ || ext_, "incremental programs not supported in smodels format");
}
void SmodelsOutput::beginStep() {
	if (ext_ && inc_) { startRule(ClaspIncrement).add(0).endRule(); }
	sec_ = 0;
	fHead_ = false;
}
void SmodelsOutput::rule(Head_t ht, const AtomSpan& head, const LitSpan& body) {
	require(sec_ == 0, "adding rules after symbols not supported");
	if (empty(head)) {
		if (ht == Head_t::Choice) { return; }
		else {
			require(false_ != 0, "empty head requires false atom");
			fHead_ = true;
			return SmodelsOutput::rule(ht, toSpan(&false_, 1), body);
		}
	}
	SmodelsRule rt = (SmodelsRule)isSmodelsHead(ht, head);
	require(rt != End, "unsupported rule type");
	startRule(rt).add(ht, head).add(body).endRule();
}
void SmodelsOutput::rule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body) {
	require(sec_ == 0, "adding rules after symbols not supported");
	if (empty(head)) {
		require(false_ != 0, "empty head requires false atom");
		fHead_ = true;
		return SmodelsOutput::rule(ht, toSpan(&false_, 1), bound, body);
	}
	SmodelsRule rt = (SmodelsRule)isSmodelsRule(ht, head, bound, body);
	require(rt != End, "unsupported rule type");
	startRule(rt).add(ht, head).add(bound, body, rt == Cardinality).endRule();
}
void SmodelsOutput::minimize(Weight_t, const WeightLitSpan& lits) {
	startRule(Optimize).add(0, lits, false).endRule();
}
void SmodelsOutput::output(const StringSpan& str, const LitSpan& cond) {
	require(sec_ <= 1, "adding symbols after compute not supported");
	require(size(cond) == 1 && lit(*begin(cond)) > 0, "general output directive not supported in smodels format");
	if (sec_ == 0) { startRule(End).endRule(); sec_ = 1; }
	os_ << unsigned(cond[0]) << " ";
	os_.write(begin(str), size(str));
	os_ << "\n";
}
void SmodelsOutput::external(Atom_t a, Value_t t) {
	require(ext_, "external directive not supported in smodels format");
	if (t != Value_t::Release) {
		startRule(ClaspAssignExt).add(a).add((unsigned(t)^3)-1).endRule();
	}
	else {
		startRule(ClaspReleaseExt).add(a).endRule();
	}
}
void SmodelsOutput::assume(const LitSpan& lits) {
	require(sec_ < 2, "at most one compute statement supported in smodels format");
	while (sec_ != 2) { startRule(End).endRule(); ++sec_; }
	os_ << "B+\n";
	for (const Lit_t* x = begin(lits); x != end(lits); ++x) {
		if (lit(*x) > 0) { os_ << atom(*x) << "\n"; }
	}
	os_ << "0\nB-\n";
	for (const Lit_t* x = begin(lits); x != end(lits); ++x) {
		if (lit(*x) < 0) { os_ << atom(*x) << "\n"; }
	}
	if (fHead_ && false_) {
		os_ << false_ << "\n";
	}
	os_ << "0\n";
}
void SmodelsOutput::endStep() {
	if (sec_ < 2) { SmodelsOutput::assume(Potassco::toSpan()); }
	os_ << "1\n";
}
}
clasp-3.2.2/liblp/src/theory_data.cpp000066400000000000000000000274021304134206100175170ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifdef _MSC_VER
#pragma warning (disable : 4996) // std::copy unsafe
#pragma warning (disable : 4200) // zero-sized array
#elif __clang__
#pragma clang diagnostic ignored "-Wzero-length-array"
#elif __GNUC__
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-pedantic"
#endif
#include 
#include 
#include 
#include 
#include 

#define FAIL_IF(exp, msg) \
	(void)( (!(exp)) || (throw std::logic_error(msg), 0))	


namespace Potassco {
template 
static std::size_t nBytes(const IdSpan& ids) {
	return sizeof(T) + (ids.size * sizeof(Id_t));
}
struct FuncData {
	static FuncData* newFunc(int32_t base, const IdSpan& args);
	static void destroy(FuncData*);
	int32_t  base;
	uint32_t size;
	Id_t     args[0];
};
FuncData* FuncData::newFunc(int32_t base, const IdSpan& args) {
	std::size_t nb = nBytes(args);
	FuncData* f = new (::operator new(nb)) FuncData;
	f->base = base;
	f->size = static_cast(Potassco::size(args));
	std::memcpy(f->args, begin(args), f->size * sizeof(Id_t));
	return f;
}
void FuncData::destroy(FuncData* f) {
	if (f) { f->~FuncData(); ::operator delete(f); }
}
const uint64_t nulTerm  = static_cast(-1);
const uint64_t typeMask = static_cast(3);

TheoryTerm::TheoryTerm() : data_(nulTerm) {}
TheoryTerm::TheoryTerm(int num) {
	data_ = (static_cast(num) << 2) | Theory_t::Number;
}
TheoryTerm::TheoryTerm(const char* sym) {
	data_ = (assertPtr(sym) | Theory_t::Symbol);
	assert(sym == symbol());
}
TheoryTerm::TheoryTerm(const FuncData* c) {
	data_ = (assertPtr(c) | Theory_t::Compound);
}
uint64_t TheoryTerm::assertPtr(const void* p) const { 
	uint64_t invalid_pointer_size[ (sizeof(uint64_t) >= sizeof(uintptr_t)) ] = {
		static_cast(reinterpret_cast(p))
	};
	FAIL_IF((invalid_pointer_size[0] & 3u) != 0u, "Invalid pointer alignment!");
	return invalid_pointer_size[0];
}
void TheoryTerm::assertType(Theory_t t) const { FAIL_IF(type() != t, "Invalid term cast!"); }
bool TheoryTerm::valid() const { return data_ != nulTerm; }
Theory_t TheoryTerm::type() const { FAIL_IF(!valid(), "Invalid term!"); return static_cast(data_&typeMask); }
int TheoryTerm::number() const {
	assertType(Theory_t::Number);
	return static_cast(data_ >> 2);
}
uintptr_t TheoryTerm::getPtr() const {
	return static_cast(data_ & ~typeMask);
}
const char* TheoryTerm::symbol() const {
	assertType(Theory_t::Symbol);
	return reinterpret_cast(getPtr());
}
FuncData* TheoryTerm::func() const {
	return reinterpret_cast(getPtr());
}
int TheoryTerm::compound() const {
	assertType(Theory_t::Compound);
	return func()->base;
}
bool TheoryTerm::isFunction() const { return type() == Theory_t::Compound && func()->base >= 0; }
bool TheoryTerm::isTuple()    const { return type() == Theory_t::Compound && func()->base < 0; }
Id_t TheoryTerm::function()   const { FAIL_IF(!isFunction(), "Invalid term cast: not a function!"); return static_cast(func()->base); }
Tuple_t TheoryTerm::tuple()   const { FAIL_IF(!isTuple(), "Invalid term cast: not a tuple!"); return static_cast(func()->base); }
uint32_t TheoryTerm::size()   const { return type() == Theory_t::Compound ? func()->size : 0; }
TheoryTerm::iterator TheoryTerm::begin() const { return type() == Theory_t::Compound ? func()->args : 0; }
TheoryTerm::iterator TheoryTerm::end()   const { return type() == Theory_t::Compound ? func()->args + func()->size : 0; }

TheoryElement::TheoryElement(const IdSpan& terms, Id_t c) : nTerms_(static_cast(Potassco::size(terms))), nCond_(c != 0) {
	std::memcpy(term_, Potassco::begin(terms), nTerms_ * sizeof(Id_t));
	if (nCond_ != 0) { term_[nTerms_] = c; }
}
TheoryElement* TheoryElement::newElement(const IdSpan& terms, Id_t c) {
	std::size_t nb = nBytes(terms);
	if (c != 0) { nb += sizeof(Id_t); }
	return new (::operator new(nb)) TheoryElement(terms, c);
}
void TheoryElement::destroy(TheoryElement* e) {
	if (e) {
		e->~TheoryElement();
		::operator delete(e);
	}
}
Id_t TheoryElement::condition() const {
	return nCond_ == 0 ? 0 : term_[nTerms_];
}
void TheoryElement::setCondition(Id_t c) {
	term_[nTerms_] = c;
}

TheoryAtom::TheoryAtom(Id_t a, Id_t term, const IdSpan& args, Id_t* op, Id_t* rhs)
	: atom_(a)
	, guard_(op != 0)
	, termId_(term)
	, nTerms_(static_cast(Potassco::size(args))) {
	std::memcpy(term_, Potassco::begin(args), nTerms_ * sizeof(Id_t));
	if (op) { 
		term_[nTerms_] = *op; 
		term_[nTerms_ + 1] = *rhs; 
	}
}

TheoryAtom* TheoryAtom::newAtom(Id_t a, Id_t term, const IdSpan& args) {
	return new (::operator new(nBytes(args))) TheoryAtom(a, term, args, 0, 0);
}
TheoryAtom* TheoryAtom::newAtom(Id_t a, Id_t term, const IdSpan& args, Id_t op, Id_t rhs) {
	std::size_t nb = nBytes(args) + (2*sizeof(Id_t));
	return new (::operator new(nb)) TheoryAtom(a, term, args, &op, &rhs);
}
void TheoryAtom::destroy(TheoryAtom* a) {
	if (a) {
		a->~TheoryAtom();
		::operator delete(a);
	}
}
const Id_t* TheoryAtom::guard() const {
	return guard_ != 0 ? &term_[nTerms_] : 0;
}
const Id_t* TheoryAtom::rhs() const {
	return guard_ != 0 ? &term_[nTerms_ + 1] : 0;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// TheoryData
//////////////////////////////////////////////////////////////////////////////////////////////////////
struct TheoryData::DestroyT { 
	template  void operator()(T* x) const { return T::destroy(x); }
	void operator()(TheoryTerm& t) const {
		if (t.valid()) {
			if (t.type() == Theory_t::Compound) {
				this->operator()(t.func());
			}
			else if (t.type() == Theory_t::Symbol) {
				delete[] const_cast(t.symbol());
			}
		}
	}
};
TheoryData::TheoryData()  {}
TheoryData::~TheoryData() {
	reset();
}
const TheoryTerm& TheoryData::addTerm(Id_t termId, int number) {
	return setTerm(termId) = TheoryTerm(number);
}
const TheoryTerm& TheoryData::addTerm(Id_t termId, const StringSpan& name) {
	char* buf = new char[name.size + 1];
	*std::copy(Potassco::begin(name), Potassco::end(name), buf) = 0;
	return setTerm(termId) = TheoryTerm(buf);
}
const TheoryTerm& TheoryData::addTerm(Id_t termId, const char* name) {
	return addTerm(termId, Potassco::toSpan(name, name ? std::strlen(name) : 0));
}
const TheoryTerm& TheoryData::addTerm(Id_t termId, Id_t funcId, const IdSpan& args) {
	return setTerm(termId) = TheoryTerm(FuncData::newFunc(static_cast(funcId), args));
}
const TheoryTerm& TheoryData::addTerm(Id_t termId, Tuple_t type, const IdSpan& args) {
	return setTerm(termId) = TheoryTerm(FuncData::newFunc(static_cast(type), args));
}
void TheoryData::removeTerm(Id_t termId) {
	if (hasTerm(termId)) {
		DestroyT()(terms()[termId]);
		terms()[termId] = Term();
	}
}
const TheoryElement& TheoryData::addElement(Id_t id, const IdSpan& terms, Id_t cId) {
	while (numElems() <= id) { elems_.push(static_cast(0)); }
	FAIL_IF(elems()[id] != 0, "Redefinition of theory element!");
	return *(elems()[id] = TheoryElement::newElement(terms, cId));
}

const TheoryAtom& TheoryData::addAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elems) {
	atoms_.push(static_cast(0));
	return *(atoms()[numAtoms()-1] = TheoryAtom::newAtom(atomOrZero, termId, elems));
}
const TheoryAtom& TheoryData::addAtom(Id_t atomOrZero, Id_t termId, const IdSpan& elems, Id_t op, Id_t rhs) {
	atoms_.push(static_cast(0));
	return *(atoms()[numAtoms()-1] = TheoryAtom::newAtom(atomOrZero, termId, elems, op, rhs));
}

TheoryTerm& TheoryData::setTerm(Id_t id) {
	while (numTerms() <= id) { terms_.push(TheoryTerm()); }
	FAIL_IF(terms()[id].valid(), "Redefinition of theory term!");
	return terms()[id];
}
void TheoryData::setCondition(Id_t elementId, Id_t newCond) {
	FAIL_IF(getElement(elementId).condition() != COND_DEFERRED, "Precondition violated!");
	elems()[elementId]->setCondition(newCond);
}

void TheoryData::reset() {
	DestroyT destroy;
	std::for_each(terms(), terms() + numTerms(), destroy);
	std::for_each(elems(), elems() + numElems(), destroy);
	std::for_each(atoms(), atoms() + numAtoms(), destroy);
	PtrStack().swap(terms_);
	PtrStack().swap(elems_);
	TermStack().swap(atoms_);
	frame_ = Up();
}
void TheoryData::update() {
	frame_.atom = numAtoms();
	frame_.term = numTerms();
	frame_.elem = numElems();
}
TheoryTerm* TheoryData::terms() const {
	return static_cast(terms_.get(0));
}
TheoryElement** TheoryData::elems() const {
	return static_cast(elems_.get(0));
}
TheoryAtom** TheoryData::atoms() const {
	return static_cast(atoms_.get(0));
}

uint32_t TheoryData::numAtoms() const {
	return atoms_.top() / sizeof(TheoryAtom*);
}
uint32_t TheoryData::numTerms() const {
	return terms_.top() / sizeof(TheoryTerm);
}
uint32_t TheoryData::numElems() const {
	return elems_.top() / sizeof(TheoryElement*);
}
TheoryData::atom_iterator TheoryData::begin() const { 
	return atoms();
}
TheoryData::atom_iterator TheoryData::currBegin() const { 
	return begin() + frame_.atom; 
}
TheoryData::atom_iterator TheoryData::end() const { 
	return begin() + numAtoms();
}
bool TheoryData::hasTerm(Id_t id) const { 
	return id < numTerms() && terms()[id].valid(); 
}
bool TheoryData::isNewTerm(Id_t id) const {
	return hasTerm(id) && id >= frame_.term;
}
bool TheoryData::hasElement(Id_t id) const { 
	return id < numElems() && elems()[id] != 0; 
}
bool TheoryData::isNewElement(Id_t id) const { 
	return hasElement(id) && id >= frame_.elem;
}
const TheoryTerm& TheoryData::getTerm(Id_t id) const {
	FAIL_IF(!hasTerm(id), "Invalid term id!");
	return terms()[id];
}
const TheoryElement& TheoryData::getElement(Id_t id) const {
	FAIL_IF(!hasElement(id), "Invalid element id!");
	return *elems()[id];
}
void TheoryData::accept(Visitor& out) const {
	for (atom_iterator aIt = currBegin(), aEnd = end(); aIt != aEnd; ++aIt) {
		out.visit(*this, **aIt);
	}
}
void TheoryData::accept(const TheoryTerm& t, Visitor& out) const {
	if (t.type() == Theory_t::Compound) {
		for (TheoryTerm::iterator it = t.begin(), end = t.end(); it != end; ++it) {
			if (isNewTerm(*it)) { out.visit(*this, *it, getTerm(*it)); }
		}
		if (t.isFunction() && isNewTerm(t.function())) { out.visit(*this, t.function(), getTerm(t.function())); }
	}
}
void TheoryData::accept(const TheoryElement& e, Visitor& out) const {
	for (TheoryElement::iterator it = e.begin(), end = e.end(); it != end; ++it) {
		if (isNewTerm(*it)) { out.visit(*this, *it, getTerm(*it)); }
	}
}
void TheoryData::accept(const TheoryAtom& a, Visitor& out) const {
	if (isNewTerm(a.term())) { out.visit(*this, a.term(), getTerm(a.term())); }
	for (TheoryElement::iterator eIt = a.begin(), eEnd = a.end(); eIt != eEnd; ++eIt) {
		if (isNewElement(*eIt)) { out.visit(*this, *eIt, getElement(*eIt)); }
	}
	if (a.guard() && isNewTerm(*a.guard())) { out.visit(*this, *a.guard(), getTerm(*a.guard())); }
	if (a.rhs()   && isNewTerm(*a.rhs()))   { out.visit(*this, *a.rhs(),   getTerm(*a.rhs())); }
}
TheoryData::Visitor::~Visitor() {}
StringSpan toSpan(const char* x) {
	return Potassco::toSpan(x, std::strlen(x));
}

}
clasp-3.2.2/liblp/tests/000077500000000000000000000000001304134206100150565ustar00rootroot00000000000000clasp-3.2.2/liblp/tests/CMakeLists.txt000066400000000000000000000002521304134206100176150ustar00rootroot00000000000000include_directories(${PROJECT_SOURCE_DIR}/liblp/ .)
aux_source_directory(. SRC_LIST)
add_executable(test EXCLUDE_FROM_ALL ${SRC_LIST})
target_link_libraries(test liblp)

clasp-3.2.2/liblp/tests/aspif.cpp000066400000000000000000000445251304134206100166760ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 

#include "catch.hpp"
#include "common.h"
#include 
#include 
#include 
#include 
namespace Potassco {
namespace Test {
namespace Aspif {
const Weight_t BOUND_NONE = -1;
static void finalize(std::stringstream& str) {
	str << "0\n";
}
static void rule(std::ostream& os, const Rule& r) {
	os << (unsigned)Directive_t::Rule << " " << r.ht << " ";
	os << r.head.size();
	for (auto x : r.head) { os << " " << x; }
	os << " " << (unsigned)r.bt << " ";
	if (r.bt == Body_t::Sum) { 
		os << r.bnd << " " << r.body.size();
		std::for_each(begin(r.body), end(r.body), [&os](WeightLit_t x) { os << " " << x.lit << " " << x.weight; });
	}
	else {
		os << r.body.size();
		std::for_each(begin(r.body), end(r.body), [&os](WeightLit_t x) { os << " " << x.lit; });
	}
	os << "\n";
}

class ReadObserver : public Test::ReadObserver {
public:
	virtual void rule(Head_t ht, const AtomSpan& head, const LitSpan& body) override {
		rules.push_back({ht, {begin(head), end(head)}, Body_t::Normal, BOUND_NONE, {}});
		Vec& wb = rules.back().body;
		std::for_each(begin(body), end(body), [&wb](Lit_t x) {wb.push_back({x, 1}); });
	}
	virtual void rule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body) override {
		rules.push_back({ht, {begin(head), end(head)}, Body_t::Sum, bound, {begin(body), end(body)}});
	}
	virtual void minimize(Weight_t prio, const WeightLitSpan& lits) override {
		min.push_back({prio, {begin(lits), end(lits)}});
	}
	virtual void project(const AtomSpan& atoms) override {
		projects.insert(projects.end(), begin(atoms), end(atoms));
	}
	virtual void output(const StringSpan& str, const LitSpan& cond) override {
		shows.push_back({{begin(str), end(str)}, {begin(cond), end(cond)}});
	}

	virtual void external(Atom_t a, Value_t v) override {
		externals.push_back({a, v});
	}
	virtual void assume(const LitSpan& lits) override {
		assumes.insert(assumes.end(), begin(lits), end(lits));
	}
	Vec rules;
	Vec > > min;
	Vec > > shows;
	Vec > externals;
	Vec projects;
	Vec  assumes;
};

static int compareRead(std::stringstream& input, ReadObserver& observer, const Rule* rules, const std::pair& subset) {
	for (unsigned i = 0; i != subset.second; ++i) { rule(input, rules[subset.first + i]); }
	finalize(input);
	readAspif(input, observer);
	if (observer.rules.size() != subset.second) {
		return (int)observer.rules.size();
	}
	for (unsigned i = 0; i != subset.second; ++i) {
		if (!(rules[subset.first + i] == observer.rules[i])) {
			return i;
		}
	}
	return subset.second;
}
TEST_CASE("BasicStack", "[stack]") {
	BasicStack stack;
	SECTION("empty stack is empty") {
		REQUIRE(stack.top() == 0u);
	}
	SECTION("char is aligned to int") {
		stack.push('x');
		REQUIRE(stack.top() == sizeof(int32_t));
	}
	SECTION("char span is aligned to multiple of int") {
		char* x = stack.makeSpan(13);
		REQUIRE(stack.top() == 16);
		StringSpan y = stack.popSpan(13);
		REQUIRE(x == y.first);
	}
	SECTION("stack push uint") {
		stack.push(92u);
		REQUIRE(stack.pop() == 92u);
		REQUIRE(stack.top() == 0u);
	}
	SECTION("stack push wlit") {
		WeightLit_t wl = {-123, 99};
		stack.push(wl);
		REQUIRE(stack.pop() == wl);
		REQUIRE(stack.top() == 0u);
	}
	SECTION("stack make span") {
		Lit_t* x = stack.makeSpan(3);
		x[0] = 123;
		x[1] = -456;
		x[2] = 789;
		Lit_t cmp[3] = {123, -456, 789};
		LitSpan span = stack.popSpan(3);
		REQUIRE(std::equal(Potassco::begin(span), Potassco::end(span), cmp));
	}
}
TEST_CASE("Intermediate Format Reader ", "[aspif]") {
	std::stringstream input;
	ReadObserver observer;
	input << "asp 1 0 0\n";
	SECTION("read empty") {
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.nStep == 1);
		REQUIRE(observer.incremental == false);
	}
	SECTION("read empty rule") {
		rule(input, {Head_t::Disjunctive, {}, Body_t::Normal, BOUND_NONE, {}});
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.rules.size() == 1);
		REQUIRE(observer.rules[0].head.empty());
		REQUIRE(observer.rules[0].body.empty());
	}
	SECTION("read rules") {
		Rule rules[] = {
			{Head_t::Disjunctive, {1}, Body_t::Normal, BOUND_NONE, {{-2, 1}, {3, 1}, {-4, 1}}},
			{Head_t::Disjunctive, {1, 2, 3}, Body_t::Normal, BOUND_NONE, {{5, 1}, {-6, 1}}},
			{Head_t::Disjunctive, {}, Body_t::Normal, BOUND_NONE, {{1, 1}, {2, 1}}},
			{Head_t::Choice, {1, 2, 3}, Body_t::Normal, BOUND_NONE, {{5, 1}, {-6, 1}}},
			// weight
			{Head_t::Disjunctive, {1}, Body_t::Sum, 1, {{2, 1}, {-3, 2}, {-4, 3}, {5, 1}}},
			{Head_t::Disjunctive, {2}, Body_t::Sum, 1, {{3, 1}, {-4, 1}, {5, 1}}},
			// mixed
			{Head_t::Choice, {1, 2}, Body_t::Sum, 1, {{2, 1}, {-3, 2}, {-4, 3}, {5, 1}}},
			{Head_t::Disjunctive, {}, Body_t::Sum, 1, {{2, 1}, {-3, 2}, {-4, 3}, {5, 1}}},
			// negative weights
			{Head_t::Disjunctive, {1}, Body_t::Sum, 1, {{2, 1}, {-3, -2}, {-4, 3}, {5, 1}}}
		};
		using Pair = std::pair;
		Pair basic(0, 4);
		Pair weight(4, 2);
		Pair mixed(6, 2);
		Pair neg(8, 1);
		SECTION("simple rules with normal bodies") {
			REQUIRE(compareRead(input, observer, rules, basic) == basic.second);
		}
		SECTION("read rules with weight body") {
			REQUIRE(compareRead(input, observer, rules, weight) == weight.second);
		}
		SECTION("read mixed rules") {
			REQUIRE(compareRead(input, observer, rules, mixed) == mixed.second);
		}
		SECTION("negative weights not allowed in weight rule") {
			REQUIRE_THROWS(compareRead(input, observer, rules, neg));
		}
	}
	SECTION("read minimize rule") {
		input << (unsigned)Directive_t::Minimize << " -1 3 4 5 6 1 3 2\n";
		input << (unsigned)Directive_t::Minimize << " 10 3 4 -52 -6 36 3 -20\n";
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.min.size() == 2);
		const auto& mr1 = observer.min[0];
		const auto& mr2 = observer.min[1];
		REQUIRE(mr1.first == -1);
		REQUIRE(mr2.first == 10);
		auto lits = Vec{{4, 5}, {6, 1}, {3, 2}};
		REQUIRE(mr1.second == lits);
		lits = Vec{{4, -52}, {-6, 36}, {3, -20}};
		REQUIRE(mr2.second == lits);
	}
	SECTION("read output") {
		input << (unsigned)Directive_t::Output << " 1 a 1 1\n";
		input << (unsigned)Directive_t::Output << " 10 Hallo Welt 2 1 -2\n";
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.shows.size() == 2);
		const auto& s1 = observer.shows[0];
		const auto& s2 = observer.shows[1];
		REQUIRE(s1.first == "a");
		REQUIRE(s1.second == Vec({1}));
		REQUIRE(s2.first == "Hallo Welt");
		REQUIRE(s2.second == Vec({1, -2}));
	}
	SECTION("read projection") {
		input << (unsigned)Directive_t::Project << " 3 1 2 987232\n";
		input << (unsigned)Directive_t::Project << " 1 17\n";
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.projects == Vec({1, 2, 987232, 17}));
	}
	SECTION("read external") {
		std::pair exp[] = {
			{1, Value_t::Free},
			{2, Value_t::True},
			{3, Value_t::False},
			{4, Value_t::Release}
		};
		for (auto&& e : exp) {
			input << (unsigned)Directive_t::External << " " << e.first << " " << (unsigned)e.second << "\n";
		}
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(std::distance(begin(exp), end(exp)) == observer.externals.size());
		REQUIRE(std::equal(begin(exp), end(exp), observer.externals.begin()) == true);
	}
	SECTION("read assumptions") {
		input << (unsigned)Directive_t::Assume << " 2 1 987232\n";
		input << (unsigned)Directive_t::Assume << " 1 -2\n";
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.assumes == Vec({1, 987232, -2}));
	}
	SECTION("read edges") {
		input << (unsigned)Directive_t::Edge << " 0 1 2 1 -2\n";
		input << (unsigned)Directive_t::Edge << " 1 0 1 3\n";
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.edges.size() == 2);
		REQUIRE(observer.edges[0].s == 0);
		REQUIRE(observer.edges[0].t == 1);
		REQUIRE(observer.edges[0].cond == Vec({1, -2}));
		REQUIRE(observer.edges[1].s == 1);
		REQUIRE(observer.edges[1].t == 0);
		REQUIRE(observer.edges[1].cond == Vec({3}));
	}
	SECTION("read heuristic") {
		Heuristic exp[] = {
			{1, Heuristic_t::Sign, -1, 1, {10}},
			{2, Heuristic_t::Level, 10, 3, {-1, 10}},
			{1, Heuristic_t::Init, 20, 1, {}},
			{1, Heuristic_t::Factor, 2, 2, {}}
		};
		for (auto&& r : exp) {
			input << (unsigned)Directive_t::Heuristic << " " << (unsigned)r.type << " " << r.atom << " " << r.bias
				<< " " << r.prio << " " << r.cond.size();
			for (auto&& p : r.cond) { input << " " << p; }
			input << "\n";
		}
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.heuristics.size() == 4);
		REQUIRE(std::equal(std::begin(exp), std::end(exp), observer.heuristics.begin()) == true);
	}
	SECTION("ignore comments") {
		input << (unsigned)Directive_t::Comment << "Hello World" << "\n";
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
	}
}
TEST_CASE("Intermediate Format Reader supports incremental programs", "[aspif]") {
	std::stringstream input;
	ReadObserver observer;
	input << "asp 1 0 0 incremental\n";
	SECTION("read empty steps") {
		finalize(input);
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.incremental == true);
		REQUIRE(observer.nStep == 2);
	}
	SECTION("read rules in each steps") {
		rule(input, {Head_t::Disjunctive, {1,2}, Body_t::Normal, BOUND_NONE, {}});
		finalize(input);
		rule(input, {Head_t::Disjunctive, {3, 4}, Body_t::Normal, BOUND_NONE, {}});
		finalize(input);
		REQUIRE(readAspif(input, observer) == 0);
		REQUIRE(observer.incremental == true);
		REQUIRE(observer.nStep == 2);
		REQUIRE(observer.rules.size() == 2);
	}
}

TEST_CASE("Intermediate Format Reader requires current version", "[aspif]") {
	std::stringstream input;
	ReadObserver observer;
	input << "asp 1 2 0 incremental\n";
	finalize(input);
	REQUIRE_THROWS(readAspif(input, observer));
}
TEST_CASE("Intermediate Format Reader requires incremental tag for incremental programs", "[aspif]") {
	std::stringstream input;
	ReadObserver observer;
	input << "asp 1 0 0\n";
	finalize(input);
	finalize(input);
	REQUIRE_THROWS(readAspif(input, observer));
}

TEST_CASE("Test AspifOutput", "[aspif]") {
	std::stringstream out;
	AspifOutput writer(out);
	ReadObserver observer;
	writer.initProgram(false);
	writer.beginStep();
	SECTION("Writer writes rules") {
		Rule rules[] = {
			{Head_t::Disjunctive, {1}, Body_t::Normal, BOUND_NONE, {{-2, 1}, {3, 1}, {-4, 1}}},
			{Head_t::Disjunctive, {1, 2, 3}, Body_t::Normal, BOUND_NONE, {{5, 1}, {-6, 1}}},
			{Head_t::Disjunctive, {}, Body_t::Normal, BOUND_NONE, {{1, 1}, {2, 1}}},
			{Head_t::Choice, {1, 2, 3}, Body_t::Normal, BOUND_NONE, {{5, 1}, {-6, 1}}},
			// weight
			{Head_t::Disjunctive, {1}, Body_t::Sum, 1, {{2, 1}, {-3, 2}, {-4, 3}, {5, 1}}},
			{Head_t::Disjunctive, {2}, Body_t::Sum, 1, {{3, 1}, {-4, 1}, {5, 1}}},
			// mixed
			{Head_t::Choice, {1, 2}, Body_t::Sum, 1, {{2, 1}, {-3, 2}, {-4, 3}, {5, 1}}},
			{Head_t::Disjunctive, {}, Body_t::Sum, 1, {{2, 1}, {-3, 2}, {-4, 3}, {5, 1}}},
		};
		Vec temp;
		for (auto&& r : rules) {
			if (r.bt == Body_t::Normal) {
				temp.clear();
				std::transform(r.body.begin(), r.body.end(), std::back_inserter(temp), [](const WeightLit_t& x) { return x.lit; });
				writer.rule(r.ht, toSpan(r.head), toSpan(temp));
			}
			else {
				writer.rule(r.ht, toSpan(r.head), r.bnd, toSpan(r.body));
			}
		}
		writer.endStep();
		readAspif(out, observer);
		for (auto&& r : rules) {
			REQUIRE(std::find(observer.rules.begin(), observer.rules.end(), r) != observer.rules.end());
		}
	}
	SECTION("Writer writes minimize") {
		auto m1 = Vec{{1, -2}, {-3, 2}, {4, 1}};
		auto m2 = Vec{{-10, 1}, {-20, 2}};
		writer.minimize(1, toSpan(m1));
		writer.minimize(-2, toSpan(m2));
		writer.endStep();
		readAspif(out, observer);
		REQUIRE(observer.min.size() == 2);
		REQUIRE(observer.min[0].first == 1);
		REQUIRE(observer.min[1].first == -2);
		REQUIRE(observer.min[0].second == m1);
		REQUIRE(observer.min[1].second == m2);
	}
	SECTION("Writer writes output") {
		std::pair > exp[] ={
			{"Hallo", {1, -2, 3}},
			{"Fact", {}}
		};
		for (auto&& s : exp) { writer.output(toSpan(s.first), toSpan(s.second)); }
		writer.endStep();
		readAspif(out, observer);
		for (auto&& s : exp) { REQUIRE(std::find(observer.shows.begin(), observer.shows.end(), s) != observer.shows.end()); }
	}
	SECTION("Writer writes external") {
		std::pair exp[] ={
			{1, Value_t::Free},
			{2, Value_t::True},
			{3, Value_t::False},
			{4, Value_t::Release}
		};
		for (auto&& e : exp) {
			writer.external(e.first, e.second);
		}
		writer.endStep();
		readAspif(out, observer);
		for (auto&& e : exp) {
			REQUIRE(std::find(observer.externals.begin(), observer.externals.end(), e) != observer.externals.end());
		}
	}
	SECTION("Writer writes assumptions") {
		Lit_t a[] ={1, 987232, -2};
		writer.assume(toSpan(a, 2));
		writer.assume(toSpan(a+2, 1));
		writer.endStep();
		readAspif(out, observer);
		REQUIRE(observer.assumes.size() == 3);
		REQUIRE(std::equal(a, a+3, observer.assumes.begin()) == true);
	}
	SECTION("Writer writes projection") {
		Atom_t a[] ={1, 987232, 2};
		writer.project(toSpan(a, 2));
		writer.project(toSpan(a+2, 1));
		writer.endStep();
		readAspif(out, observer);
		REQUIRE(observer.projects.size() == 3);
		REQUIRE(std::equal(a, a+3, observer.projects.begin()) == true);
	}
	SECTION("Writer writes acyc edges") {
		Edge exp[] ={
			{0, 1, {1, -2}},
			{1, 0, {3}}
		};
		for (auto&& e : exp) { writer.acycEdge(e.s, e.t, toSpan(e.cond)); }
		writer.endStep();
		readAspif(out, observer);
		REQUIRE(observer.edges.size() == std::distance(std::begin(exp), std::end(exp)));
		REQUIRE(std::equal(std::begin(exp), std::end(exp), observer.edges.begin()) == true);
	}
	SECTION("Writer writes heuristics") {
		Heuristic exp[] ={
			{1, Heuristic_t::Sign, -1, 1, {10}},
			{2, Heuristic_t::Level, 10, 3, {-1, 10}},
			{1, Heuristic_t::Init, 20, 1, {}},
			{1, Heuristic_t::Factor, 2, 2, {}}
		};
		for (auto&& h : exp) {
			writer.heuristic(h.atom, h.type, h.bias, h.prio, toSpan(h.cond));
		}
		writer.endStep();
		readAspif(out, observer);
		REQUIRE(std::equal(std::begin(exp), std::end(exp), observer.heuristics.begin()) == true);
	}
}
TEST_CASE("TheoryData", "[aspif]") {
	TheoryData data;
	SECTION("Destruct invalid term") {
		data.addTerm(10, "Foo");
		data.reset();
	}
	SECTION("Term 0 is ok") {
		data.addTerm(0, 0);
		REQUIRE(data.hasTerm(0));
		REQUIRE(data.getTerm(0).type() == Theory_t::Number);
	}

	SECTION("Visit theory") {
		using Potassco::toSpan;
		Id_t tId = 0, s[3], n[5], o[2], f[3], e[4], args[2];
		// primitives
		data.addTerm(n[0] = tId++, 1); // (number 1)
		data.addTerm(n[1] = tId++, 2); // (number 2)
		data.addTerm(n[2] = tId++, 3); // (number 3)
		data.addTerm(n[3] = tId++, 4); // (number 4)
		data.addTerm(s[0] = tId++, toSpan("x")); // (string x)
		data.addTerm(s[1] = tId++, toSpan("z")); // (string z)
		// compounds
		data.addTerm(o[0] = tId++, toSpan("*")); // (operator *)
		data.addTerm(f[0] = tId++, s[0], toSpan(n, 1));   // (function x(1))
		data.addTerm(f[1] = tId++, s[0], toSpan(n+1, 1)); // (function x(2))
		data.addTerm(f[2] = tId++, s[0], toSpan(n+2, 1)); // (function x(3))
		args[0] = n[0]; args[1] = f[0];
		data.addTerm(e[0] = tId++, o[0], toSpan(args, 2)); // (1 * x(1))
		args[0] = n[1]; args[1] = f[1];
		data.addTerm(e[1] = tId++, o[0], toSpan(args, 2)); // (2 * x(2))
		args[0] = n[2]; args[1] = f[2];
		data.addTerm(e[2] = tId++, o[0], toSpan(args, 2)); // (3 * x(3))
		args[0] = n[3]; args[1] = s[1];
		data.addTerm(e[3] = tId++, o[0], toSpan(args, 2)); // (4 * z)
		// elements
		Id_t elems[4];
		data.addElement(elems[0] = 0, toSpan(&e[0], 1), 0u); // (element 1*x(1):)
		data.addElement(elems[1] = 1, toSpan(&e[1], 1), 0u); // (element 2*x(2):)
		data.addElement(elems[2] = 2, toSpan(&e[2], 1), 0u); // (element 3*x(3):)
		data.addElement(elems[3] = 3, toSpan(&e[3], 1), 0u); // (element 4*z:)
		
		// atom
		data.addTerm(s[2] = tId++, toSpan("sum"));       // (string sum)
		data.addTerm(o[1] = tId++, toSpan(">="));        // (string >=)
		data.addTerm(n[4] = tId++, 42);                  // (number 42)
		data.addAtom(1, s[2], toSpan(elems, 4), o[1], n[4]); // (&sum { 1*x(1); 2*x(2); 3*x(3); 4*z     } >= 42)
		
		struct Visitor : public TheoryData::Visitor {
			void visit(const TheoryData& data, Id_t termId, const TheoryTerm& t) override {
				if (out.hasTerm(termId)) return;
				switch (t.type()) {
					case Potassco::Theory_t::Number: out.addTerm(termId, t.number()); break;
					case Potassco::Theory_t::Symbol: out.addTerm(termId, t.symbol()); break;
					case Potassco::Theory_t::Compound:
						data.accept(t, *this);
						if (t.isFunction()) { out.addTerm(termId, t.function(), t.terms()); }
						else                { out.addTerm(termId, t.tuple(), t.terms()); }
						break;
				}
			}
			void visit(const TheoryData& data, Id_t elemId, const TheoryElement& e) override {
				if (out.hasElement(elemId)) return;
				data.accept(e, *this);
				out.addElement(elemId, e.terms(), e.condition());
			}
			void visit(const TheoryData& data, const TheoryAtom& a) override {
				data.accept(a, *this);
				if (!a.guard()) { out.addAtom(a.atom(), a.term(), a.elements()); }
				else            { out.addAtom(a.atom(), a.term(), a.elements(), *a.guard(), *a.rhs()); }
			}
			TheoryData out;
		} th;
		data.accept(th);
		REQUIRE(data.numAtoms() == th.out.numAtoms());
		for (Id_t id = 0; id != tId; ++id) {
			REQUIRE(data.hasTerm(id) == th.out.hasTerm(id));
			REQUIRE(data.getTerm(id).type() == th.out.getTerm(id).type());
		}
		for (Id_t id = 0; id != 4; ++id) {
			REQUIRE(data.hasElement(id) == th.out.hasElement(id));
		}
	}
}

}}}
clasp-3.2.2/liblp/tests/catch.hpp000066400000000000000000012201521304134206100166540ustar00rootroot00000000000000/*
 *  CATCH v1.1 build 14 (develop branch)
 *  Generated: 2015-03-04 18:32:24.627737
 *  ----------------------------------------------------------
 *  This file has been merged from multiple headers. Please don't edit it directly
 *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
 *
 *  Distributed under the Boost Software License, Version 1.0. (See accompanying
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED

#define TWOBLUECUBES_CATCH_HPP_INCLUDED

// #included from: internal/catch_suppress_warnings.h

#define TWOBLUECUBES_CATCH_SUPPRESS_WARNINGS_H_INCLUDED

#ifdef __clang__
#   ifdef __ICC // icpc defines the __clang__ macro
#       pragma warning(push)
#       pragma warning(disable: 161 1682)
#   else // __ICC
#       pragma clang diagnostic ignored "-Wglobal-constructors"
#       pragma clang diagnostic ignored "-Wvariadic-macros"
#       pragma clang diagnostic ignored "-Wc99-extensions"
#       pragma clang diagnostic ignored "-Wunused-variable"
#       pragma clang diagnostic push
#       pragma clang diagnostic ignored "-Wpadded"
#       pragma clang diagnostic ignored "-Wc++98-compat"
#       pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#    endif
#elif defined __GNUC__
#    pragma GCC diagnostic ignored "-Wvariadic-macros"
#    pragma GCC diagnostic ignored "-Wunused-variable"
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wpadded"
#endif

#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
#  define CATCH_IMPL
#endif

#ifdef CATCH_IMPL
#  ifndef CLARA_CONFIG_MAIN
#    define CLARA_CONFIG_MAIN_NOT_DEFINED
#    define CLARA_CONFIG_MAIN
#  endif
#endif

// #included from: internal/catch_notimplemented_exception.h
#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED

// #included from: catch_common.h
#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED

#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
#define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )

#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )

#include 
#include 
#include 

// #included from: catch_compiler_capabilities.h
#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED

// Much of the following code is based on Boost (1.53)

#ifdef __clang__

#  if __has_feature(cxx_nullptr)
#    define CATCH_CONFIG_CPP11_NULLPTR
#  endif

#  if __has_feature(cxx_noexcept)
#    define CATCH_CONFIG_CPP11_NOEXCEPT
#  endif

#endif // __clang__

////////////////////////////////////////////////////////////////////////////////
// Borland
#ifdef __BORLANDC__

#if (__BORLANDC__ > 0x582 )
//#define CATCH_CONFIG_SFINAE // Not confirmed
#endif

#endif // __BORLANDC__

////////////////////////////////////////////////////////////////////////////////
// EDG
#ifdef __EDG_VERSION__

#if (__EDG_VERSION__ > 238 )
//#define CATCH_CONFIG_SFINAE // Not confirmed
#endif

#endif // __EDG_VERSION__

////////////////////////////////////////////////////////////////////////////////
// Digital Mars
#ifdef __DMC__

#if (__DMC__ > 0x840 )
//#define CATCH_CONFIG_SFINAE // Not confirmed
#endif

#endif // __DMC__

////////////////////////////////////////////////////////////////////////////////
// GCC
#ifdef __GNUC__

#if __GNUC__ < 3

#if (__GNUC_MINOR__ >= 96 )
//#define CATCH_CONFIG_SFINAE
#endif

#elif __GNUC__ >= 3

// #define CATCH_CONFIG_SFINAE // Taking this out completely for now

#endif // __GNUC__ < 3

#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) )

#define CATCH_CONFIG_CPP11_NULLPTR
#endif

#endif // __GNUC__

////////////////////////////////////////////////////////////////////////////////
// Visual C++
#ifdef _MSC_VER

#if (_MSC_VER >= 1600)
#define CATCH_CONFIG_CPP11_NULLPTR
#endif

#if (_MSC_VER >= 1310 ) // (VC++ 7.0+)
//#define CATCH_CONFIG_SFINAE // Not confirmed
#endif

#endif // _MSC_VER

// Use variadic macros if the compiler supports them
#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )

#ifndef CATCH_CONFIG_NO_VARIADIC_MACROS
#define CATCH_CONFIG_VARIADIC_MACROS
#endif

#endif

////////////////////////////////////////////////////////////////////////////////
// C++ language feature support

// detect language version:
#if (__cplusplus == 201103L)
#  define CATCH_CPP11
#  define CATCH_CPP11_OR_GREATER
#elif (__cplusplus >= 201103L)
#  define CATCH_CPP11_OR_GREATER
#endif

// noexcept support:
#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
#  define CATCH_NOEXCEPT noexcept
#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
#else
#  define CATCH_NOEXCEPT throw()
#  define CATCH_NOEXCEPT_IS(x)
#endif

namespace Catch {

    class NonCopyable {
#ifdef CATCH_CPP11_OR_GREATER
        NonCopyable( NonCopyable const& )              = delete;
        NonCopyable( NonCopyable && )                  = delete;
        NonCopyable& operator = ( NonCopyable const& ) = delete;
        NonCopyable& operator = ( NonCopyable && )     = delete;
#else
        NonCopyable( NonCopyable const& info );
        NonCopyable& operator = ( NonCopyable const& );
#endif

    protected:
        NonCopyable() {}
        virtual ~NonCopyable();
    };

    class SafeBool {
    public:
        typedef void (SafeBool::*type)() const;

        static type makeSafe( bool value ) {
            return value ? &SafeBool::trueValue : 0;
        }
    private:
        void trueValue() const {}
    };

    template
    inline void deleteAll( ContainerT& container ) {
        typename ContainerT::const_iterator it = container.begin();
        typename ContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete *it;
    }
    template
    inline void deleteAllValues( AssociativeContainerT& container ) {
        typename AssociativeContainerT::const_iterator it = container.begin();
        typename AssociativeContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete it->second;
    }

    bool startsWith( std::string const& s, std::string const& prefix );
    bool endsWith( std::string const& s, std::string const& suffix );
    bool contains( std::string const& s, std::string const& infix );
    void toLowerInPlace( std::string& s );
    std::string toLower( std::string const& s );
    std::string trim( std::string const& str );
    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );

    struct pluralise {
        pluralise( std::size_t count, std::string const& label );

        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );

        std::size_t m_count;
        std::string m_label;
    };

    struct SourceLineInfo {

        SourceLineInfo();
        SourceLineInfo( char const* _file, std::size_t _line );
        SourceLineInfo( SourceLineInfo const& other );
#  ifdef CATCH_CPP11_OR_GREATER
        SourceLineInfo( SourceLineInfo && )                  = default;
        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
#  endif
        bool empty() const;
        bool operator == ( SourceLineInfo const& other ) const;
        bool operator < ( SourceLineInfo const& other ) const;

        std::string file;
        std::size_t line;
    };

    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );

    // This is just here to avoid compiler warnings with macro constants and boolean literals
    inline bool isTrue( bool value ){ return value; }
    inline bool alwaysTrue() { return true; }
    inline bool alwaysFalse() { return false; }

    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );

    // Use this in variadic streaming macros to allow
    //    >> +StreamEndStop
    // as well as
    //    >> stuff +StreamEndStop
    struct StreamEndStop {
        std::string operator+() {
            return std::string();
        }
    };
    template
    T const& operator + ( T const& value, StreamEndStop ) {
        return value;
    }
}

#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) )
#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );

#include 

namespace Catch {

    class NotImplementedException : public std::exception
    {
    public:
        NotImplementedException( SourceLineInfo const& lineInfo );
        NotImplementedException( NotImplementedException const& ) {}

        virtual ~NotImplementedException() CATCH_NOEXCEPT {}

        virtual const char* what() const CATCH_NOEXCEPT;

    private:
        std::string m_what;
        SourceLineInfo m_lineInfo;
    };

} // end namespace Catch

///////////////////////////////////////////////////////////////////////////////
#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )

// #included from: internal/catch_context.h
#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED

// #included from: catch_interfaces_generators.h
#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED

#include 

namespace Catch {

    struct IGeneratorInfo {
        virtual ~IGeneratorInfo();
        virtual bool moveNext() = 0;
        virtual std::size_t getCurrentIndex() const = 0;
    };

    struct IGeneratorsForTest {
        virtual ~IGeneratorsForTest();

        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
        virtual bool moveNext() = 0;
    };

    IGeneratorsForTest* createGeneratorsForTest();

} // end namespace Catch

// #included from: catch_ptr.hpp
#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#endif

namespace Catch {

    // An intrusive reference counting smart pointer.
    // T must implement addRef() and release() methods
    // typically implementing the IShared interface
    template
    class Ptr {
    public:
        Ptr() : m_p( NULL ){}
        Ptr( T* p ) : m_p( p ){
            if( m_p )
                m_p->addRef();
        }
        Ptr( Ptr const& other ) : m_p( other.m_p ){
            if( m_p )
                m_p->addRef();
        }
        ~Ptr(){
            if( m_p )
                m_p->release();
        }
        void reset() {
            if( m_p )
                m_p->release();
            m_p = NULL;
        }
        Ptr& operator = ( T* p ){
            Ptr temp( p );
            swap( temp );
            return *this;
        }
        Ptr& operator = ( Ptr const& other ){
            Ptr temp( other );
            swap( temp );
            return *this;
        }
        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
        T* get() { return m_p; }
        const T* get() const{ return m_p; }
        T& operator*() const { return *m_p; }
        T* operator->() const { return m_p; }
        bool operator !() const { return m_p == NULL; }
        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); }

    private:
        T* m_p;
    };

    struct IShared : NonCopyable {
        virtual ~IShared();
        virtual void addRef() const = 0;
        virtual void release() const = 0;
    };

    template
    struct SharedImpl : T {

        SharedImpl() : m_rc( 0 ){}

        virtual void addRef() const {
            ++m_rc;
        }
        virtual void release() const {
            if( --m_rc == 0 )
                delete this;
        }

        mutable unsigned int m_rc;
    };

} // end namespace Catch

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#include 
#include 
#include 

namespace Catch {

    class TestCase;
    class Stream;
    struct IResultCapture;
    struct IRunner;
    struct IGeneratorsForTest;
    struct IConfig;

    struct IContext
    {
        virtual ~IContext();

        virtual IResultCapture* getResultCapture() = 0;
        virtual IRunner* getRunner() = 0;
        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
        virtual bool advanceGeneratorsForCurrentTest() = 0;
        virtual Ptr getConfig() const = 0;
    };

    struct IMutableContext : IContext
    {
        virtual ~IMutableContext();
        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
        virtual void setRunner( IRunner* runner ) = 0;
        virtual void setConfig( Ptr const& config ) = 0;
    };

    IContext& getCurrentContext();
    IMutableContext& getCurrentMutableContext();
    void cleanUpContext();
    Stream createStream( std::string const& streamName );

}

// #included from: internal/catch_test_registry.hpp
#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED

// #included from: catch_interfaces_testcase.h
#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED

#include 

namespace Catch {

    class TestSpec;

    struct ITestCase : IShared {
        virtual void invoke () const = 0;
    protected:
        virtual ~ITestCase();
    };

    class TestCase;
    struct IConfig;

    struct ITestCaseRegistry {
        virtual ~ITestCaseRegistry();
        virtual std::vector const& getAllTests() const = 0;
        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector& matchingTestCases, bool negated = false ) const = 0;

    };
}

namespace Catch {

template
class MethodTestCase : public SharedImpl {

public:
    MethodTestCase( void (C::*method)() ) : m_method( method ) {}

    virtual void invoke() const {
        C obj;
        (obj.*m_method)();
    }

private:
    virtual ~MethodTestCase() {}

    void (C::*m_method)();
};

typedef void(*TestFunction)();

struct NameAndDesc {
    NameAndDesc( const char* _name = "", const char* _description= "" )
    : name( _name ), description( _description )
    {}

    const char* name;
    const char* description;
};

struct AutoReg {

    AutoReg(    TestFunction function,
                SourceLineInfo const& lineInfo,
                NameAndDesc const& nameAndDesc );

    template
    AutoReg(    void (C::*method)(),
                char const* className,
                NameAndDesc const& nameAndDesc,
                SourceLineInfo const& lineInfo ) {
        registerTestCase(   new MethodTestCase( method ),
                            className,
                            nameAndDesc,
                            lineInfo );
    }

    void registerTestCase(  ITestCase* testCase,
                            char const* className,
                            NameAndDesc const& nameAndDesc,
                            SourceLineInfo const& lineInfo );

    ~AutoReg();

private:
    AutoReg( AutoReg const& );
    void operator= ( AutoReg const& );
};

} // end namespace Catch

#ifdef CATCH_CONFIG_VARIADIC_MACROS
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TESTCASE( ... ) \
        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\
        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); }

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\
        namespace{ \
            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
                void test(); \
            }; \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
        } \
        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()

#else
    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\
        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); }

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
        namespace{ \
            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
                void test(); \
            }; \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
        } \
        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()

#endif

// #included from: internal/catch_capture.hpp
#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED

// #included from: catch_result_builder.h
#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED

// #included from: catch_result_type.h
#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED

namespace Catch {

    // ResultWas::OfType enum
    struct ResultWas { enum OfType {
        Unknown = -1,
        Ok = 0,
        Info = 1,
        Warning = 2,

        FailureBit = 0x10,

        ExpressionFailed = FailureBit | 1,
        ExplicitFailure = FailureBit | 2,

        Exception = 0x100 | FailureBit,

        ThrewException = Exception | 1,
        DidntThrowException = Exception | 2,

        FatalErrorCondition = 0x200 | FailureBit

    }; };

    inline bool isOk( ResultWas::OfType resultType ) {
        return ( resultType & ResultWas::FailureBit ) == 0;
    }
    inline bool isJustInfo( int flags ) {
        return flags == ResultWas::Info;
    }

    // ResultDisposition::Flags enum
    struct ResultDisposition { enum Flags {
        Normal = 0x00,

        ContinueOnFailure = 0x01,   // Failures fail test, but execution continues
        FalseTest = 0x02,           // Prefix expression with !
        SuppressFail = 0x04         // Failures are reported but do not fail the test
    }; };

    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
        return static_cast( static_cast( lhs ) | static_cast( rhs ) );
    }

    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }

} // end namespace Catch

// #included from: catch_assertionresult.h
#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED

#include 

namespace Catch {

    struct AssertionInfo
    {
        AssertionInfo() {}
        AssertionInfo(  std::string const& _macroName,
                        SourceLineInfo const& _lineInfo,
                        std::string const& _capturedExpression,
                        ResultDisposition::Flags _resultDisposition );

        std::string macroName;
        SourceLineInfo lineInfo;
        std::string capturedExpression;
        ResultDisposition::Flags resultDisposition;
    };

    struct AssertionResultData
    {
        AssertionResultData() : resultType( ResultWas::Unknown ) {}

        std::string reconstructedExpression;
        std::string message;
        ResultWas::OfType resultType;
    };

    class AssertionResult {
    public:
        AssertionResult();
        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
        ~AssertionResult();
#  ifdef CATCH_CPP11_OR_GREATER
         AssertionResult( AssertionResult const& )              = default;
         AssertionResult( AssertionResult && )                  = default;
         AssertionResult& operator = ( AssertionResult const& ) = default;
         AssertionResult& operator = ( AssertionResult && )     = default;
#  endif

        bool isOk() const;
        bool succeeded() const;
        ResultWas::OfType getResultType() const;
        bool hasExpression() const;
        bool hasMessage() const;
        std::string getExpression() const;
        std::string getExpressionInMacro() const;
        bool hasExpandedExpression() const;
        std::string getExpandedExpression() const;
        std::string getMessage() const;
        SourceLineInfo getSourceInfo() const;
        std::string getTestMacroName() const;

    protected:
        AssertionInfo m_info;
        AssertionResultData m_resultData;
    };

} // end namespace Catch

namespace Catch {

    struct TestFailureException{};

    template class ExpressionLhs;

    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;

    struct CopyableStream {
        CopyableStream() {}
        CopyableStream( CopyableStream const& other ) {
            oss << other.oss.str();
        }
        CopyableStream& operator=( CopyableStream const& other ) {
            oss.str("");
            oss << other.oss.str();
            return *this;
        }
        std::ostringstream oss;
    };

    class ResultBuilder {
    public:
        ResultBuilder(  char const* macroName,
                        SourceLineInfo const& lineInfo,
                        char const* capturedExpression,
                        ResultDisposition::Flags resultDisposition );

        template
        ExpressionLhs operator->* ( T const& operand );
        ExpressionLhs operator->* ( bool value );

        template
        ResultBuilder& operator << ( T const& value ) {
            m_stream.oss << value;
            return *this;
        }

        template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
        template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );

        ResultBuilder& setResultType( ResultWas::OfType result );
        ResultBuilder& setResultType( bool result );
        ResultBuilder& setLhs( std::string const& lhs );
        ResultBuilder& setRhs( std::string const& rhs );
        ResultBuilder& setOp( std::string const& op );

        void endExpression();

        std::string reconstructExpression() const;
        AssertionResult build() const;

        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
        void captureResult( ResultWas::OfType resultType );
        void captureExpression();
        void react();
        bool shouldDebugBreak() const;
        bool allowThrows() const;

    private:
        AssertionInfo m_assertionInfo;
        AssertionResultData m_data;
        struct ExprComponents {
            ExprComponents() : testFalse( false ) {}
            bool testFalse;
            std::string lhs, rhs, op;
        } m_exprComponents;
        CopyableStream m_stream;

        bool m_shouldDebugBreak;
        bool m_shouldThrow;
    };

} // namespace Catch

// Include after due to circular dependency:
// #included from: catch_expression_lhs.hpp
#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED

// #included from: catch_evaluate.hpp
#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
#endif

#include 

namespace Catch {
namespace Internal {

    enum Operator {
        IsEqualTo,
        IsNotEqualTo,
        IsLessThan,
        IsGreaterThan,
        IsLessThanOrEqualTo,
        IsGreaterThanOrEqualTo
    };

    template struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
    template<> struct OperatorTraits             { static const char* getName(){ return "=="; } };
    template<> struct OperatorTraits          { static const char* getName(){ return "!="; } };
    template<> struct OperatorTraits            { static const char* getName(){ return "<"; } };
    template<> struct OperatorTraits         { static const char* getName(){ return ">"; } };
    template<> struct OperatorTraits   { static const char* getName(){ return "<="; } };
    template<> struct OperatorTraits{ static const char* getName(){ return ">="; } };

    template
    inline T& opCast(T const& t) { return const_cast(t); }

// nullptr_t support based on pull request #154 from Konstantin Baumann
#ifdef CATCH_CONFIG_CPP11_NULLPTR
    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
#endif // CATCH_CONFIG_CPP11_NULLPTR

    // So the compare overloads can be operator agnostic we convey the operator as a template
    // enum, which is used to specialise an Evaluator for doing the comparison.
    template
    class Evaluator{};

    template
    struct Evaluator {
        static bool evaluate( T1 const& lhs, T2 const& rhs) {
            return opCast( lhs ) ==  opCast( rhs );
        }
    };
    template
    struct Evaluator {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
            return opCast( lhs ) != opCast( rhs );
        }
    };
    template
    struct Evaluator {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
            return opCast( lhs ) < opCast( rhs );
        }
    };
    template
    struct Evaluator {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
            return opCast( lhs ) > opCast( rhs );
        }
    };
    template
    struct Evaluator {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
            return opCast( lhs ) >= opCast( rhs );
        }
    };
    template
    struct Evaluator {
        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
            return opCast( lhs ) <= opCast( rhs );
        }
    };

    template
    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
        return Evaluator::evaluate( lhs, rhs );
    }

    // This level of indirection allows us to specialise for integer types
    // to avoid signed/ unsigned warnings

    // "base" overload
    template
    bool compare( T1 const& lhs, T2 const& rhs ) {
        return Evaluator::evaluate( lhs, rhs );
    }

    // unsigned X to int
    template bool compare( unsigned int lhs, int rhs ) {
        return applyEvaluator( lhs, static_cast( rhs ) );
    }
    template bool compare( unsigned long lhs, int rhs ) {
        return applyEvaluator( lhs, static_cast( rhs ) );
    }
    template bool compare( unsigned char lhs, int rhs ) {
        return applyEvaluator( lhs, static_cast( rhs ) );
    }

    // unsigned X to long
    template bool compare( unsigned int lhs, long rhs ) {
        return applyEvaluator( lhs, static_cast( rhs ) );
    }
    template bool compare( unsigned long lhs, long rhs ) {
        return applyEvaluator( lhs, static_cast( rhs ) );
    }
    template bool compare( unsigned char lhs, long rhs ) {
        return applyEvaluator( lhs, static_cast( rhs ) );
    }

    // int to unsigned X
    template bool compare( int lhs, unsigned int rhs ) {
        return applyEvaluator( static_cast( lhs ), rhs );
    }
    template bool compare( int lhs, unsigned long rhs ) {
        return applyEvaluator( static_cast( lhs ), rhs );
    }
    template bool compare( int lhs, unsigned char rhs ) {
        return applyEvaluator( static_cast( lhs ), rhs );
    }

    // long to unsigned X
    template bool compare( long lhs, unsigned int rhs ) {
        return applyEvaluator( static_cast( lhs ), rhs );
    }
    template bool compare( long lhs, unsigned long rhs ) {
        return applyEvaluator( static_cast( lhs ), rhs );
    }
    template bool compare( long lhs, unsigned char rhs ) {
        return applyEvaluator( static_cast( lhs ), rhs );
    }

    // pointer to long (when comparing against NULL)
    template bool compare( long lhs, T* rhs ) {
        return Evaluator::evaluate( reinterpret_cast( lhs ), rhs );
    }
    template bool compare( T* lhs, long rhs ) {
        return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) );
    }

    // pointer to int (when comparing against NULL)
    template bool compare( int lhs, T* rhs ) {
        return Evaluator::evaluate( reinterpret_cast( lhs ), rhs );
    }
    template bool compare( T* lhs, int rhs ) {
        return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) );
    }

#ifdef CATCH_CONFIG_CPP11_NULLPTR
    // pointer to nullptr_t (when comparing against nullptr)
    template bool compare( std::nullptr_t, T* rhs ) {
        return Evaluator::evaluate( NULL, rhs );
    }
    template bool compare( T* lhs, std::nullptr_t ) {
        return Evaluator::evaluate( lhs, NULL );
    }
#endif // CATCH_CONFIG_CPP11_NULLPTR

} // end of namespace Internal
} // end of namespace Catch

#ifdef _MSC_VER
#pragma warning(pop)
#endif

// #included from: catch_tostring.h
#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED

// #included from: catch_sfinae.hpp
#define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED

// Try to detect if the current compiler supports SFINAE

namespace Catch {

    struct TrueType {
        static const bool value = true;
        typedef void Enable;
        char sizer[1];
    };
    struct FalseType {
        static const bool value = false;
        typedef void Disable;
        char sizer[2];
    };

#ifdef CATCH_CONFIG_SFINAE

    template struct NotABooleanExpression;

    template struct If : NotABooleanExpression {};
    template<> struct If : TrueType {};
    template<> struct If : FalseType {};

    template struct SizedIf;
    template<> struct SizedIf : TrueType {};
    template<> struct SizedIf : FalseType {};

#endif // CATCH_CONFIG_SFINAE

} // end namespace Catch

#include 
#include 
#include 
#include 
#include 

#ifdef __OBJC__
// #included from: catch_objc_arc.hpp
#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED

#import 

#ifdef __has_feature
#define CATCH_ARC_ENABLED __has_feature(objc_arc)
#else
#define CATCH_ARC_ENABLED 0
#endif

void arcSafeRelease( NSObject* obj );
id performOptionalSelector( id obj, SEL sel );

#if !CATCH_ARC_ENABLED
inline void arcSafeRelease( NSObject* obj ) {
    [obj release];
}
inline id performOptionalSelector( id obj, SEL sel ) {
    if( [obj respondsToSelector: sel] )
        return [obj performSelector: sel];
    return nil;
}
#define CATCH_UNSAFE_UNRETAINED
#define CATCH_ARC_STRONG
#else
inline void arcSafeRelease( NSObject* ){}
inline id performOptionalSelector( id obj, SEL sel ) {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
#endif
    if( [obj respondsToSelector: sel] )
        return [obj performSelector: sel];
#ifdef __clang__
#pragma clang diagnostic pop
#endif
    return nil;
}
#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
#define CATCH_ARC_STRONG __strong
#endif

#endif

#ifdef CATCH_CPP11_OR_GREATER
#include 
#include 
#endif

namespace Catch {

// Why we're here.
template
std::string toString( T const& value );

// Built in overloads

std::string toString( std::string const& value );
std::string toString( std::wstring const& value );
std::string toString( const char* const value );
std::string toString( char* const value );
std::string toString( const wchar_t* const value );
std::string toString( wchar_t* const value );
std::string toString( int value );
std::string toString( unsigned long value );
std::string toString( unsigned int value );
std::string toString( const double value );
std::string toString( const float value );
std::string toString( bool value );
std::string toString( char value );
std::string toString( signed char value );
std::string toString( unsigned char value );

#ifdef CATCH_CONFIG_CPP11_NULLPTR
std::string toString( std::nullptr_t );
#endif

#ifdef __OBJC__
    std::string toString( NSString const * const& nsstring );
    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
    std::string toString( NSObject* const& nsObject );
#endif

namespace Detail {

    extern std::string unprintableString;

// SFINAE is currently disabled by default for all compilers.
// If the non SFINAE version of IsStreamInsertable is ambiguous for you
// and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE
#ifdef CATCH_CONFIG_SFINAE

    template
    class IsStreamInsertableHelper {
        template struct TrueIfSizeable : TrueType {};

        template
        static TrueIfSizeable dummy(T2*);
        static FalseType dummy(...);

    public:
        typedef SizedIf type;
    };

    template
    struct IsStreamInsertable : IsStreamInsertableHelper::type {};

#else

    struct BorgType {
        template BorgType( T const& );
    };

    TrueType& testStreamable( std::ostream& );
    FalseType testStreamable( FalseType );

    FalseType operator<<( std::ostream const&, BorgType const& );

    template
    struct IsStreamInsertable {
        static std::ostream &s;
        static T  const&t;
        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
    };

#endif

#if defined(CATCH_CPP11_OR_GREATER)
    template::value
             >
    struct EnumStringMaker
    {
        static std::string convert( T const& ) { return unprintableString; }
    };

    template
    struct EnumStringMaker
    {
        static std::string convert( T const& v )
        {
            return ::Catch::toString(
                static_cast::type>(v)
                );
        }
    };
#endif
    template
    struct StringMakerBase {
#if defined(CATCH_CPP11_OR_GREATER)
        template
        static std::string convert( T const& v )
        {
            return EnumStringMaker::convert( v );
        }
#else
        template
        static std::string convert( T const& ) { return unprintableString; }
#endif
    };

    template<>
    struct StringMakerBase {
        template
        static std::string convert( T const& _value ) {
            std::ostringstream oss;
            oss << _value;
            return oss.str();
        }
    };

    std::string rawMemoryToString( const void *object, std::size_t size );

    template
    inline std::string rawMemoryToString( const T& object ) {
      return rawMemoryToString( &object, sizeof(object) );
    }

} // end namespace Detail

template
struct StringMaker :
    Detail::StringMakerBase::value> {};

template
struct StringMaker {
    template
    static std::string convert( U* p ) {
        if( !p )
            return INTERNAL_CATCH_STRINGIFY( NULL );
        else
            return Detail::rawMemoryToString( p );
    }
};

template
struct StringMaker {
    static std::string convert( R C::* p ) {
        if( !p )
            return INTERNAL_CATCH_STRINGIFY( NULL );
        else
            return Detail::rawMemoryToString( p );
    }
};

namespace Detail {
    template
    std::string rangeToString( InputIterator first, InputIterator last );
}

//template
//struct StringMaker > {
//    static std::string convert( std::vector const& v ) {
//        return Detail::rangeToString( v.begin(), v.end() );
//    }
//};

template
std::string toString( std::vector const& v ) {
    return Detail::rangeToString( v.begin(), v.end() );
}

#ifdef CATCH_CPP11_OR_GREATER

// toString for tuples
namespace TupleDetail {
  template<
      typename Tuple,
      std::size_t N = 0,
      bool = (N < std::tuple_size::value)
      >
  struct ElementPrinter {
      static void print( const Tuple& tuple, std::ostream& os )
      {
          os << ( N ? ", " : " " )
             << Catch::toString(std::get(tuple));
          ElementPrinter::print(tuple,os);
      }
  };

  template<
      typename Tuple,
      std::size_t N
      >
  struct ElementPrinter {
      static void print( const Tuple&, std::ostream& ) {}
  };

}

template
struct StringMaker> {

    static std::string convert( const std::tuple& tuple )
    {
        std::ostringstream os;
        os << '{';
        TupleDetail::ElementPrinter>::print( tuple, os );
        os << " }";
        return os.str();
    }
};
#endif

namespace Detail {
    template
    std::string makeString( T const& value ) {
        return StringMaker::convert( value );
    }
} // end namespace Detail

/// \brief converts any type to a string
///
/// The default template forwards on to ostringstream - except when an
/// ostringstream overload does not exist - in which case it attempts to detect
/// that and writes {?}.
/// Overload (not specialise) this template for custom typs that you don't want
/// to provide an ostream overload for.
template
std::string toString( T const& value ) {
    return StringMaker::convert( value );
}

    namespace Detail {
    template
    std::string rangeToString( InputIterator first, InputIterator last ) {
        std::ostringstream oss;
        oss << "{ ";
        if( first != last ) {
            oss << Catch::toString( *first );
            for( ++first ; first != last ; ++first )
                oss << ", " << Catch::toString( *first );
        }
        oss << " }";
        return oss.str();
    }
}

} // end namespace Catch

namespace Catch {

// Wraps the LHS of an expression and captures the operator and RHS (if any) -
// wrapping them all in a ResultBuilder object
template
class ExpressionLhs {
    ExpressionLhs& operator = ( ExpressionLhs const& );
#  ifdef CATCH_CPP11_OR_GREATER
    ExpressionLhs& operator = ( ExpressionLhs && ) = delete;
#  endif

public:
    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {}
#  ifdef CATCH_CPP11_OR_GREATER
    ExpressionLhs( ExpressionLhs const& ) = default;
    ExpressionLhs( ExpressionLhs && )     = default;
#  endif

    template
    ResultBuilder& operator == ( RhsT const& rhs ) {
        return captureExpression( rhs );
    }

    template
    ResultBuilder& operator != ( RhsT const& rhs ) {
        return captureExpression( rhs );
    }

    template
    ResultBuilder& operator < ( RhsT const& rhs ) {
        return captureExpression( rhs );
    }

    template
    ResultBuilder& operator > ( RhsT const& rhs ) {
        return captureExpression( rhs );
    }

    template
    ResultBuilder& operator <= ( RhsT const& rhs ) {
        return captureExpression( rhs );
    }

    template
    ResultBuilder& operator >= ( RhsT const& rhs ) {
        return captureExpression( rhs );
    }

    ResultBuilder& operator == ( bool rhs ) {
        return captureExpression( rhs );
    }

    ResultBuilder& operator != ( bool rhs ) {
        return captureExpression( rhs );
    }

    void endExpression() {
        bool value = m_lhs ? true : false;
        m_rb
            .setLhs( Catch::toString( value ) )
            .setResultType( value )
            .endExpression();
    }

    // Only simple binary expressions are allowed on the LHS.
    // If more complex compositions are required then place the sub expression in parentheses
    template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& );
    template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& );
    template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& );
    template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& );
    template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
    template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );

private:
    template
    ResultBuilder& captureExpression( RhsT const& rhs ) {
        return m_rb
            .setResultType( Internal::compare( m_lhs, rhs ) )
            .setLhs( Catch::toString( m_lhs ) )
            .setRhs( Catch::toString( rhs ) )
            .setOp( Internal::OperatorTraits::getName() );
    }

private:
    ResultBuilder& m_rb;
    T m_lhs;
};

} // end namespace Catch


namespace Catch {

    template
    inline ExpressionLhs ResultBuilder::operator->* ( T const& operand ) {
        return ExpressionLhs( *this, operand );
    }

    inline ExpressionLhs ResultBuilder::operator->* ( bool value ) {
        return ExpressionLhs( *this, value );
    }

} // namespace Catch

// #included from: catch_message.h
#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED

#include 

namespace Catch {

    struct MessageInfo {
        MessageInfo(    std::string const& _macroName,
                        SourceLineInfo const& _lineInfo,
                        ResultWas::OfType _type );

        std::string macroName;
        SourceLineInfo lineInfo;
        ResultWas::OfType type;
        std::string message;
        unsigned int sequence;

        bool operator == ( MessageInfo const& other ) const {
            return sequence == other.sequence;
        }
        bool operator < ( MessageInfo const& other ) const {
            return sequence < other.sequence;
        }
    private:
        static unsigned int globalCount;
    };

    struct MessageBuilder {
        MessageBuilder( std::string const& macroName,
                        SourceLineInfo const& lineInfo,
                        ResultWas::OfType type )
        : m_info( macroName, lineInfo, type )
        {}

        template
        MessageBuilder& operator << ( T const& value ) {
            m_stream << value;
            return *this;
        }

        MessageInfo m_info;
        std::ostringstream m_stream;
    };

    class ScopedMessage {
    public:
        ScopedMessage( MessageBuilder const& builder );
        ScopedMessage( ScopedMessage const& other );
        ~ScopedMessage();

        MessageInfo m_info;
    };

} // end namespace Catch

// #included from: catch_interfaces_capture.h
#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED

#include 

namespace Catch {

    class TestCase;
    class AssertionResult;
    struct AssertionInfo;
    struct SectionInfo;
    struct MessageInfo;
    class ScopedMessageBuilder;
    struct Counts;

    struct IResultCapture {

        virtual ~IResultCapture();

        virtual void assertionEnded( AssertionResult const& result ) = 0;
        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
                                        Counts& assertions ) = 0;
        virtual void sectionEnded( SectionInfo const& name, Counts const& assertions, double _durationInSeconds ) = 0;
        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
        virtual void popScopedMessage( MessageInfo const& message ) = 0;

        virtual std::string getCurrentTestName() const = 0;
        virtual const AssertionResult* getLastResult() const = 0;

        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
    };

    IResultCapture& getResultCapture();
}

// #included from: catch_debugger.h
#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED

// #included from: catch_platform.h
#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED

#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
#define CATCH_PLATFORM_MAC
#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
#define CATCH_PLATFORM_IPHONE
#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
#define CATCH_PLATFORM_WINDOWS
#endif

#include 

namespace Catch{

    bool isDebuggerActive();
    void writeToDebugConsole( std::string const& text );
}

#ifdef CATCH_PLATFORM_MAC

    // The following code snippet based on:
    // http://cocoawithlove.com/2008/03/break-into-debugger.html
    #ifdef DEBUG
        #if defined(__ppc64__) || defined(__ppc__)
            #define CATCH_BREAK_INTO_DEBUGGER() \
                if( Catch::isDebuggerActive() ) { \
                    __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
                    : : : "memory","r0","r3","r4" ); \
                }
        #else
            #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );}
        #endif
    #endif

#elif defined(_MSC_VER)
    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); }
#elif defined(__MINGW32__)
    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); }
#endif

#ifndef CATCH_BREAK_INTO_DEBUGGER
#define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
#endif

// #included from: catch_interfaces_runner.h
#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED

namespace Catch {
    class TestCase;

    struct IRunner {
        virtual ~IRunner();
        virtual bool aborting() const = 0;
    };
}

///////////////////////////////////////////////////////////////////////////////
// In the event of a failure works out if the debugger needs to be invoked
// and/or an exception thrown and takes appropriate action.
// This needs to be done as a macro so the debugger will stop in the user
// source code rather than in Catch library code
#define INTERNAL_CATCH_REACT( resultBuilder ) \
    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
    resultBuilder.react();

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
        try { \
            ( __catchResult->*expr ).endExpression(); \
        } \
        catch( ... ) { \
            __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \
        } \
        INTERNAL_CATCH_REACT( __catchResult ) \
    } while( Catch::isTrue( false && (expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \
    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
    if( Catch::getResultCapture().getLastResult()->succeeded() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \
    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
    if( !Catch::getResultCapture().getLastResult()->succeeded() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
        try { \
            expr; \
            __catchResult.captureResult( Catch::ResultWas::Ok ); \
        } \
        catch( ... ) { \
            __catchResult.useActiveException( resultDisposition ); \
        } \
        INTERNAL_CATCH_REACT( __catchResult ) \
    } while( Catch::alwaysFalse() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS( expr, resultDisposition, macroName ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
        if( __catchResult.allowThrows() ) \
            try { \
                expr; \
                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
            } \
            catch( ... ) { \
                __catchResult.captureResult( Catch::ResultWas::Ok ); \
            } \
        else \
            __catchResult.captureResult( Catch::ResultWas::Ok ); \
        INTERNAL_CATCH_REACT( __catchResult ) \
    } while( Catch::alwaysFalse() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
        if( __catchResult.allowThrows() ) \
            try { \
                expr; \
                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
            } \
            catch( exceptionType ) { \
                __catchResult.captureResult( Catch::ResultWas::Ok ); \
            } \
            catch( ... ) { \
                __catchResult.useActiveException( resultDisposition ); \
            } \
        else \
            __catchResult.captureResult( Catch::ResultWas::Ok ); \
        INTERNAL_CATCH_REACT( __catchResult ) \
    } while( Catch::alwaysFalse() )

///////////////////////////////////////////////////////////////////////////////
#ifdef CATCH_CONFIG_VARIADIC_MACROS
    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \
        do { \
            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
            __catchResult.captureResult( messageType ); \
            INTERNAL_CATCH_REACT( __catchResult ) \
        } while( Catch::alwaysFalse() )
#else
    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \
        do { \
            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
            __catchResult << log + ::Catch::StreamEndStop(); \
            __catchResult.captureResult( messageType ); \
            INTERNAL_CATCH_REACT( __catchResult ) \
        } while( Catch::alwaysFalse() )
#endif

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_INFO( log, macroName ) \
    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \
    do { \
        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg " " #matcher, resultDisposition ); \
        try { \
            std::string matcherAsString = ::Catch::Matchers::matcher.toString(); \
            __catchResult \
                .setLhs( Catch::toString( arg ) ) \
                .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \
                .setOp( "matches" ) \
                .setResultType( ::Catch::Matchers::matcher.match( arg ) ); \
            __catchResult.captureExpression(); \
        } catch( ... ) { \
            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
        } \
        INTERNAL_CATCH_REACT( __catchResult ) \
    } while( Catch::alwaysFalse() )

// #included from: internal/catch_section.h
#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED

// #included from: catch_section_info.h
#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED

namespace Catch {

    struct SectionInfo {
        SectionInfo
            (   SourceLineInfo const& _lineInfo,
                std::string const& _name,
                std::string const& _description = std::string() );

        std::string name;
        std::string description;
        SourceLineInfo lineInfo;
    };

} // end namespace Catch

// #included from: catch_totals.hpp
#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED

#include 

namespace Catch {

    struct Counts {
        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}

        Counts operator - ( Counts const& other ) const {
            Counts diff;
            diff.passed = passed - other.passed;
            diff.failed = failed - other.failed;
            diff.failedButOk = failedButOk - other.failedButOk;
            return diff;
        }
        Counts& operator += ( Counts const& other ) {
            passed += other.passed;
            failed += other.failed;
            failedButOk += other.failedButOk;
            return *this;
        }

        std::size_t total() const {
            return passed + failed + failedButOk;
        }
        bool allPassed() const {
            return failed == 0 && failedButOk == 0;
        }
        bool allOk() const {
            return failed == 0;
        }

        std::size_t passed;
        std::size_t failed;
        std::size_t failedButOk;
    };

    struct Totals {

        Totals operator - ( Totals const& other ) const {
            Totals diff;
            diff.assertions = assertions - other.assertions;
            diff.testCases = testCases - other.testCases;
            return diff;
        }

        Totals delta( Totals const& prevTotals ) const {
            Totals diff = *this - prevTotals;
            if( diff.assertions.failed > 0 )
                ++diff.testCases.failed;
            else if( diff.assertions.failedButOk > 0 )
                ++diff.testCases.failedButOk;
            else
                ++diff.testCases.passed;
            return diff;
        }

        Totals& operator += ( Totals const& other ) {
            assertions += other.assertions;
            testCases += other.testCases;
            return *this;
        }

        Counts assertions;
        Counts testCases;
    };
}

// #included from: catch_timer.h
#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED

#ifdef CATCH_PLATFORM_WINDOWS
typedef unsigned long long uint64_t;
#else
#include 
#endif

namespace Catch {

    class Timer {
    public:
        Timer() : m_ticks( 0 ) {}
        void start();
        unsigned int getElapsedMicroseconds() const;
        unsigned int getElapsedMilliseconds() const;
        double getElapsedSeconds() const;

    private:
        uint64_t m_ticks;
    };

} // namespace Catch

#include 

namespace Catch {

    class Section : NonCopyable {
    public:
        Section( SectionInfo const& info );
        ~Section();

        // This indicates whether the section should be executed or not
        operator bool() const;

    private:
        SectionInfo m_info;

        std::string m_name;
        Counts m_assertions;
        bool m_sectionIncluded;
        Timer m_timer;
    };

} // end namespace Catch

#ifdef CATCH_CONFIG_VARIADIC_MACROS
    #define INTERNAL_CATCH_SECTION( ... ) \
        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
#else
    #define INTERNAL_CATCH_SECTION( name, desc ) \
        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
#endif

// #included from: internal/catch_generators.hpp
#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED

#include 
#include 
#include 
#include 

namespace Catch {

template
struct IGenerator {
    virtual ~IGenerator() {}
    virtual T getValue( std::size_t index ) const = 0;
    virtual std::size_t size () const = 0;
};

template
class BetweenGenerator : public IGenerator {
public:
    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}

    virtual T getValue( std::size_t index ) const {
        return m_from+static_cast( index );
    }

    virtual std::size_t size() const {
        return static_cast( 1+m_to-m_from );
    }

private:

    T m_from;
    T m_to;
};

template
class ValuesGenerator : public IGenerator {
public:
    ValuesGenerator(){}

    void add( T value ) {
        m_values.push_back( value );
    }

    virtual T getValue( std::size_t index ) const {
        return m_values[index];
    }

    virtual std::size_t size() const {
        return m_values.size();
    }

private:
    std::vector m_values;
};

template
class CompositeGenerator {
public:
    CompositeGenerator() : m_totalSize( 0 ) {}

    // *** Move semantics, similar to auto_ptr ***
    CompositeGenerator( CompositeGenerator& other )
    :   m_fileInfo( other.m_fileInfo ),
        m_totalSize( 0 )
    {
        move( other );
    }

    CompositeGenerator& setFileInfo( const char* fileInfo ) {
        m_fileInfo = fileInfo;
        return *this;
    }

    ~CompositeGenerator() {
        deleteAll( m_composed );
    }

    operator T () const {
        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );

        typename std::vector*>::const_iterator it = m_composed.begin();
        typename std::vector*>::const_iterator itEnd = m_composed.end();
        for( size_t index = 0; it != itEnd; ++it )
        {
            const IGenerator* generator = *it;
            if( overallIndex >= index && overallIndex < index + generator->size() )
            {
                return generator->getValue( overallIndex-index );
            }
            index += generator->size();
        }
        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
    }

    void add( const IGenerator* generator ) {
        m_totalSize += generator->size();
        m_composed.push_back( generator );
    }

    CompositeGenerator& then( CompositeGenerator& other ) {
        move( other );
        return *this;
    }

    CompositeGenerator& then( T value ) {
        ValuesGenerator* valuesGen = new ValuesGenerator();
        valuesGen->add( value );
        add( valuesGen );
        return *this;
    }

private:

    void move( CompositeGenerator& other ) {
        std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) );
        m_totalSize += other.m_totalSize;
        other.m_composed.clear();
    }

    std::vector*> m_composed;
    std::string m_fileInfo;
    size_t m_totalSize;
};

namespace Generators
{
    template
    CompositeGenerator between( T from, T to ) {
        CompositeGenerator generators;
        generators.add( new BetweenGenerator( from, to ) );
        return generators;
    }

    template
    CompositeGenerator values( T val1, T val2 ) {
        CompositeGenerator generators;
        ValuesGenerator* valuesGen = new ValuesGenerator();
        valuesGen->add( val1 );
        valuesGen->add( val2 );
        generators.add( valuesGen );
        return generators;
    }

    template
    CompositeGenerator values( T val1, T val2, T val3 ){
        CompositeGenerator generators;
        ValuesGenerator* valuesGen = new ValuesGenerator();
        valuesGen->add( val1 );
        valuesGen->add( val2 );
        valuesGen->add( val3 );
        generators.add( valuesGen );
        return generators;
    }

    template
    CompositeGenerator values( T val1, T val2, T val3, T val4 ) {
        CompositeGenerator generators;
        ValuesGenerator* valuesGen = new ValuesGenerator();
        valuesGen->add( val1 );
        valuesGen->add( val2 );
        valuesGen->add( val3 );
        valuesGen->add( val4 );
        generators.add( valuesGen );
        return generators;
    }

} // end namespace Generators

using namespace Generators;

} // end namespace Catch

#define INTERNAL_CATCH_LINESTR2( line ) #line
#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )

#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )

// #included from: internal/catch_interfaces_exception.h
#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED

#include 
// #included from: catch_interfaces_registry_hub.h
#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED

#include 

namespace Catch {

    class TestCase;
    struct ITestCaseRegistry;
    struct IExceptionTranslatorRegistry;
    struct IExceptionTranslator;
    struct IReporterRegistry;
    struct IReporterFactory;

    struct IRegistryHub {
        virtual ~IRegistryHub();

        virtual IReporterRegistry const& getReporterRegistry() const = 0;
        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
    };

    struct IMutableRegistryHub {
        virtual ~IMutableRegistryHub();
        virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0;
        virtual void registerTest( TestCase const& testInfo ) = 0;
        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
    };

    IRegistryHub& getRegistryHub();
    IMutableRegistryHub& getMutableRegistryHub();
    void cleanUp();
    std::string translateActiveException();

}


namespace Catch {

    typedef std::string(*exceptionTranslateFunction)();

    struct IExceptionTranslator {
        virtual ~IExceptionTranslator();
        virtual std::string translate() const = 0;
    };

    struct IExceptionTranslatorRegistry {
        virtual ~IExceptionTranslatorRegistry();

        virtual std::string translateActiveException() const = 0;
    };

    class ExceptionTranslatorRegistrar {
        template
        class ExceptionTranslator : public IExceptionTranslator {
        public:

            ExceptionTranslator( std::string(*translateFunction)( T& ) )
            : m_translateFunction( translateFunction )
            {}

            virtual std::string translate() const {
                try {
                    throw;
                }
                catch( T& ex ) {
                    return m_translateFunction( ex );
                }
            }

        protected:
            std::string(*m_translateFunction)( T& );
        };

    public:
        template
        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
            getMutableRegistryHub().registerTranslator
                ( new ExceptionTranslator( translateFunction ) );
        }
    };
}

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) \
    static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ); \
    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ) ); }\
    static std::string INTERNAL_CATCH_UNIQUE_NAME(  catch_internal_ExceptionTranslator )( signature )

// #included from: internal/catch_approx.hpp
#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED

#include 
#include 

namespace Catch {
namespace Detail {

    class Approx {
    public:
        explicit Approx ( double value )
        :   m_epsilon( std::numeric_limits::epsilon()*100 ),
            m_scale( 1.0 ),
            m_value( value )
        {}

        Approx( Approx const& other )
        :   m_epsilon( other.m_epsilon ),
            m_scale( other.m_scale ),
            m_value( other.m_value )
        {}

        static Approx custom() {
            return Approx( 0 );
        }

        Approx operator()( double value ) {
            Approx approx( value );
            approx.epsilon( m_epsilon );
            approx.scale( m_scale );
            return approx;
        }

        friend bool operator == ( double lhs, Approx const& rhs ) {
            // Thanks to Richard Harris for his help refining this formula
            return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) );
        }

        friend bool operator == ( Approx const& lhs, double rhs ) {
            return operator==( rhs, lhs );
        }

        friend bool operator != ( double lhs, Approx const& rhs ) {
            return !operator==( lhs, rhs );
        }

        friend bool operator != ( Approx const& lhs, double rhs ) {
            return !operator==( rhs, lhs );
        }

        Approx& epsilon( double newEpsilon ) {
            m_epsilon = newEpsilon;
            return *this;
        }

        Approx& scale( double newScale ) {
            m_scale = newScale;
            return *this;
        }

        std::string toString() const {
            std::ostringstream oss;
            oss << "Approx( " << Catch::toString( m_value ) << " )";
            return oss.str();
        }

    private:
        double m_epsilon;
        double m_scale;
        double m_value;
    };
}

template<>
inline std::string toString( Detail::Approx const& value ) {
    return value.toString();
}

} // end namespace Catch

// #included from: internal/catch_matchers.hpp
#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED

namespace Catch {
namespace Matchers {
    namespace Impl {

    template
    struct Matcher : SharedImpl
    {
        typedef ExpressionT ExpressionType;

        virtual ~Matcher() {}
        virtual Ptr clone() const = 0;
        virtual bool match( ExpressionT const& expr ) const = 0;
        virtual std::string toString() const = 0;
    };

    template
    struct MatcherImpl : Matcher {

        virtual Ptr > clone() const {
            return Ptr >( new DerivedT( static_cast( *this ) ) );
        }
    };

    namespace Generic {

        template
        class AllOf : public MatcherImpl, ExpressionT> {
        public:

            AllOf() {}
            AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {}

            AllOf& add( Matcher const& matcher ) {
                m_matchers.push_back( matcher.clone() );
                return *this;
            }
            virtual bool match( ExpressionT const& expr ) const
            {
                for( std::size_t i = 0; i < m_matchers.size(); ++i )
                    if( !m_matchers[i]->match( expr ) )
                        return false;
                return true;
            }
            virtual std::string toString() const {
                std::ostringstream oss;
                oss << "( ";
                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
                    if( i != 0 )
                        oss << " and ";
                    oss << m_matchers[i]->toString();
                }
                oss << " )";
                return oss.str();
            }

        private:
            std::vector > > m_matchers;
        };

        template
        class AnyOf : public MatcherImpl, ExpressionT> {
        public:

            AnyOf() {}
            AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {}

            AnyOf& add( Matcher const& matcher ) {
                m_matchers.push_back( matcher.clone() );
                return *this;
            }
            virtual bool match( ExpressionT const& expr ) const
            {
                for( std::size_t i = 0; i < m_matchers.size(); ++i )
                    if( m_matchers[i]->match( expr ) )
                        return true;
                return false;
            }
            virtual std::string toString() const {
                std::ostringstream oss;
                oss << "( ";
                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
                    if( i != 0 )
                        oss << " or ";
                    oss << m_matchers[i]->toString();
                }
                oss << " )";
                return oss.str();
            }

        private:
            std::vector > > m_matchers;
        };

    }

    namespace StdString {

        inline std::string makeString( std::string const& str ) { return str; }
        inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); }

        struct Equals : MatcherImpl {
            Equals( std::string const& str ) : m_str( str ){}
            Equals( Equals const& other ) : m_str( other.m_str ){}

            virtual ~Equals();

            virtual bool match( std::string const& expr ) const {
                return m_str == expr;
            }
            virtual std::string toString() const {
                return "equals: \"" + m_str + "\"";
            }

            std::string m_str;
        };

        struct Contains : MatcherImpl {
            Contains( std::string const& substr ) : m_substr( substr ){}
            Contains( Contains const& other ) : m_substr( other.m_substr ){}

            virtual ~Contains();

            virtual bool match( std::string const& expr ) const {
                return expr.find( m_substr ) != std::string::npos;
            }
            virtual std::string toString() const {
                return "contains: \"" + m_substr + "\"";
            }

            std::string m_substr;
        };

        struct StartsWith : MatcherImpl {
            StartsWith( std::string const& substr ) : m_substr( substr ){}
            StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){}

            virtual ~StartsWith();

            virtual bool match( std::string const& expr ) const {
                return expr.find( m_substr ) == 0;
            }
            virtual std::string toString() const {
                return "starts with: \"" + m_substr + "\"";
            }

            std::string m_substr;
        };

        struct EndsWith : MatcherImpl {
            EndsWith( std::string const& substr ) : m_substr( substr ){}
            EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){}

            virtual ~EndsWith();

            virtual bool match( std::string const& expr ) const {
                return expr.find( m_substr ) == expr.size() - m_substr.size();
            }
            virtual std::string toString() const {
                return "ends with: \"" + m_substr + "\"";
            }

            std::string m_substr;
        };
    } // namespace StdString
    } // namespace Impl

    // The following functions create the actual matcher objects.
    // This allows the types to be inferred
    template
    inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1,
                                                    Impl::Matcher const& m2 ) {
        return Impl::Generic::AllOf().add( m1 ).add( m2 );
    }
    template
    inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1,
                                                    Impl::Matcher const& m2,
                                                    Impl::Matcher const& m3 ) {
        return Impl::Generic::AllOf().add( m1 ).add( m2 ).add( m3 );
    }
    template
    inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1,
                                                    Impl::Matcher const& m2 ) {
        return Impl::Generic::AnyOf().add( m1 ).add( m2 );
    }
    template
    inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1,
                                                    Impl::Matcher const& m2,
                                                    Impl::Matcher const& m3 ) {
        return Impl::Generic::AnyOf().add( m1 ).add( m2 ).add( m3 );
    }

    inline Impl::StdString::Equals      Equals( std::string const& str ) {
        return Impl::StdString::Equals( str );
    }
    inline Impl::StdString::Equals      Equals( const char* str ) {
        return Impl::StdString::Equals( Impl::StdString::makeString( str ) );
    }
    inline Impl::StdString::Contains    Contains( std::string const& substr ) {
        return Impl::StdString::Contains( substr );
    }
    inline Impl::StdString::Contains    Contains( const char* substr ) {
        return Impl::StdString::Contains( Impl::StdString::makeString( substr ) );
    }
    inline Impl::StdString::StartsWith  StartsWith( std::string const& substr ) {
        return Impl::StdString::StartsWith( substr );
    }
    inline Impl::StdString::StartsWith  StartsWith( const char* substr ) {
        return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) );
    }
    inline Impl::StdString::EndsWith    EndsWith( std::string const& substr ) {
        return Impl::StdString::EndsWith( substr );
    }
    inline Impl::StdString::EndsWith    EndsWith( const char* substr ) {
        return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) );
    }

} // namespace Matchers

using namespace Matchers;

} // namespace Catch

// #included from: internal/catch_interfaces_tag_alias_registry.h
#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED

// #included from: catch_tag_alias.h
#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED

#include 

namespace Catch {

    struct TagAlias {
        TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}

        std::string tag;
        SourceLineInfo lineInfo;
    };

    struct RegistrarForTagAliases {
        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
    };

} // end namespace Catch

#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
// #included from: catch_option.hpp
#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED

namespace Catch {

    // An optional type
    template
    class Option {
    public:
        Option() : nullableValue( NULL ) {}
        Option( T const& _value )
        : nullableValue( new( storage ) T( _value ) )
        {}
        Option( Option const& _other )
        : nullableValue( _other ? new( storage ) T( *_other ) : NULL )
        {}

        ~Option() {
            reset();
        }

        Option& operator= ( Option const& _other ) {
            if( &_other != this ) {
                reset();
                if( _other )
                    nullableValue = new( storage ) T( *_other );
            }
            return *this;
        }
        Option& operator = ( T const& _value ) {
            reset();
            nullableValue = new( storage ) T( _value );
            return *this;
        }

        void reset() {
            if( nullableValue )
                nullableValue->~T();
            nullableValue = NULL;
        }

        T& operator*() { return *nullableValue; }
        T const& operator*() const { return *nullableValue; }
        T* operator->() { return nullableValue; }
        const T* operator->() const { return nullableValue; }

        T valueOr( T const& defaultValue ) const {
            return nullableValue ? *nullableValue : defaultValue;
        }

        bool some() const { return nullableValue != NULL; }
        bool none() const { return nullableValue == NULL; }

        bool operator !() const { return nullableValue == NULL; }
        operator SafeBool::type() const {
            return SafeBool::makeSafe( some() );
        }

    private:
        T* nullableValue;
        char storage[sizeof(T)];
    };

} // end namespace Catch

namespace Catch {

    struct ITagAliasRegistry {
        virtual ~ITagAliasRegistry();
        virtual Option find( std::string const& alias ) const = 0;
        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;

        static ITagAliasRegistry const& get();
    };

} // end namespace Catch

// These files are included here so the single_include script doesn't put them
// in the conditionally compiled sections
// #included from: internal/catch_test_case_info.h
#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED

#include 
#include 

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#endif

namespace Catch {

    struct ITestCase;

    struct TestCaseInfo {
        enum SpecialProperties{
            None = 0,
            IsHidden = 1 << 1,
            ShouldFail = 1 << 2,
            MayFail = 1 << 3,
            Throws = 1 << 4
        };

        TestCaseInfo(   std::string const& _name,
                        std::string const& _className,
                        std::string const& _description,
                        std::set const& _tags,
                        SourceLineInfo const& _lineInfo );

        TestCaseInfo( TestCaseInfo const& other );

        bool isHidden() const;
        bool throws() const;
        bool okToFail() const;
        bool expectedToFail() const;

        std::string name;
        std::string className;
        std::string description;
        std::set tags;
        std::set lcaseTags;
        std::string tagsAsString;
        SourceLineInfo lineInfo;
        SpecialProperties properties;
    };

    class TestCase : public TestCaseInfo {
    public:

        TestCase( ITestCase* testCase, TestCaseInfo const& info );
        TestCase( TestCase const& other );

        TestCase withName( std::string const& _newName ) const;

        void invoke() const;

        TestCaseInfo const& getTestCaseInfo() const;

        void swap( TestCase& other );
        bool operator == ( TestCase const& other ) const;
        bool operator < ( TestCase const& other ) const;
        TestCase& operator = ( TestCase const& other );

    private:
        Ptr test;
    };

    TestCase makeTestCase(  ITestCase* testCase,
                            std::string const& className,
                            std::string const& name,
                            std::string const& description,
                            SourceLineInfo const& lineInfo );
}

#ifdef __clang__
#pragma clang diagnostic pop
#endif


#ifdef __OBJC__
// #included from: internal/catch_objc.hpp
#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED

#import 

#include 

// NB. Any general catch headers included here must be included
// in catch.hpp first to make sure they are included by the single
// header for non obj-usage

///////////////////////////////////////////////////////////////////////////////
// This protocol is really only here for (self) documenting purposes, since
// all its methods are optional.
@protocol OcFixture

@optional

-(void) setUp;
-(void) tearDown;

@end

namespace Catch {

    class OcMethod : public SharedImpl {

    public:
        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}

        virtual void invoke() const {
            id obj = [[m_cls alloc] init];

            performOptionalSelector( obj, @selector(setUp)  );
            performOptionalSelector( obj, m_sel );
            performOptionalSelector( obj, @selector(tearDown)  );

            arcSafeRelease( obj );
        }
    private:
        virtual ~OcMethod() {}

        Class m_cls;
        SEL m_sel;
    };

    namespace Detail{

        inline std::string getAnnotation(   Class cls,
                                            std::string const& annotationName,
                                            std::string const& testCaseName ) {
            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
            SEL sel = NSSelectorFromString( selStr );
            arcSafeRelease( selStr );
            id value = performOptionalSelector( cls, sel );
            if( value )
                return [(NSString*)value UTF8String];
            return "";
        }
    }

    inline size_t registerTestMethods() {
        size_t noTestMethods = 0;
        int noClasses = objc_getClassList( NULL, 0 );

        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
        objc_getClassList( classes, noClasses );

        for( int c = 0; c < noClasses; c++ ) {
            Class cls = classes[c];
            {
                u_int count;
                Method* methods = class_copyMethodList( cls, &count );
                for( u_int m = 0; m < count ; m++ ) {
                    SEL selector = method_getName(methods[m]);
                    std::string methodName = sel_getName(selector);
                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
                        std::string testCaseName = methodName.substr( 15 );
                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
                        const char* className = class_getName( cls );

                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
                        noTestMethods++;
                    }
                }
                free(methods);
            }
        }
        return noTestMethods;
    }

    namespace Matchers {
        namespace Impl {
        namespace NSStringMatchers {

            template
            struct StringHolder : MatcherImpl{
                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
                StringHolder() {
                    arcSafeRelease( m_substr );
                }

                NSString* m_substr;
            };

            struct Equals : StringHolder {
                Equals( NSString* substr ) : StringHolder( substr ){}

                virtual bool match( ExpressionType const& str ) const {
                    return  (str != nil || m_substr == nil ) &&
                            [str isEqualToString:m_substr];
                }

                virtual std::string toString() const {
                    return "equals string: " + Catch::toString( m_substr );
                }
            };

            struct Contains : StringHolder {
                Contains( NSString* substr ) : StringHolder( substr ){}

                virtual bool match( ExpressionType const& str ) const {
                    return  (str != nil || m_substr == nil ) &&
                            [str rangeOfString:m_substr].location != NSNotFound;
                }

                virtual std::string toString() const {
                    return "contains string: " + Catch::toString( m_substr );
                }
            };

            struct StartsWith : StringHolder {
                StartsWith( NSString* substr ) : StringHolder( substr ){}

                virtual bool match( ExpressionType const& str ) const {
                    return  (str != nil || m_substr == nil ) &&
                            [str rangeOfString:m_substr].location == 0;
                }

                virtual std::string toString() const {
                    return "starts with: " + Catch::toString( m_substr );
                }
            };
            struct EndsWith : StringHolder {
                EndsWith( NSString* substr ) : StringHolder( substr ){}

                virtual bool match( ExpressionType const& str ) const {
                    return  (str != nil || m_substr == nil ) &&
                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
                }

                virtual std::string toString() const {
                    return "ends with: " + Catch::toString( m_substr );
                }
            };

        } // namespace NSStringMatchers
        } // namespace Impl

        inline Impl::NSStringMatchers::Equals
            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }

        inline Impl::NSStringMatchers::Contains
            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }

        inline Impl::NSStringMatchers::StartsWith
            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }

        inline Impl::NSStringMatchers::EndsWith
            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }

    } // namespace Matchers

    using namespace Matchers;

} // namespace Catch

///////////////////////////////////////////////////////////////////////////////
#define OC_TEST_CASE( name, desc )\
+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
{\
return @ name; \
}\
+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
{ \
return @ desc; \
} \
-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )

#endif

#ifdef CATCH_IMPL
// #included from: internal/catch_impl.hpp
#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED

// Collect all the implementation files together here
// These are the equivalent of what would usually be cpp files

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"
#endif

// #included from: ../catch_runner.hpp
#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED

// #included from: internal/catch_commandline.hpp
#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED

// #included from: catch_config.hpp
#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED

// #included from: catch_test_spec_parser.hpp
#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#endif

// #included from: catch_test_spec.hpp
#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#endif

#include 
#include 

namespace Catch {

    class TestSpec {
        struct Pattern : SharedImpl<> {
            virtual ~Pattern();
            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
        };
        class NamePattern : public Pattern {
            enum WildcardPosition {
                NoWildcard = 0,
                WildcardAtStart = 1,
                WildcardAtEnd = 2,
                WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
            };

        public:
            NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) {
                if( startsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 1 );
                    m_wildcard = WildcardAtStart;
                }
                if( endsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 0, m_name.size()-1 );
                    m_wildcard = static_cast( m_wildcard | WildcardAtEnd );
                }
            }
            virtual ~NamePattern();
            virtual bool matches( TestCaseInfo const& testCase ) const {
                switch( m_wildcard ) {
                    case NoWildcard:
                        return m_name == toLower( testCase.name );
                    case WildcardAtStart:
                        return endsWith( toLower( testCase.name ), m_name );
                    case WildcardAtEnd:
                        return startsWith( toLower( testCase.name ), m_name );
                    case WildcardAtBothEnds:
                        return contains( toLower( testCase.name ), m_name );
                }

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif
                throw std::logic_error( "Unknown enum" );
#ifdef __clang__
#pragma clang diagnostic pop
#endif
            }
        private:
            std::string m_name;
            WildcardPosition m_wildcard;
        };
        class TagPattern : public Pattern {
        public:
            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
            virtual ~TagPattern();
            virtual bool matches( TestCaseInfo const& testCase ) const {
                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
            }
        private:
            std::string m_tag;
        };
        class ExcludedPattern : public Pattern {
        public:
            ExcludedPattern( Ptr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
            virtual ~ExcludedPattern();
            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
        private:
            Ptr m_underlyingPattern;
        };

        struct Filter {
            std::vector > m_patterns;

            bool matches( TestCaseInfo const& testCase ) const {
                // All patterns in a filter must match for the filter to be a match
                for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it )
                    if( !(*it)->matches( testCase ) )
                        return false;
                    return true;
            }
        };

    public:
        bool hasFilters() const {
            return !m_filters.empty();
        }
        bool matches( TestCaseInfo const& testCase ) const {
            // A TestSpec matches if any filter matches
            for( std::vector::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
                if( it->matches( testCase ) )
                    return true;
            return false;
        }

    private:
        std::vector m_filters;

        friend class TestSpecParser;
    };
}

#ifdef __clang__
#pragma clang diagnostic pop
#endif

namespace Catch {

    class TestSpecParser {
        enum Mode{ None, Name, QuotedName, Tag };
        Mode m_mode;
        bool m_exclusion;
        std::size_t m_start, m_pos;
        std::string m_arg;
        TestSpec::Filter m_currentFilter;
        TestSpec m_testSpec;
        ITagAliasRegistry const* m_tagAliases;

    public:
        TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}

        TestSpecParser& parse( std::string const& arg ) {
            m_mode = None;
            m_exclusion = false;
            m_start = std::string::npos;
            m_arg = m_tagAliases->expandAliases( arg );
            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
                visitChar( m_arg[m_pos] );
            if( m_mode == Name )
                addPattern();
            return *this;
        }
        TestSpec testSpec() {
            addFilter();
            return m_testSpec;
        }
    private:
        void visitChar( char c ) {
            if( m_mode == None ) {
                switch( c ) {
                case ' ': return;
                case '~': m_exclusion = true; return;
                case '[': return startNewMode( Tag, ++m_pos );
                case '"': return startNewMode( QuotedName, ++m_pos );
                default: startNewMode( Name, m_pos ); break;
                }
            }
            if( m_mode == Name ) {
                if( c == ',' ) {
                    addPattern();
                    addFilter();
                }
                else if( c == '[' ) {
                    if( subString() == "exclude:" )
                        m_exclusion = true;
                    else
                        addPattern();
                    startNewMode( Tag, ++m_pos );
                }
            }
            else if( m_mode == QuotedName && c == '"' )
                addPattern();
            else if( m_mode == Tag && c == ']' )
                addPattern();
        }
        void startNewMode( Mode mode, std::size_t start ) {
            m_mode = mode;
            m_start = start;
        }
        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
        template
        void addPattern() {
            std::string token = subString();
            if( startsWith( token, "exclude:" ) ) {
                m_exclusion = true;
                token = token.substr( 8 );
            }
            if( !token.empty() ) {
                Ptr pattern = new T( token );
                if( m_exclusion )
                    pattern = new TestSpec::ExcludedPattern( pattern );
                m_currentFilter.m_patterns.push_back( pattern );
            }
            m_exclusion = false;
            m_mode = None;
        }
        void addFilter() {
            if( !m_currentFilter.m_patterns.empty() ) {
                m_testSpec.m_filters.push_back( m_currentFilter );
                m_currentFilter = TestSpec::Filter();
            }
        }
    };
    inline TestSpec parseTestSpec( std::string const& arg ) {
        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
    }

} // namespace Catch

#ifdef __clang__
#pragma clang diagnostic pop
#endif

// #included from: catch_interfaces_config.h
#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED

#include 
#include 
#include 

namespace Catch {

    struct Verbosity { enum Level {
        NoOutput = 0,
        Quiet,
        Normal
    }; };

    struct WarnAbout { enum What {
        Nothing = 0x00,
        NoAssertions = 0x01
    }; };

    struct ShowDurations { enum OrNot {
        DefaultForReporter,
        Always,
        Never
    }; };
    struct RunTests { enum InWhatOrder {
        InDeclarationOrder,
        InLexicographicalOrder,
        InRandomOrder
    }; };

    class TestSpec;

    struct IConfig : IShared {

        virtual ~IConfig();

        virtual bool allowThrows() const = 0;
        virtual std::ostream& stream() const = 0;
        virtual std::string name() const = 0;
        virtual bool includeSuccessfulResults() const = 0;
        virtual bool shouldDebugBreak() const = 0;
        virtual bool warnAboutMissingAssertions() const = 0;
        virtual int abortAfter() const = 0;
        virtual bool showInvisibles() const = 0;
        virtual ShowDurations::OrNot showDurations() const = 0;
        virtual TestSpec const& testSpec() const = 0;
        virtual RunTests::InWhatOrder runOrder() const = 0;
        virtual unsigned int rngSeed() const = 0;
        virtual bool forceColour() const = 0;
    };
}

// #included from: catch_stream.h
#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED

#include 

#ifdef __clang__
#pragma clang diagnostic ignored "-Wpadded"
#endif

namespace Catch {

    class Stream {
    public:
        Stream();
        Stream( std::streambuf* _streamBuf, bool _isOwned );
        void release();

        std::streambuf* streamBuf;

    private:
        bool isOwned;
    };

    std::ostream& cout();
    std::ostream& cerr();
}

#include 
#include 
#include 
#include 
#include 

#ifndef CATCH_CONFIG_CONSOLE_WIDTH
#define CATCH_CONFIG_CONSOLE_WIDTH 80
#endif

namespace Catch {

    struct ConfigData {

        ConfigData()
        :   listTests( false ),
            listTags( false ),
            listReporters( false ),
            listTestNamesOnly( false ),
            showSuccessfulTests( false ),
            shouldDebugBreak( false ),
            noThrow( false ),
            showHelp( false ),
            showInvisibles( false ),
            forceColour( false ),
            abortAfter( -1 ),
            rngSeed( 0 ),
            verbosity( Verbosity::Normal ),
            warnings( WarnAbout::Nothing ),
            showDurations( ShowDurations::DefaultForReporter ),
            runOrder( RunTests::InDeclarationOrder )
        {}

        bool listTests;
        bool listTags;
        bool listReporters;
        bool listTestNamesOnly;

        bool showSuccessfulTests;
        bool shouldDebugBreak;
        bool noThrow;
        bool showHelp;
        bool showInvisibles;
        bool forceColour;

        int abortAfter;
        unsigned int rngSeed;

        Verbosity::Level verbosity;
        WarnAbout::What warnings;
        ShowDurations::OrNot showDurations;
        RunTests::InWhatOrder runOrder;

        std::string reporterName;
        std::string outputFilename;
        std::string name;
        std::string processName;

        std::vector testsOrTags;
    };

    class Config : public SharedImpl {
    private:
        Config( Config const& other );
        Config& operator = ( Config const& other );
        virtual void dummy();
    public:

        Config()
        :   m_os( Catch::cout().rdbuf() )
        {}

        Config( ConfigData const& data )
        :   m_data( data ),
            m_os( Catch::cout().rdbuf() )
        {
            if( !data.testsOrTags.empty() ) {
                TestSpecParser parser( ITagAliasRegistry::get() );
                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
                    parser.parse( data.testsOrTags[i] );
                m_testSpec = parser.testSpec();
            }
        }

        virtual ~Config() {
            m_os.rdbuf( Catch::cout().rdbuf() );
            m_stream.release();
        }

        void setFilename( std::string const& filename ) {
            m_data.outputFilename = filename;
        }

        std::string const& getFilename() const {
            return m_data.outputFilename ;
        }

        bool listTests() const { return m_data.listTests; }
        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
        bool listTags() const { return m_data.listTags; }
        bool listReporters() const { return m_data.listReporters; }

        std::string getProcessName() const { return m_data.processName; }

        bool shouldDebugBreak() const { return m_data.shouldDebugBreak; }

        void setStreamBuf( std::streambuf* buf ) {
            m_os.rdbuf( buf ? buf : Catch::cout().rdbuf() );
        }

        void useStream( std::string const& streamName ) {
            Stream stream = createStream( streamName );
            setStreamBuf( stream.streamBuf );
            m_stream.release();
            m_stream = stream;
        }

        std::string getReporterName() const { return m_data.reporterName; }

        int abortAfter() const { return m_data.abortAfter; }

        TestSpec const& testSpec() const { return m_testSpec; }

        bool showHelp() const { return m_data.showHelp; }
        bool showInvisibles() const { return m_data.showInvisibles; }

        // IConfig interface
        virtual bool allowThrows() const        { return !m_data.noThrow; }
        virtual std::ostream& stream() const    { return m_os; }
        virtual std::string name() const        { return m_data.name.empty() ? m_data.processName : m_data.name; }
        virtual bool includeSuccessfulResults() const   { return m_data.showSuccessfulTests; }
        virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; }
        virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; }
        virtual RunTests::InWhatOrder runOrder() const  { return m_data.runOrder; }
        virtual unsigned int rngSeed() const    { return m_data.rngSeed; }
        virtual bool forceColour() const { return m_data.forceColour; }

    private:
        ConfigData m_data;

        Stream m_stream;
        mutable std::ostream m_os;
        TestSpec m_testSpec;
    };

} // end namespace Catch

// #included from: catch_clara.h
#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED

// Use Catch's value for console width (store Clara's off to the side, if present)
#ifdef CLARA_CONFIG_CONSOLE_WIDTH
#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
#undef CLARA_CONFIG_CONSOLE_WIDTH
#endif
#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH

// Declare Clara inside the Catch namespace
#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
// #included from: ../external/clara.h

// Only use header guard if we are not using an outer namespace
#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)

#ifndef STITCH_CLARA_OPEN_NAMESPACE
#define TWOBLUECUBES_CLARA_H_INCLUDED
#define STITCH_CLARA_OPEN_NAMESPACE
#define STITCH_CLARA_CLOSE_NAMESPACE
#else
#define STITCH_CLARA_CLOSE_NAMESPACE }
#endif

#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE

// ----------- #included from tbc_text_format.h -----------

// Only use header guard if we are not using an outer namespace
#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
#define TBC_TEXT_FORMAT_H_INCLUDED
#endif

#include 
#include 
#include 

// Use optional outer namespace
#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
#endif

namespace Tbc {

#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
#else
    const unsigned int consoleWidth = 80;
#endif

    struct TextAttributes {
        TextAttributes()
        :   initialIndent( std::string::npos ),
            indent( 0 ),
            width( consoleWidth-1 ),
            tabChar( '\t' )
        {}

        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }

        std::size_t initialIndent;  // indent of first line, or npos
        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
        char tabChar;               // If this char is seen the indent is changed to current pos
    };

    class Text {
    public:
        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
        : attr( _attr )
        {
            std::string wrappableChars = " [({.,/|\\-";
            std::size_t indent = _attr.initialIndent != std::string::npos
                ? _attr.initialIndent
                : _attr.indent;
            std::string remainder = _str;

            while( !remainder.empty() ) {
                if( lines.size() >= 1000 ) {
                    lines.push_back( "... message truncated due to excessive size" );
                    return;
                }
                std::size_t tabPos = std::string::npos;
                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
                std::size_t pos = remainder.find_first_of( '\n' );
                if( pos <= width ) {
                    width = pos;
                }
                pos = remainder.find_last_of( _attr.tabChar, width );
                if( pos != std::string::npos ) {
                    tabPos = pos;
                    if( remainder[width] == '\n' )
                        width--;
                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
                }

                if( width == remainder.size() ) {
                    spliceLine( indent, remainder, width );
                }
                else if( remainder[width] == '\n' ) {
                    spliceLine( indent, remainder, width );
                    if( width <= 1 || remainder.size() != 1 )
                        remainder = remainder.substr( 1 );
                    indent = _attr.indent;
                }
                else {
                    pos = remainder.find_last_of( wrappableChars, width );
                    if( pos != std::string::npos && pos > 0 ) {
                        spliceLine( indent, remainder, pos );
                        if( remainder[0] == ' ' )
                            remainder = remainder.substr( 1 );
                    }
                    else {
                        spliceLine( indent, remainder, width-1 );
                        lines.back() += "-";
                    }
                    if( lines.size() == 1 )
                        indent = _attr.indent;
                    if( tabPos != std::string::npos )
                        indent += tabPos;
                }
            }
        }

        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
            _remainder = _remainder.substr( _pos );
        }

        typedef std::vector::const_iterator const_iterator;

        const_iterator begin() const { return lines.begin(); }
        const_iterator end() const { return lines.end(); }
        std::string const& last() const { return lines.back(); }
        std::size_t size() const { return lines.size(); }
        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
        std::string toString() const {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }

        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
                it != itEnd; ++it ) {
                if( it != _text.begin() )
                    _stream << "\n";
                _stream << *it;
            }
            return _stream;
        }

    private:
        std::string str;
        TextAttributes attr;
        std::vector lines;
    };

} // end namespace Tbc

#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
} // end outer namespace
#endif

#endif // TBC_TEXT_FORMAT_H_INCLUDED

// ----------- end of #include from tbc_text_format.h -----------
// ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h

#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE

#include 
#include 
#include 
#include 

// Use optional outer namespace
#ifdef STITCH_CLARA_OPEN_NAMESPACE
STITCH_CLARA_OPEN_NAMESPACE
#endif

namespace Clara {

    struct UnpositionalTag {};

    extern UnpositionalTag _;

#ifdef CLARA_CONFIG_MAIN
    UnpositionalTag _;
#endif

    namespace Detail {

#ifdef CLARA_CONSOLE_WIDTH
    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
#else
    const unsigned int consoleWidth = 80;
#endif

        using namespace Tbc;

        inline bool startsWith( std::string const& str, std::string const& prefix ) {
            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
        }

        template struct RemoveConstRef{ typedef T type; };
        template struct RemoveConstRef{ typedef T type; };
        template struct RemoveConstRef{ typedef T type; };
        template struct RemoveConstRef{ typedef T type; };

        template    struct IsBool       { static const bool value = false; };
        template<>              struct IsBool { static const bool value = true; };

        template
        void convertInto( std::string const& _source, T& _dest ) {
            std::stringstream ss;
            ss << _source;
            ss >> _dest;
            if( ss.fail() )
                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
        }
        inline void convertInto( std::string const& _source, std::string& _dest ) {
            _dest = _source;
        }
        inline void convertInto( std::string const& _source, bool& _dest ) {
            std::string sourceLC = _source;
            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower );
            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
                _dest = true;
            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
                _dest = false;
            else
                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
        }
        inline void convertInto( bool _source, bool& _dest ) {
            _dest = _source;
        }
        template
        inline void convertInto( bool, T& ) {
            throw std::runtime_error( "Invalid conversion" );
        }

        template
        struct IArgFunction {
            virtual ~IArgFunction() {}
#  ifdef CATCH_CPP11_OR_GREATER
            IArgFunction()                      = default;
            IArgFunction( IArgFunction const& ) = default;
#  endif
            virtual void set( ConfigT& config, std::string const& value ) const = 0;
            virtual void setFlag( ConfigT& config ) const = 0;
            virtual bool takesArg() const = 0;
            virtual IArgFunction* clone() const = 0;
        };

        template
        class BoundArgFunction {
        public:
            BoundArgFunction() : functionObj( NULL ) {}
            BoundArgFunction( IArgFunction* _functionObj ) : functionObj( _functionObj ) {}
            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : NULL ) {}
            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
                IArgFunction* newFunctionObj = other.functionObj ? other.functionObj->clone() : NULL;
                delete functionObj;
                functionObj = newFunctionObj;
                return *this;
            }
            ~BoundArgFunction() { delete functionObj; }

            void set( ConfigT& config, std::string const& value ) const {
                functionObj->set( config, value );
            }
            void setFlag( ConfigT& config ) const {
                functionObj->setFlag( config );
            }
            bool takesArg() const { return functionObj->takesArg(); }

            bool isSet() const {
                return functionObj != NULL;
            }
        private:
            IArgFunction* functionObj;
        };

        template
        struct NullBinder : IArgFunction{
            virtual void set( C&, std::string const& ) const {}
            virtual void setFlag( C& ) const {}
            virtual bool takesArg() const { return true; }
            virtual IArgFunction* clone() const { return new NullBinder( *this ); }
        };

        template
        struct BoundDataMember : IArgFunction{
            BoundDataMember( M C::* _member ) : member( _member ) {}
            virtual void set( C& p, std::string const& stringValue ) const {
                convertInto( stringValue, p.*member );
            }
            virtual void setFlag( C& p ) const {
                convertInto( true, p.*member );
            }
            virtual bool takesArg() const { return !IsBool::value; }
            virtual IArgFunction* clone() const { return new BoundDataMember( *this ); }
            M C::* member;
        };
        template
        struct BoundUnaryMethod : IArgFunction{
            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
            virtual void set( C& p, std::string const& stringValue ) const {
                typename RemoveConstRef::type value;
                convertInto( stringValue, value );
                (p.*member)( value );
            }
            virtual void setFlag( C& p ) const {
                typename RemoveConstRef::type value;
                convertInto( true, value );
                (p.*member)( value );
            }
            virtual bool takesArg() const { return !IsBool::value; }
            virtual IArgFunction* clone() const { return new BoundUnaryMethod( *this ); }
            void (C::*member)( M );
        };
        template
        struct BoundNullaryMethod : IArgFunction{
            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
            virtual void set( C& p, std::string const& stringValue ) const {
                bool value;
                convertInto( stringValue, value );
                if( value )
                    (p.*member)();
            }
            virtual void setFlag( C& p ) const {
                (p.*member)();
            }
            virtual bool takesArg() const { return false; }
            virtual IArgFunction* clone() const { return new BoundNullaryMethod( *this ); }
            void (C::*member)();
        };

        template
        struct BoundUnaryFunction : IArgFunction{
            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
            virtual void set( C& obj, std::string const& stringValue ) const {
                bool value;
                convertInto( stringValue, value );
                if( value )
                    function( obj );
            }
            virtual void setFlag( C& p ) const {
                function( p );
            }
            virtual bool takesArg() const { return false; }
            virtual IArgFunction* clone() const { return new BoundUnaryFunction( *this ); }
            void (*function)( C& );
        };

        template
        struct BoundBinaryFunction : IArgFunction{
            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
            virtual void set( C& obj, std::string const& stringValue ) const {
                typename RemoveConstRef::type value;
                convertInto( stringValue, value );
                function( obj, value );
            }
            virtual void setFlag( C& obj ) const {
                typename RemoveConstRef::type value;
                convertInto( true, value );
                function( obj, value );
            }
            virtual bool takesArg() const { return !IsBool::value; }
            virtual IArgFunction* clone() const { return new BoundBinaryFunction( *this ); }
            void (*function)( C&, T );
        };

    } // namespace Detail

    struct Parser {
        Parser() : separators( " \t=:" ) {}

        struct Token {
            enum Type { Positional, ShortOpt, LongOpt };
            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
            Type type;
            std::string data;
        };

        void parseIntoTokens( int argc, char const * const * argv, std::vector& tokens ) const {
            const std::string doubleDash = "--";
            for( int i = 1; i < argc && argv[i] != doubleDash; ++i )
                parseIntoTokens( argv[i] , tokens);
        }
        void parseIntoTokens( std::string arg, std::vector& tokens ) const {
            while( !arg.empty() ) {
                Parser::Token token( Parser::Token::Positional, arg );
                arg = "";
                if( token.data[0] == '-' ) {
                    if( token.data.size() > 1 && token.data[1] == '-' ) {
                        token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) );
                    }
                    else {
                        token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) );
                        if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) {
                            arg = "-" + token.data.substr( 1 );
                            token.data = token.data.substr( 0, 1 );
                        }
                    }
                }
                if( token.type != Parser::Token::Positional ) {
                    std::size_t pos = token.data.find_first_of( separators );
                    if( pos != std::string::npos ) {
                        arg = token.data.substr( pos+1 );
                        token.data = token.data.substr( 0, pos );
                    }
                }
                tokens.push_back( token );
            }
        }
        std::string separators;
    };

    template
    struct CommonArgProperties {
        CommonArgProperties() {}
        CommonArgProperties( Detail::BoundArgFunction const& _boundField ) : boundField( _boundField ) {}

        Detail::BoundArgFunction boundField;
        std::string description;
        std::string detail;
        std::string placeholder; // Only value if boundField takes an arg

        bool takesArg() const {
            return !placeholder.empty();
        }
        void validate() const {
            if( !boundField.isSet() )
                throw std::logic_error( "option not bound" );
        }
    };
    struct OptionArgProperties {
        std::vector shortNames;
        std::string longName;

        bool hasShortName( std::string const& shortName ) const {
            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
        }
        bool hasLongName( std::string const& _longName ) const {
            return _longName == longName;
        }
    };
    struct PositionalArgProperties {
        PositionalArgProperties() : position( -1 ) {}
        int position; // -1 means non-positional (floating)

        bool isFixedPositional() const {
            return position != -1;
        }
    };

    template
    class CommandLine {

        struct Arg : CommonArgProperties, OptionArgProperties, PositionalArgProperties {
            Arg() {}
            Arg( Detail::BoundArgFunction const& _boundField ) : CommonArgProperties( _boundField ) {}

            using CommonArgProperties::placeholder; // !TBD

            std::string dbgName() const {
                if( !longName.empty() )
                    return "--" + longName;
                if( !shortNames.empty() )
                    return "-" + shortNames[0];
                return "positional args";
            }
            std::string commands() const {
                std::ostringstream oss;
                bool first = true;
                std::vector::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
                for(; it != itEnd; ++it ) {
                    if( first )
                        first = false;
                    else
                        oss << ", ";
                    oss << "-" << *it;
                }
                if( !longName.empty() ) {
                    if( !first )
                        oss << ", ";
                    oss << "--" << longName;
                }
                if( !placeholder.empty() )
                    oss << " <" << placeholder << ">";
                return oss.str();
            }
        };

        // NOTE: std::auto_ptr is deprecated in c++11/c++0x
#if defined(__cplusplus) && __cplusplus > 199711L
        typedef std::unique_ptr ArgAutoPtr;
#else
        typedef std::auto_ptr ArgAutoPtr;
#endif

        friend void addOptName( Arg& arg, std::string const& optName )
        {
            if( optName.empty() )
                return;
            if( Detail::startsWith( optName, "--" ) ) {
                if( !arg.longName.empty() )
                    throw std::logic_error( "Only one long opt may be specified. '"
                        + arg.longName
                        + "' already specified, now attempting to add '"
                        + optName + "'" );
                arg.longName = optName.substr( 2 );
            }
            else if( Detail::startsWith( optName, "-" ) )
                arg.shortNames.push_back( optName.substr( 1 ) );
            else
                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
        }
        friend void setPositionalArg( Arg& arg, int position )
        {
            arg.position = position;
        }

        class ArgBuilder {
        public:
            ArgBuilder( Arg* arg ) : m_arg( arg ) {}

            // Bind a non-boolean data member (requires placeholder string)
            template
            void bind( M C::* field, std::string const& placeholder ) {
                m_arg->boundField = new Detail::BoundDataMember( field );
                m_arg->placeholder = placeholder;
            }
            // Bind a boolean data member (no placeholder required)
            template
            void bind( bool C::* field ) {
                m_arg->boundField = new Detail::BoundDataMember( field );
            }

            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
            template
            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
                m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod );
                m_arg->placeholder = placeholder;
            }

            // Bind a method taking a single, boolean argument (no placeholder string required)
            template
            void bind( void (C::* unaryMethod)( bool ) ) {
                m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod );
            }

            // Bind a method that takes no arguments (will be called if opt is present)
            template
            void bind( void (C::* nullaryMethod)() ) {
                m_arg->boundField = new Detail::BoundNullaryMethod( nullaryMethod );
            }

            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
            template
            void bind( void (* unaryFunction)( C& ) ) {
                m_arg->boundField = new Detail::BoundUnaryFunction( unaryFunction );
            }

            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
            template
            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
                m_arg->boundField = new Detail::BoundBinaryFunction( binaryFunction );
                m_arg->placeholder = placeholder;
            }

            ArgBuilder& describe( std::string const& description ) {
                m_arg->description = description;
                return *this;
            }
            ArgBuilder& detail( std::string const& detail ) {
                m_arg->detail = detail;
                return *this;
            }

        protected:
            Arg* m_arg;
        };

        class OptBuilder : public ArgBuilder {
        public:
            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}

            OptBuilder& operator[]( std::string const& optName ) {
                addOptName( *ArgBuilder::m_arg, optName );
                return *this;
            }
        };

    public:

        CommandLine()
        :   m_boundProcessName( new Detail::NullBinder() ),
            m_highestSpecifiedArgPosition( 0 ),
            m_throwOnUnrecognisedTokens( false )
        {}
        CommandLine( CommandLine const& other )
        :   m_boundProcessName( other.m_boundProcessName ),
            m_options ( other.m_options ),
            m_positionalArgs( other.m_positionalArgs ),
            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
        {
            if( other.m_floatingArg.get() )
                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
        }

        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
            m_throwOnUnrecognisedTokens = shouldThrow;
            return *this;
        }

        OptBuilder operator[]( std::string const& optName ) {
            m_options.push_back( Arg() );
            addOptName( m_options.back(), optName );
            OptBuilder builder( &m_options.back() );
            return builder;
        }

        ArgBuilder operator[]( int position ) {
            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
            if( position > m_highestSpecifiedArgPosition )
                m_highestSpecifiedArgPosition = position;
            setPositionalArg( m_positionalArgs[position], position );
            ArgBuilder builder( &m_positionalArgs[position] );
            return builder;
        }

        // Invoke this with the _ instance
        ArgBuilder operator[]( UnpositionalTag ) {
            if( m_floatingArg.get() )
                throw std::logic_error( "Only one unpositional argument can be added" );
            m_floatingArg.reset( new Arg() );
            ArgBuilder builder( m_floatingArg.get() );
            return builder;
        }

        template
        void bindProcessName( M C::* field ) {
            m_boundProcessName = new Detail::BoundDataMember( field );
        }
        template
        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
            m_boundProcessName = new Detail::BoundUnaryMethod( _unaryMethod );
        }

        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
            typename std::vector::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
            std::size_t maxWidth = 0;
            for( it = itBegin; it != itEnd; ++it )
                maxWidth = (std::max)( maxWidth, it->commands().size() );

            for( it = itBegin; it != itEnd; ++it ) {
                Detail::Text usage( it->commands(), Detail::TextAttributes()
                                                        .setWidth( maxWidth+indent )
                                                        .setIndent( indent ) );
                Detail::Text desc( it->description, Detail::TextAttributes()
                                                        .setWidth( width - maxWidth - 3 ) );

                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
                    std::string usageCol = i < usage.size() ? usage[i] : "";
                    os << usageCol;

                    if( i < desc.size() && !desc[i].empty() )
                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
                            << desc[i];
                    os << "\n";
                }
            }
        }
        std::string optUsage() const {
            std::ostringstream oss;
            optUsage( oss );
            return oss.str();
        }

        void argSynopsis( std::ostream& os ) const {
            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
                if( i > 1 )
                    os << " ";
                typename std::map::const_iterator it = m_positionalArgs.find( i );
                if( it != m_positionalArgs.end() )
                    os << "<" << it->second.placeholder << ">";
                else if( m_floatingArg.get() )
                    os << "<" << m_floatingArg->placeholder << ">";
                else
                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
            }
            // !TBD No indication of mandatory args
            if( m_floatingArg.get() ) {
                if( m_highestSpecifiedArgPosition > 1 )
                    os << " ";
                os << "[<" << m_floatingArg->placeholder << "> ...]";
            }
        }
        std::string argSynopsis() const {
            std::ostringstream oss;
            argSynopsis( oss );
            return oss.str();
        }

        void usage( std::ostream& os, std::string const& procName ) const {
            validate();
            os << "usage:\n  " << procName << " ";
            argSynopsis( os );
            if( !m_options.empty() ) {
                os << " [options]\n\nwhere options are: \n";
                optUsage( os, 2 );
            }
            os << "\n";
        }
        std::string usage( std::string const& procName ) const {
            std::ostringstream oss;
            usage( oss, procName );
            return oss.str();
        }

        ConfigT parse( int argc, char const * const * argv ) const {
            ConfigT config;
            parseInto( argc, argv, config );
            return config;
        }

        std::vector parseInto( int argc, char const * const * argv, ConfigT& config ) const {
            std::string processName = argv[0];
            std::size_t lastSlash = processName.find_last_of( "/\\" );
            if( lastSlash != std::string::npos )
                processName = processName.substr( lastSlash+1 );
            m_boundProcessName.set( config, processName );
            std::vector tokens;
            Parser parser;
            parser.parseIntoTokens( argc, argv, tokens );
            return populate( tokens, config );
        }

        std::vector populate( std::vector const& tokens, ConfigT& config ) const {
            validate();
            std::vector unusedTokens = populateOptions( tokens, config );
            unusedTokens = populateFixedArgs( unusedTokens, config );
            unusedTokens = populateFloatingArgs( unusedTokens, config );
            return unusedTokens;
        }

        std::vector populateOptions( std::vector const& tokens, ConfigT& config ) const {
            std::vector unusedTokens;
            std::vector errors;
            for( std::size_t i = 0; i < tokens.size(); ++i ) {
                Parser::Token const& token = tokens[i];
                typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end();
                for(; it != itEnd; ++it ) {
                    Arg const& arg = *it;

                    try {
                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
                            if( arg.takesArg() ) {
                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
                                    errors.push_back( "Expected argument to option: " + token.data );
                                else
                                    arg.boundField.set( config, tokens[++i].data );
                            }
                            else {
                                arg.boundField.setFlag( config );
                            }
                            break;
                        }
                    }
                    catch( std::exception& ex ) {
                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
                    }
                }
                if( it == itEnd ) {
                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
                        unusedTokens.push_back( token );
                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
                        errors.push_back( "unrecognised option: " + token.data );
                }
            }
            if( !errors.empty() ) {
                std::ostringstream oss;
                for( std::vector::const_iterator it = errors.begin(), itEnd = errors.end();
                        it != itEnd;
                        ++it ) {
                    if( it != errors.begin() )
                        oss << "\n";
                    oss << *it;
                }
                throw std::runtime_error( oss.str() );
            }
            return unusedTokens;
        }
        std::vector populateFixedArgs( std::vector const& tokens, ConfigT& config ) const {
            std::vector unusedTokens;
            int position = 1;
            for( std::size_t i = 0; i < tokens.size(); ++i ) {
                Parser::Token const& token = tokens[i];
                typename std::map::const_iterator it = m_positionalArgs.find( position );
                if( it != m_positionalArgs.end() )
                    it->second.boundField.set( config, token.data );
                else
                    unusedTokens.push_back( token );
                if( token.type == Parser::Token::Positional )
                    position++;
            }
            return unusedTokens;
        }
        std::vector populateFloatingArgs( std::vector const& tokens, ConfigT& config ) const {
            if( !m_floatingArg.get() )
                return tokens;
            std::vector unusedTokens;
            for( std::size_t i = 0; i < tokens.size(); ++i ) {
                Parser::Token const& token = tokens[i];
                if( token.type == Parser::Token::Positional )
                    m_floatingArg->boundField.set( config, token.data );
                else
                    unusedTokens.push_back( token );
            }
            return unusedTokens;
        }

        void validate() const
        {
            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
                throw std::logic_error( "No options or arguments specified" );

            for( typename std::vector::const_iterator  it = m_options.begin(),
                                                            itEnd = m_options.end();
                    it != itEnd; ++it )
                it->validate();
        }

    private:
        Detail::BoundArgFunction m_boundProcessName;
        std::vector m_options;
        std::map m_positionalArgs;
        ArgAutoPtr m_floatingArg;
        int m_highestSpecifiedArgPosition;
        bool m_throwOnUnrecognisedTokens;
    };

} // end namespace Clara

STITCH_CLARA_CLOSE_NAMESPACE
#undef STITCH_CLARA_OPEN_NAMESPACE
#undef STITCH_CLARA_CLOSE_NAMESPACE

#endif // TWOBLUECUBES_CLARA_H_INCLUDED
#undef STITCH_CLARA_OPEN_NAMESPACE

// Restore Clara's value for console width, if present
#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
#endif

#include 

namespace Catch {

    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
    inline void abortAfterX( ConfigData& config, int x ) {
        if( x < 1 )
            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
        config.abortAfter = x;
    }
    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }

    inline void addWarning( ConfigData& config, std::string const& _warning ) {
        if( _warning == "NoAssertions" )
            config.warnings = static_cast( config.warnings | WarnAbout::NoAssertions );
        else
            throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
    }
    inline void setOrder( ConfigData& config, std::string const& order ) {
        if( startsWith( "declared", order ) )
            config.runOrder = RunTests::InDeclarationOrder;
        else if( startsWith( "lexical", order ) )
            config.runOrder = RunTests::InLexicographicalOrder;
        else if( startsWith( "random", order ) )
            config.runOrder = RunTests::InRandomOrder;
        else
            throw std::runtime_error( "Unrecognised ordering: '" + order + "'" );
    }
    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
        if( seed == "time" ) {
            config.rngSeed = static_cast( std::time(0) );
        }
        else {
            std::stringstream ss;
            ss << seed;
            ss >> config.rngSeed;
            if( ss.fail() )
                throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" );
        }
    }
    inline void setVerbosity( ConfigData& config, int level ) {
        // !TBD: accept strings?
        config.verbosity = static_cast( level );
    }
    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
        config.showDurations = _showDurations
            ? ShowDurations::Always
            : ShowDurations::Never;
    }
    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
        std::ifstream f( _filename.c_str() );
        if( !f.is_open() )
            throw std::domain_error( "Unable to load input file: " + _filename );

        std::string line;
        while( std::getline( f, line ) ) {
            line = trim(line);
            if( !line.empty() && !startsWith( line, "#" ) )
                addTestOrTags( config, "\"" + line + "\"," );
        }
    }

    inline Clara::CommandLine makeCommandLineParser() {

        using namespace Clara;
        CommandLine cli;

        cli.bindProcessName( &ConfigData::processName );

        cli["-?"]["-h"]["--help"]
            .describe( "display usage information" )
            .bind( &ConfigData::showHelp );

        cli["-l"]["--list-tests"]
            .describe( "list all/matching test cases" )
            .bind( &ConfigData::listTests );

        cli["-t"]["--list-tags"]
            .describe( "list all/matching tags" )
            .bind( &ConfigData::listTags );

        cli["-s"]["--success"]
            .describe( "include successful tests in output" )
            .bind( &ConfigData::showSuccessfulTests );

        cli["-b"]["--break"]
            .describe( "break into debugger on failure" )
            .bind( &ConfigData::shouldDebugBreak );

        cli["-e"]["--nothrow"]
            .describe( "skip exception tests" )
            .bind( &ConfigData::noThrow );

        cli["-i"]["--invisibles"]
            .describe( "show invisibles (tabs, newlines)" )
            .bind( &ConfigData::showInvisibles );

        cli["-o"]["--out"]
            .describe( "output filename" )
            .bind( &ConfigData::outputFilename, "filename" );

        cli["-r"]["--reporter"]
//            .placeholder( "name[:filename]" )
            .describe( "reporter to use (defaults to console)" )
            .bind( &ConfigData::reporterName, "name" );

        cli["-n"]["--name"]
            .describe( "suite name" )
            .bind( &ConfigData::name, "name" );

        cli["-a"]["--abort"]
            .describe( "abort at first failure" )
            .bind( &abortAfterFirst );

        cli["-x"]["--abortx"]
            .describe( "abort after x failures" )
            .bind( &abortAfterX, "no. failures" );

        cli["-w"]["--warn"]
            .describe( "enable warnings" )
            .bind( &addWarning, "warning name" );

// - needs updating if reinstated
//        cli.into( &setVerbosity )
//            .describe( "level of verbosity (0=no output)" )
//            .shortOpt( "v")
//            .longOpt( "verbosity" )
//            .placeholder( "level" );

        cli[_]
            .describe( "which test or tests to use" )
            .bind( &addTestOrTags, "test name, pattern or tags" );

        cli["-d"]["--durations"]
            .describe( "show test durations" )
            .bind( &setShowDurations, "yes/no" );

        cli["-f"]["--input-file"]
            .describe( "load test names to run from a file" )
            .bind( &loadTestNamesFromFile, "filename" );

        // Less common commands which don't have a short form
        cli["--list-test-names-only"]
            .describe( "list all/matching test cases names only" )
            .bind( &ConfigData::listTestNamesOnly );

        cli["--list-reporters"]
            .describe( "list all reporters" )
            .bind( &ConfigData::listReporters );

        cli["--order"]
            .describe( "test case order (defaults to decl)" )
            .bind( &setOrder, "decl|lex|rand" );

        cli["--rng-seed"]
            .describe( "set a specific seed for random numbers" )
            .bind( &setRngSeed, "'time'|number" );

        cli["--force-colour"]
            .describe( "force colourised output" )
            .bind( &ConfigData::forceColour );

        return cli;
    }

} // end namespace Catch

// #included from: internal/catch_list.hpp
#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED

// #included from: catch_text.h
#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED

#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH

#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
// #included from: ../external/tbc_text_format.h
// Only use header guard if we are not using an outer namespace
#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
#  endif
# else
#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
# endif
#endif
#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
#include 
#include 
#include 

// Use optional outer namespace
#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
#endif

namespace Tbc {

#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
#else
    const unsigned int consoleWidth = 80;
#endif

    struct TextAttributes {
        TextAttributes()
        :   initialIndent( std::string::npos ),
            indent( 0 ),
            width( consoleWidth-1 ),
            tabChar( '\t' )
        {}

        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }

        std::size_t initialIndent;  // indent of first line, or npos
        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
        char tabChar;               // If this char is seen the indent is changed to current pos
    };

    class Text {
    public:
        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
        : attr( _attr )
        {
            std::string wrappableChars = " [({.,/|\\-";
            std::size_t indent = _attr.initialIndent != std::string::npos
                ? _attr.initialIndent
                : _attr.indent;
            std::string remainder = _str;

            while( !remainder.empty() ) {
                if( lines.size() >= 1000 ) {
                    lines.push_back( "... message truncated due to excessive size" );
                    return;
                }
                std::size_t tabPos = std::string::npos;
                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
                std::size_t pos = remainder.find_first_of( '\n' );
                if( pos <= width ) {
                    width = pos;
                }
                pos = remainder.find_last_of( _attr.tabChar, width );
                if( pos != std::string::npos ) {
                    tabPos = pos;
                    if( remainder[width] == '\n' )
                        width--;
                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
                }

                if( width == remainder.size() ) {
                    spliceLine( indent, remainder, width );
                }
                else if( remainder[width] == '\n' ) {
                    spliceLine( indent, remainder, width );
                    if( width <= 1 || remainder.size() != 1 )
                        remainder = remainder.substr( 1 );
                    indent = _attr.indent;
                }
                else {
                    pos = remainder.find_last_of( wrappableChars, width );
                    if( pos != std::string::npos && pos > 0 ) {
                        spliceLine( indent, remainder, pos );
                        if( remainder[0] == ' ' )
                            remainder = remainder.substr( 1 );
                    }
                    else {
                        spliceLine( indent, remainder, width-1 );
                        lines.back() += "-";
                    }
                    if( lines.size() == 1 )
                        indent = _attr.indent;
                    if( tabPos != std::string::npos )
                        indent += tabPos;
                }
            }
        }

        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
            _remainder = _remainder.substr( _pos );
        }

        typedef std::vector::const_iterator const_iterator;

        const_iterator begin() const { return lines.begin(); }
        const_iterator end() const { return lines.end(); }
        std::string const& last() const { return lines.back(); }
        std::size_t size() const { return lines.size(); }
        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
        std::string toString() const {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }

        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
                it != itEnd; ++it ) {
                if( it != _text.begin() )
                    _stream << "\n";
                _stream << *it;
            }
            return _stream;
        }

    private:
        std::string str;
        TextAttributes attr;
        std::vector lines;
    };

} // end namespace Tbc

#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
} // end outer namespace
#endif

#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE

namespace Catch {
    using Tbc::Text;
    using Tbc::TextAttributes;
}

// #included from: catch_console_colour.hpp
#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED

namespace Catch {

    struct Colour {
        enum Code {
            None = 0,

            White,
            Red,
            Green,
            Blue,
            Cyan,
            Yellow,
            Grey,

            Bright = 0x10,

            BrightRed = Bright | Red,
            BrightGreen = Bright | Green,
            LightGrey = Bright | Grey,
            BrightWhite = Bright | White,

            // By intention
            FileName = LightGrey,
            Warning = Yellow,
            ResultError = BrightRed,
            ResultSuccess = BrightGreen,
            ResultExpectedFailure = Warning,

            Error = BrightRed,
            Success = Green,

            OriginalExpression = Cyan,
            ReconstructedExpression = Yellow,

            SecondaryText = LightGrey,
            Headers = White
        };

        // Use constructed object for RAII guard
        Colour( Code _colourCode );
        Colour( Colour const& other );
        ~Colour();

        // Use static method for one-shot changes
        static void use( Code _colourCode );

    private:
        bool m_moved;
    };

    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }

} // end namespace Catch

// #included from: catch_interfaces_reporter.h
#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED

#include 
#include 
#include 
#include 

namespace Catch
{
    struct ReporterConfig {
        explicit ReporterConfig( Ptr const& _fullConfig )
        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}

        ReporterConfig( Ptr const& _fullConfig, std::ostream& _stream )
        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}

        std::ostream& stream() const    { return *m_stream; }
        Ptr fullConfig() const { return m_fullConfig; }

    private:
        std::ostream* m_stream;
        Ptr m_fullConfig;
    };

    struct ReporterPreferences {
        ReporterPreferences()
        : shouldRedirectStdOut( false )
        {}

        bool shouldRedirectStdOut;
    };

    template
    struct LazyStat : Option {
        LazyStat() : used( false ) {}
        LazyStat& operator=( T const& _value ) {
            Option::operator=( _value );
            used = false;
            return *this;
        }
        void reset() {
            Option::reset();
            used = false;
        }
        bool used;
    };

    struct TestRunInfo {
        TestRunInfo( std::string const& _name ) : name( _name ) {}
        std::string name;
    };
    struct GroupInfo {
        GroupInfo(  std::string const& _name,
                    std::size_t _groupIndex,
                    std::size_t _groupsCount )
        :   name( _name ),
            groupIndex( _groupIndex ),
            groupsCounts( _groupsCount )
        {}

        std::string name;
        std::size_t groupIndex;
        std::size_t groupsCounts;
    };

    struct AssertionStats {
        AssertionStats( AssertionResult const& _assertionResult,
                        std::vector const& _infoMessages,
                        Totals const& _totals )
        :   assertionResult( _assertionResult ),
            infoMessages( _infoMessages ),
            totals( _totals )
        {
            if( assertionResult.hasMessage() ) {
                // Copy message into messages list.
                // !TBD This should have been done earlier, somewhere
                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
                builder << assertionResult.getMessage();
                builder.m_info.message = builder.m_stream.str();

                infoMessages.push_back( builder.m_info );
            }
        }
        virtual ~AssertionStats();

#  ifdef CATCH_CPP11_OR_GREATER
        AssertionStats( AssertionStats const& )              = default;
        AssertionStats( AssertionStats && )                  = default;
        AssertionStats& operator = ( AssertionStats const& ) = default;
        AssertionStats& operator = ( AssertionStats && )     = default;
#  endif

        AssertionResult assertionResult;
        std::vector infoMessages;
        Totals totals;
    };

    struct SectionStats {
        SectionStats(   SectionInfo const& _sectionInfo,
                        Counts const& _assertions,
                        double _durationInSeconds,
                        bool _missingAssertions )
        :   sectionInfo( _sectionInfo ),
            assertions( _assertions ),
            durationInSeconds( _durationInSeconds ),
            missingAssertions( _missingAssertions )
        {}
        virtual ~SectionStats();
#  ifdef CATCH_CPP11_OR_GREATER
        SectionStats( SectionStats const& )              = default;
        SectionStats( SectionStats && )                  = default;
        SectionStats& operator = ( SectionStats const& ) = default;
        SectionStats& operator = ( SectionStats && )     = default;
#  endif

        SectionInfo sectionInfo;
        Counts assertions;
        double durationInSeconds;
        bool missingAssertions;
    };

    struct TestCaseStats {
        TestCaseStats(  TestCaseInfo const& _testInfo,
                        Totals const& _totals,
                        std::string const& _stdOut,
                        std::string const& _stdErr,
                        bool _aborting )
        : testInfo( _testInfo ),
            totals( _totals ),
            stdOut( _stdOut ),
            stdErr( _stdErr ),
            aborting( _aborting )
        {}
        virtual ~TestCaseStats();

#  ifdef CATCH_CPP11_OR_GREATER
        TestCaseStats( TestCaseStats const& )              = default;
        TestCaseStats( TestCaseStats && )                  = default;
        TestCaseStats& operator = ( TestCaseStats const& ) = default;
        TestCaseStats& operator = ( TestCaseStats && )     = default;
#  endif

        TestCaseInfo testInfo;
        Totals totals;
        std::string stdOut;
        std::string stdErr;
        bool aborting;
    };

    struct TestGroupStats {
        TestGroupStats( GroupInfo const& _groupInfo,
                        Totals const& _totals,
                        bool _aborting )
        :   groupInfo( _groupInfo ),
            totals( _totals ),
            aborting( _aborting )
        {}
        TestGroupStats( GroupInfo const& _groupInfo )
        :   groupInfo( _groupInfo ),
            aborting( false )
        {}
        virtual ~TestGroupStats();

#  ifdef CATCH_CPP11_OR_GREATER
        TestGroupStats( TestGroupStats const& )              = default;
        TestGroupStats( TestGroupStats && )                  = default;
        TestGroupStats& operator = ( TestGroupStats const& ) = default;
        TestGroupStats& operator = ( TestGroupStats && )     = default;
#  endif

        GroupInfo groupInfo;
        Totals totals;
        bool aborting;
    };

    struct TestRunStats {
        TestRunStats(   TestRunInfo const& _runInfo,
                        Totals const& _totals,
                        bool _aborting )
        :   runInfo( _runInfo ),
            totals( _totals ),
            aborting( _aborting )
        {}
        virtual ~TestRunStats();

#  ifndef CATCH_CPP11_OR_GREATER
        TestRunStats( TestRunStats const& _other )
        :   runInfo( _other.runInfo ),
            totals( _other.totals ),
            aborting( _other.aborting )
        {}
#  else
        TestRunStats( TestRunStats const& )              = default;
        TestRunStats( TestRunStats && )                  = default;
        TestRunStats& operator = ( TestRunStats const& ) = default;
        TestRunStats& operator = ( TestRunStats && )     = default;
#  endif

        TestRunInfo runInfo;
        Totals totals;
        bool aborting;
    };

    struct IStreamingReporter : IShared {
        virtual ~IStreamingReporter();

        // Implementing class must also provide the following static method:
        // static std::string getDescription();

        virtual ReporterPreferences getPreferences() const = 0;

        virtual void noMatchingTestCases( std::string const& spec ) = 0;

        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;

        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;

        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;

        // The return value indicates if the messages buffer should be cleared:
        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;

        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
    };

    struct IReporterFactory {
        virtual ~IReporterFactory();
        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
        virtual std::string getDescription() const = 0;
    };

    struct IReporterRegistry {
        typedef std::map FactoryMap;

        virtual ~IReporterRegistry();
        virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const = 0;
        virtual FactoryMap const& getFactories() const = 0;
    };

}

#include 
#include 

namespace Catch {

    inline std::size_t listTests( Config const& config ) {

        TestSpec testSpec = config.testSpec();
        if( config.testSpec().hasFilters() )
            Catch::cout() << "Matching test cases:\n";
        else {
            Catch::cout() << "All available test cases:\n";
            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
        }

        std::size_t matchedTests = 0;
        TextAttributes nameAttr, tagsAttr;
        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
        tagsAttr.setIndent( 6 );

        std::vector matchedTestCases;
        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
        for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
                it != itEnd;
                ++it ) {
            matchedTests++;
            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
            Colour::Code colour = testCaseInfo.isHidden()
                ? Colour::SecondaryText
                : Colour::None;
            Colour colourGuard( colour );

            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
            if( !testCaseInfo.tags.empty() )
                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
        }

        if( !config.testSpec().hasFilters() )
            Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
        else
            Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
        return matchedTests;
    }

    inline std::size_t listTestsNamesOnly( Config const& config ) {
        TestSpec testSpec = config.testSpec();
        if( !config.testSpec().hasFilters() )
            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
        std::size_t matchedTests = 0;
        std::vector matchedTestCases;
        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
        for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
                it != itEnd;
                ++it ) {
            matchedTests++;
            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
            Catch::cout() << testCaseInfo.name << std::endl;
        }
        return matchedTests;
    }

    struct TagInfo {
        TagInfo() : count ( 0 ) {}
        void add( std::string const& spelling ) {
            ++count;
            spellings.insert( spelling );
        }
        std::string all() const {
            std::string out;
            for( std::set::const_iterator it = spellings.begin(), itEnd = spellings.end();
                        it != itEnd;
                        ++it )
                out += "[" + *it + "]";
            return out;
        }
        std::set spellings;
        std::size_t count;
    };

    inline std::size_t listTags( Config const& config ) {
        TestSpec testSpec = config.testSpec();
        if( config.testSpec().hasFilters() )
            Catch::cout() << "Tags for matching test cases:\n";
        else {
            Catch::cout() << "All available tags:\n";
            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
        }

        std::map tagCounts;

        std::vector matchedTestCases;
        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
        for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
                it != itEnd;
                ++it ) {
            for( std::set::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
                                                        tagItEnd = it->getTestCaseInfo().tags.end();
                    tagIt != tagItEnd;
                    ++tagIt ) {
                std::string tagName = *tagIt;
                std::string lcaseTagName = toLower( tagName );
                std::map::iterator countIt = tagCounts.find( lcaseTagName );
                if( countIt == tagCounts.end() )
                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
                countIt->second.add( tagName );
            }
        }

        for( std::map::const_iterator countIt = tagCounts.begin(),
                                                            countItEnd = tagCounts.end();
                countIt != countItEnd;
                ++countIt ) {
            std::ostringstream oss;
            oss << "  " << std::setw(2) << countIt->second.count << "  ";
            Text wrapper( countIt->second.all(), TextAttributes()
                                                    .setInitialIndent( 0 )
                                                    .setIndent( oss.str().size() )
                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
            Catch::cout() << oss.str() << wrapper << "\n";
        }
        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
        return tagCounts.size();
    }

    inline std::size_t listReporters( Config const& /*config*/ ) {
        Catch::cout() << "Available reporters:\n";
        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
        std::size_t maxNameLen = 0;
        for(it = itBegin; it != itEnd; ++it )
            maxNameLen = (std::max)( maxNameLen, it->first.size() );

        for(it = itBegin; it != itEnd; ++it ) {
            Text wrapper( it->second->getDescription(), TextAttributes()
                                                        .setInitialIndent( 0 )
                                                        .setIndent( 7+maxNameLen )
                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
            Catch::cout() << "  "
                    << it->first
                    << ":"
                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
                    << wrapper << "\n";
        }
        Catch::cout() << std::endl;
        return factories.size();
    }

    inline Option list( Config const& config ) {
        Option listedCount;
        if( config.listTests() )
            listedCount = listedCount.valueOr(0) + listTests( config );
        if( config.listTestNamesOnly() )
            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
        if( config.listTags() )
            listedCount = listedCount.valueOr(0) + listTags( config );
        if( config.listReporters() )
            listedCount = listedCount.valueOr(0) + listReporters( config );
        return listedCount;
    }

} // end namespace Catch

// #included from: internal/catch_runner_impl.hpp
#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED

// #included from: catch_test_case_tracker.hpp
#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED

#include 
#include 
#include 

namespace Catch {
namespace SectionTracking {

    class TrackedSection {

        typedef std::map TrackedSections;

    public:
        enum RunState {
            NotStarted,
            Executing,
            ExecutingChildren,
            Completed
        };

        TrackedSection( std::string const& name, TrackedSection* parent )
        :   m_name( name ), m_runState( NotStarted ), m_parent( parent )
        {}

        RunState runState() const { return m_runState; }

        TrackedSection* findChild( std::string const& childName ) {
            TrackedSections::iterator it = m_children.find( childName );
            return it != m_children.end()
                ? &it->second
                : NULL;
        }
        TrackedSection* acquireChild( std::string const& childName ) {
            if( TrackedSection* child = findChild( childName ) )
                return child;
            m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) );
            return findChild( childName );
        }
        void enter() {
            if( m_runState == NotStarted )
                m_runState = Executing;
        }
        void leave() {
            for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end();
                    it != itEnd;
                    ++it )
                if( it->second.runState() != Completed ) {
                    m_runState = ExecutingChildren;
                    return;
                }
            m_runState = Completed;
        }
        TrackedSection* getParent() {
            return m_parent;
        }
        bool hasChildren() const {
            return !m_children.empty();
        }

    private:
        std::string m_name;
        RunState m_runState;
        TrackedSections m_children;
        TrackedSection* m_parent;

    };

    class TestCaseTracker {
    public:
        TestCaseTracker( std::string const& testCaseName )
        :   m_testCase( testCaseName, NULL ),
            m_currentSection( &m_testCase ),
            m_completedASectionThisRun( false )
        {}

        bool enterSection( std::string const& name ) {
            TrackedSection* child = m_currentSection->acquireChild( name );
            if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
                return false;

            m_currentSection = child;
            m_currentSection->enter();
            return true;
        }
        void leaveSection() {
            m_currentSection->leave();
            m_currentSection = m_currentSection->getParent();
            assert( m_currentSection != NULL );
            m_completedASectionThisRun = true;
        }

        bool currentSectionHasChildren() const {
            return m_currentSection->hasChildren();
        }
        bool isCompleted() const {
            return m_testCase.runState() == TrackedSection::Completed;
        }

        class Guard {
        public:
            Guard( TestCaseTracker& tracker ) : m_tracker( tracker ) {
                m_tracker.enterTestCase();
            }
            ~Guard() {
                m_tracker.leaveTestCase();
            }
        private:
            Guard( Guard const& );
            void operator = ( Guard const& );
            TestCaseTracker& m_tracker;
        };

    private:
        void enterTestCase() {
            m_currentSection = &m_testCase;
            m_completedASectionThisRun = false;
            m_testCase.enter();
        }
        void leaveTestCase() {
            m_testCase.leave();
        }

        TrackedSection m_testCase;
        TrackedSection* m_currentSection;
        bool m_completedASectionThisRun;
    };

} // namespace SectionTracking

using SectionTracking::TestCaseTracker;

} // namespace Catch

// #included from: catch_fatal_condition.hpp
#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED

namespace Catch {

    // Report the error condition then exit the process
    inline void fatal( std::string const& message, int exitCode ) {
        IContext& context = Catch::getCurrentContext();
        IResultCapture* resultCapture = context.getResultCapture();
        resultCapture->handleFatalErrorCondition( message );

		if( Catch::alwaysTrue() ) // avoids "no return" warnings
            exit( exitCode );
    }

} // namespace Catch

#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////

namespace Catch {

    struct FatalConditionHandler {
		void reset() {}
	};

} // namespace Catch

#else // Not Windows - assumed to be POSIX compatible //////////////////////////

#include 

namespace Catch {

    struct SignalDefs { int id; const char* name; };
    extern SignalDefs signalDefs[];
    SignalDefs signalDefs[] = {
            { SIGINT,  "SIGINT - Terminal interrupt signal" },
            { SIGILL,  "SIGILL - Illegal instruction signal" },
            { SIGFPE,  "SIGFPE - Floating point error signal" },
            { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
            { SIGTERM, "SIGTERM - Termination request signal" },
            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
        };

    struct FatalConditionHandler {

        static void handleSignal( int sig ) {
            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
                if( sig == signalDefs[i].id )
                    fatal( signalDefs[i].name, -sig );
            fatal( "", -sig );
        }

        FatalConditionHandler() : m_isSet( true ) {
            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
                signal( signalDefs[i].id, handleSignal );
        }
        ~FatalConditionHandler() {
            reset();
        }
        void reset() {
            if( m_isSet ) {
                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
                    signal( signalDefs[i].id, SIG_DFL );
                m_isSet = false;
            }
        }

        bool m_isSet;
    };

} // namespace Catch

#endif // not Windows

#include 
#include 

namespace Catch {

    class StreamRedirect {

    public:
        StreamRedirect( std::ostream& stream, std::string& targetString )
        :   m_stream( stream ),
            m_prevBuf( stream.rdbuf() ),
            m_targetString( targetString )
        {
            stream.rdbuf( m_oss.rdbuf() );
        }

        ~StreamRedirect() {
            m_targetString += m_oss.str();
            m_stream.rdbuf( m_prevBuf );
        }

    private:
        std::ostream& m_stream;
        std::streambuf* m_prevBuf;
        std::ostringstream m_oss;
        std::string& m_targetString;
    };

    ///////////////////////////////////////////////////////////////////////////

    class RunContext : public IResultCapture, public IRunner {

        RunContext( RunContext const& );
        void operator =( RunContext const& );

    public:

        explicit RunContext( Ptr const& config, Ptr const& reporter )
        :   m_runInfo( config->name() ),
            m_context( getCurrentMutableContext() ),
            m_activeTestCase( NULL ),
            m_config( config ),
            m_reporter( reporter ),
            m_prevRunner( m_context.getRunner() ),
            m_prevResultCapture( m_context.getResultCapture() ),
            m_prevConfig( m_context.getConfig() )
        {
            m_context.setRunner( this );
            m_context.setConfig( m_config );
            m_context.setResultCapture( this );
            m_reporter->testRunStarting( m_runInfo );
        }

        virtual ~RunContext() {
            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
            m_context.setRunner( m_prevRunner );
            m_context.setConfig( NULL );
            m_context.setResultCapture( m_prevResultCapture );
            m_context.setConfig( m_prevConfig );
        }

        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
        }
        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
        }

        Totals runTest( TestCase const& testCase ) {
            Totals prevTotals = m_totals;

            std::string redirectedCout;
            std::string redirectedCerr;

            TestCaseInfo testInfo = testCase.getTestCaseInfo();

            m_reporter->testCaseStarting( testInfo );

            m_activeTestCase = &testCase;
            m_testCaseTracker = TestCaseTracker( testInfo.name );

            do {
                do {
                    runCurrentTest( redirectedCout, redirectedCerr );
                }
                while( !m_testCaseTracker->isCompleted() && !aborting() );
            }
            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );

            Totals deltaTotals = m_totals.delta( prevTotals );
            m_totals.testCases += deltaTotals.testCases;
            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
                                                        deltaTotals,
                                                        redirectedCout,
                                                        redirectedCerr,
                                                        aborting() ) );

            m_activeTestCase = NULL;
            m_testCaseTracker.reset();

            return deltaTotals;
        }

        Ptr config() const {
            return m_config;
        }

    private: // IResultCapture

        virtual void assertionEnded( AssertionResult const& result ) {
            if( result.getResultType() == ResultWas::Ok ) {
                m_totals.assertions.passed++;
            }
            else if( !result.isOk() ) {
                m_totals.assertions.failed++;
            }

            if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
                m_messages.clear();

            // Reset working state
            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
            m_lastResult = result;
        }

        virtual bool sectionStarted (
            SectionInfo const& sectionInfo,
            Counts& assertions
        )
        {
            std::ostringstream oss;
            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;

            if( !m_testCaseTracker->enterSection( oss.str() ) )
                return false;

            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;

            m_reporter->sectionStarting( sectionInfo );

            assertions = m_totals.assertions;

            return true;
        }
        bool testForMissingAssertions( Counts& assertions ) {
            if( assertions.total() != 0 ||
                    !m_config->warnAboutMissingAssertions() ||
                    m_testCaseTracker->currentSectionHasChildren() )
                return false;
            m_totals.assertions.failed++;
            assertions.failed++;
            return true;
        }

        virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
            if( std::uncaught_exception() ) {
                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
                return;
            }

            Counts assertions = m_totals.assertions - prevAssertions;
            bool missingAssertions = testForMissingAssertions( assertions );

            m_testCaseTracker->leaveSection();

            m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) );
            m_messages.clear();
        }

        virtual void pushScopedMessage( MessageInfo const& message ) {
            m_messages.push_back( message );
        }

        virtual void popScopedMessage( MessageInfo const& message ) {
            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
        }

        virtual std::string getCurrentTestName() const {
            return m_activeTestCase
                ? m_activeTestCase->getTestCaseInfo().name
                : "";
        }

        virtual const AssertionResult* getLastResult() const {
            return &m_lastResult;
        }

        virtual void handleFatalErrorCondition( std::string const& message ) {
            ResultBuilder resultBuilder = makeUnexpectedResultBuilder();
            resultBuilder.setResultType( ResultWas::FatalErrorCondition );
            resultBuilder << message;
            resultBuilder.captureExpression();

            handleUnfinishedSections();

            // Recreate section for test case (as we will lose the one that was in scope)
            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );

            Counts assertions;
            assertions.failed = 1;
            SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
            m_reporter->sectionEnded( testCaseSectionStats );

            TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();

            Totals deltaTotals;
            deltaTotals.testCases.failed = 1;
            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
                                                        deltaTotals,
                                                        "",
                                                        "",
                                                        false ) );
            m_totals.testCases.failed++;
            testGroupEnded( "", m_totals, 1, 1 );
            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
        }

    public:
        // !TBD We need to do this another way!
        bool aborting() const {
            return m_totals.assertions.failed == static_cast( m_config->abortAfter() );
        }

    private:

        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
            m_reporter->sectionStarting( testCaseSection );
            Counts prevAssertions = m_totals.assertions;
            double duration = 0;
            try {
                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
                TestCaseTracker::Guard guard( *m_testCaseTracker );

                Timer timer;
                timer.start();
                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
                    StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
                    invokeActiveTestCase();
                }
                else {
                    invokeActiveTestCase();
                }
                duration = timer.getElapsedSeconds();
            }
            catch( TestFailureException& ) {
                // This just means the test was aborted due to failure
            }
            catch(...) {
                makeUnexpectedResultBuilder().useActiveException();
            }
            handleUnfinishedSections();
            m_messages.clear();

            Counts assertions = m_totals.assertions - prevAssertions;
            bool missingAssertions = testForMissingAssertions( assertions );

            if( testCaseInfo.okToFail() ) {
                std::swap( assertions.failedButOk, assertions.failed );
                m_totals.assertions.failed -= assertions.failedButOk;
                m_totals.assertions.failedButOk += assertions.failedButOk;
            }

            SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
            m_reporter->sectionEnded( testCaseSectionStats );
        }

        void invokeActiveTestCase() {
            FatalConditionHandler fatalConditionHandler; // Handle signals
            m_activeTestCase->invoke();
            fatalConditionHandler.reset();
        }

    private:

        ResultBuilder makeUnexpectedResultBuilder() const {
            return ResultBuilder(   m_lastAssertionInfo.macroName.c_str(),
                                    m_lastAssertionInfo.lineInfo,
                                    m_lastAssertionInfo.capturedExpression.c_str(),
                                    m_lastAssertionInfo.resultDisposition );
        }

        void handleUnfinishedSections() {
            // If sections ended prematurely due to an exception we stored their
            // infos here so we can tear them down outside the unwind process.
            for( std::vector::const_reverse_iterator it = m_unfinishedSections.rbegin(),
                        itEnd = m_unfinishedSections.rend();
                    it != itEnd;
                    ++it )
                sectionEnded( it->info, it->prevAssertions, it->durationInSeconds );
            m_unfinishedSections.clear();
        }

        struct UnfinishedSections {
            UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds )
            : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
            {}

            SectionInfo info;
            Counts prevAssertions;
            double durationInSeconds;
        };

        TestRunInfo m_runInfo;
        IMutableContext& m_context;
        TestCase const* m_activeTestCase;
        Option m_testCaseTracker;
        AssertionResult m_lastResult;

        Ptr m_config;
        Totals m_totals;
        Ptr m_reporter;
        std::vector m_messages;
        IRunner* m_prevRunner;
        IResultCapture* m_prevResultCapture;
        Ptr m_prevConfig;
        AssertionInfo m_lastAssertionInfo;
        std::vector m_unfinishedSections;
    };

    IResultCapture& getResultCapture() {
        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
            return *capture;
        else
            throw std::logic_error( "No result capture instance" );
    }

} // end namespace Catch

// #included from: internal/catch_version.h
#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED

namespace Catch {

    // Versioning information
    struct Version {
        Version(    unsigned int _majorVersion,
                    unsigned int _minorVersion,
                    unsigned int _buildNumber,
                    char const* const _branchName )
        :   majorVersion( _majorVersion ),
            minorVersion( _minorVersion ),
            buildNumber( _buildNumber ),
            branchName( _branchName )
        {}

        unsigned int const majorVersion;
        unsigned int const minorVersion;
        unsigned int const buildNumber;
        char const* const branchName;

    private:
        void operator=( Version const& );
    };

    extern Version libraryVersion;
}

#include 
#include 
#include 

namespace Catch {

    class Runner {

    public:
        Runner( Ptr const& config )
        :   m_config( config )
        {
            openStream();
            makeReporter();
        }

        Totals runTests() {

            RunContext context( m_config.get(), m_reporter );

            Totals totals;

            context.testGroupStarting( "all tests", 1, 1 ); // deprecated?

            TestSpec testSpec = m_config->testSpec();
            if( !testSpec.hasFilters() )
                testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests

            std::vector testCases;
            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, testCases );

            int testsRunForGroup = 0;
            for( std::vector::const_iterator it = testCases.begin(), itEnd = testCases.end();
                    it != itEnd;
                    ++it ) {
                testsRunForGroup++;
                if( m_testsAlreadyRun.find( *it ) == m_testsAlreadyRun.end() ) {

                    if( context.aborting() )
                        break;

                    totals += context.runTest( *it );
                    m_testsAlreadyRun.insert( *it );
                }
            }
            std::vector skippedTestCases;
            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, skippedTestCases, true );

            for( std::vector::const_iterator it = skippedTestCases.begin(), itEnd = skippedTestCases.end();
                    it != itEnd;
                    ++it )
                m_reporter->skipTest( *it );

            context.testGroupEnded( "all tests", totals, 1, 1 );
            return totals;
        }

    private:
        void openStream() {
            // Open output file, if specified
            if( !m_config->getFilename().empty() ) {
                m_ofs.open( m_config->getFilename().c_str() );
                if( m_ofs.fail() ) {
                    std::ostringstream oss;
                    oss << "Unable to open file: '" << m_config->getFilename() << "'";
                    throw std::domain_error( oss.str() );
                }
                m_config->setStreamBuf( m_ofs.rdbuf() );
            }
        }
        void makeReporter() {
            std::string reporterName = m_config->getReporterName().empty()
                ? "console"
                : m_config->getReporterName();

            m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() );
            if( !m_reporter ) {
                std::ostringstream oss;
                oss << "No reporter registered with name: '" << reporterName << "'";
                throw std::domain_error( oss.str() );
            }
        }

    private:
        Ptr m_config;
        std::ofstream m_ofs;
        Ptr m_reporter;
        std::set m_testsAlreadyRun;
    };

    class Session : NonCopyable {
        static bool alreadyInstantiated;

    public:

        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };

        Session()
        : m_cli( makeCommandLineParser() ) {
            if( alreadyInstantiated ) {
                std::string msg = "Only one instance of Catch::Session can ever be used";
                Catch::cerr() << msg << std::endl;
                throw std::logic_error( msg );
            }
            alreadyInstantiated = true;
        }
        ~Session() {
            Catch::cleanUp();
        }

        void showHelp( std::string const& processName ) {
            Catch::cout() << "\nCatch v"    << libraryVersion.majorVersion << "."
                                        << libraryVersion.minorVersion << " build "
                                        << libraryVersion.buildNumber;
            if( libraryVersion.branchName != std::string( "master" ) )
                Catch::cout() << " (" << libraryVersion.branchName << " branch)";
            Catch::cout() << "\n";

            m_cli.usage( Catch::cout(), processName );
            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
        }

        int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
            try {
                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
                m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
                if( m_configData.showHelp )
                    showHelp( m_configData.processName );
                m_config.reset();
            }
            catch( std::exception& ex ) {
                {
                    Colour colourGuard( Colour::Red );
                    Catch::cerr()   << "\nError(s) in input:\n"
                                << Text( ex.what(), TextAttributes().setIndent(2) )
                                << "\n\n";
                }
                m_cli.usage( Catch::cout(), m_configData.processName );
                return (std::numeric_limits::max)();
            }
            return 0;
        }

        void useConfigData( ConfigData const& _configData ) {
            m_configData = _configData;
            m_config.reset();
        }

        int run( int argc, char* const argv[] ) {

            int returnCode = applyCommandLine( argc, argv );
            if( returnCode == 0 )
                returnCode = run();
            return returnCode;
        }

        int run() {
            if( m_configData.showHelp )
                return 0;

            try
            {
                config(); // Force config to be constructed

                std::srand( m_configData.rngSeed );

                Runner runner( m_config );

                // Handle list request
                if( Option listed = list( config() ) )
                    return static_cast( *listed );

                return static_cast( runner.runTests().assertions.failed );
            }
            catch( std::exception& ex ) {
                Catch::cerr() << ex.what() << std::endl;
                return (std::numeric_limits::max)();
            }
        }

        Clara::CommandLine const& cli() const {
            return m_cli;
        }
        std::vector const& unusedTokens() const {
            return m_unusedTokens;
        }
        ConfigData& configData() {
            return m_configData;
        }
        Config& config() {
            if( !m_config )
                m_config = new Config( m_configData );
            return *m_config;
        }

    private:
        Clara::CommandLine m_cli;
        std::vector m_unusedTokens;
        ConfigData m_configData;
        Ptr m_config;
    };

    bool Session::alreadyInstantiated = false;

} // end namespace Catch

// #included from: catch_registry_hub.hpp
#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED

// #included from: catch_test_case_registry_impl.hpp
#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED

#include 
#include 
#include 
#include 
#include 

namespace Catch {

    class TestRegistry : public ITestCaseRegistry {
        struct LexSort {
            bool operator() (TestCase i,TestCase j) const { return (i const& getAllTests() const {
            return m_functionsInOrder;
        }

        virtual std::vector const& getAllNonHiddenTests() const {
            return m_nonHiddenFunctions;
        }

        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector& matchingTestCases, bool negated = false ) const {

            for( std::vector::const_iterator  it = m_functionsInOrder.begin(),
                                                        itEnd = m_functionsInOrder.end();
                    it != itEnd;
                    ++it ) {
                bool includeTest = testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() );
                if( includeTest != negated )
                    matchingTestCases.push_back( *it );
            }
            sortTests( config, matchingTestCases );
        }

    private:

        static void sortTests( IConfig const& config, std::vector& matchingTestCases ) {

            switch( config.runOrder() ) {
                case RunTests::InLexicographicalOrder:
                    std::sort( matchingTestCases.begin(), matchingTestCases.end(), LexSort() );
                    break;
                case RunTests::InRandomOrder:
                {
                    RandomNumberGenerator rng;
                    std::random_shuffle( matchingTestCases.begin(), matchingTestCases.end(), rng );
                }
                    break;
                case RunTests::InDeclarationOrder:
                    // already in declaration order
                    break;
            }
        }
        std::set m_functions;
        std::vector m_functionsInOrder;
        std::vector m_nonHiddenFunctions;
        size_t m_unnamedCount;
    };

    ///////////////////////////////////////////////////////////////////////////

    class FreeFunctionTestCase : public SharedImpl {
    public:

        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}

        virtual void invoke() const {
            m_fun();
        }

    private:
        virtual ~FreeFunctionTestCase();

        TestFunction m_fun;
    };

    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
        std::string className = classOrQualifiedMethodName;
        if( startsWith( className, "&" ) )
        {
            std::size_t lastColons = className.rfind( "::" );
            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
            if( penultimateColons == std::string::npos )
                penultimateColons = 1;
            className = className.substr( penultimateColons, lastColons-penultimateColons );
        }
        return className;
    }

    ///////////////////////////////////////////////////////////////////////////

    AutoReg::AutoReg(   TestFunction function,
                        SourceLineInfo const& lineInfo,
                        NameAndDesc const& nameAndDesc ) {
        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
    }

    AutoReg::~AutoReg() {}

    void AutoReg::registerTestCase( ITestCase* testCase,
                                    char const* classOrQualifiedMethodName,
                                    NameAndDesc const& nameAndDesc,
                                    SourceLineInfo const& lineInfo ) {

        getMutableRegistryHub().registerTest
            ( makeTestCase( testCase,
                            extractClassName( classOrQualifiedMethodName ),
                            nameAndDesc.name,
                            nameAndDesc.description,
                            lineInfo ) );
    }

} // end namespace Catch

// #included from: catch_reporter_registry.hpp
#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED

#include 

namespace Catch {

    class ReporterRegistry : public IReporterRegistry {

    public:

        virtual ~ReporterRegistry() {
            deleteAllValues( m_factories );
        }

        virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const {
            FactoryMap::const_iterator it =  m_factories.find( name );
            if( it == m_factories.end() )
                return NULL;
            return it->second->create( ReporterConfig( config ) );
        }

        void registerReporter( std::string const& name, IReporterFactory* factory ) {
            m_factories.insert( std::make_pair( name, factory ) );
        }

        FactoryMap const& getFactories() const {
            return m_factories;
        }

    private:
        FactoryMap m_factories;
    };
}

// #included from: catch_exception_translator_registry.hpp
#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED

#ifdef __OBJC__
#import "Foundation/Foundation.h"
#endif

namespace Catch {

    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
    public:
        ~ExceptionTranslatorRegistry() {
            deleteAll( m_translators );
        }

        virtual void registerTranslator( const IExceptionTranslator* translator ) {
            m_translators.push_back( translator );
        }

        virtual std::string translateActiveException() const {
            try {
#ifdef __OBJC__
                // In Objective-C try objective-c exceptions first
                @try {
                    throw;
                }
                @catch (NSException *exception) {
                    return Catch::toString( [exception description] );
                }
#else
                throw;
#endif
            }
            catch( TestFailureException& ) {
                throw;
            }
            catch( std::exception& ex ) {
                return ex.what();
            }
            catch( std::string& msg ) {
                return msg;
            }
            catch( const char* msg ) {
                return msg;
            }
            catch(...) {
                return tryTranslators( m_translators.begin() );
            }
        }

        std::string tryTranslators( std::vector::const_iterator it ) const {
            if( it == m_translators.end() )
                return "Unknown exception";

            try {
                return (*it)->translate();
            }
            catch(...) {
                return tryTranslators( it+1 );
            }
        }

    private:
        std::vector m_translators;
    };
}

namespace Catch {

    namespace {

        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {

            RegistryHub( RegistryHub const& );
            void operator=( RegistryHub const& );

        public: // IRegistryHub
            RegistryHub() {
            }
            virtual IReporterRegistry const& getReporterRegistry() const {
                return m_reporterRegistry;
            }
            virtual ITestCaseRegistry const& getTestCaseRegistry() const {
                return m_testCaseRegistry;
            }
            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() {
                return m_exceptionTranslatorRegistry;
            }

        public: // IMutableRegistryHub
            virtual void registerReporter( std::string const& name, IReporterFactory* factory ) {
                m_reporterRegistry.registerReporter( name, factory );
            }
            virtual void registerTest( TestCase const& testInfo ) {
                m_testCaseRegistry.registerTest( testInfo );
            }
            virtual void registerTranslator( const IExceptionTranslator* translator ) {
                m_exceptionTranslatorRegistry.registerTranslator( translator );
            }

        private:
            TestRegistry m_testCaseRegistry;
            ReporterRegistry m_reporterRegistry;
            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
        };

        // Single, global, instance
        inline RegistryHub*& getTheRegistryHub() {
            static RegistryHub* theRegistryHub = NULL;
            if( !theRegistryHub )
                theRegistryHub = new RegistryHub();
            return theRegistryHub;
        }
    }

    IRegistryHub& getRegistryHub() {
        return *getTheRegistryHub();
    }
    IMutableRegistryHub& getMutableRegistryHub() {
        return *getTheRegistryHub();
    }
    void cleanUp() {
        delete getTheRegistryHub();
        getTheRegistryHub() = NULL;
        cleanUpContext();
    }
    std::string translateActiveException() {
        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
    }

} // end namespace Catch

// #included from: catch_notimplemented_exception.hpp
#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED

#include 

namespace Catch {

    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
    :   m_lineInfo( lineInfo ) {
        std::ostringstream oss;
        oss << lineInfo << ": function ";
        oss << "not implemented";
        m_what = oss.str();
    }

    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
        return m_what.c_str();
    }

} // end namespace Catch

// #included from: catch_context_impl.hpp
#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED

// #included from: catch_stream.hpp
#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED

// #included from: catch_streambuf.h
#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED

#include 

namespace Catch {

    class StreamBufBase : public std::streambuf {
    public:
        virtual ~StreamBufBase() CATCH_NOEXCEPT;
    };
}

#include 
#include 
#include 

namespace Catch {

    template
    class StreamBufImpl : public StreamBufBase {
        char data[bufferSize];
        WriterF m_writer;

    public:
        StreamBufImpl() {
            setp( data, data + sizeof(data) );
        }

        ~StreamBufImpl() CATCH_NOEXCEPT {
            sync();
        }

    private:
        int overflow( int c ) {
            sync();

            if( c != EOF ) {
                if( pbase() == epptr() )
                    m_writer( std::string( 1, static_cast( c ) ) );
                else
                    sputc( static_cast( c ) );
            }
            return 0;
        }

        int sync() {
            if( pbase() != pptr() ) {
                m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) );
                setp( pbase(), epptr() );
            }
            return 0;
        }
    };

    ///////////////////////////////////////////////////////////////////////////

    struct OutputDebugWriter {

        void operator()( std::string const&str ) {
            writeToDebugConsole( str );
        }
    };

    Stream::Stream()
    : streamBuf( NULL ), isOwned( false )
    {}

    Stream::Stream( std::streambuf* _streamBuf, bool _isOwned )
    : streamBuf( _streamBuf ), isOwned( _isOwned )
    {}

    void Stream::release() {
        if( isOwned ) {
            delete streamBuf;
            streamBuf = NULL;
            isOwned = false;
        }
    }

#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement this functions
    std::ostream& cout() {
        return std::cout;
    }
    std::ostream& cerr() {
        return std::cerr;
    }
#endif
}

namespace Catch {

    class Context : public IMutableContext {

        Context() : m_config( NULL ), m_runner( NULL ), m_resultCapture( NULL ) {}
        Context( Context const& );
        void operator=( Context const& );

    public: // IContext
        virtual IResultCapture* getResultCapture() {
            return m_resultCapture;
        }
        virtual IRunner* getRunner() {
            return m_runner;
        }
        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
            return getGeneratorsForCurrentTest()
            .getGeneratorInfo( fileInfo, totalSize )
            .getCurrentIndex();
        }
        virtual bool advanceGeneratorsForCurrentTest() {
            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
            return generators && generators->moveNext();
        }

        virtual Ptr getConfig() const {
            return m_config;
        }

    public: // IMutableContext
        virtual void setResultCapture( IResultCapture* resultCapture ) {
            m_resultCapture = resultCapture;
        }
        virtual void setRunner( IRunner* runner ) {
            m_runner = runner;
        }
        virtual void setConfig( Ptr const& config ) {
            m_config = config;
        }

        friend IMutableContext& getCurrentMutableContext();

    private:
        IGeneratorsForTest* findGeneratorsForCurrentTest() {
            std::string testName = getResultCapture()->getCurrentTestName();

            std::map::const_iterator it =
                m_generatorsByTestName.find( testName );
            return it != m_generatorsByTestName.end()
                ? it->second
                : NULL;
        }

        IGeneratorsForTest& getGeneratorsForCurrentTest() {
            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
            if( !generators ) {
                std::string testName = getResultCapture()->getCurrentTestName();
                generators = createGeneratorsForTest();
                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
            }
            return *generators;
        }

    private:
        Ptr m_config;
        IRunner* m_runner;
        IResultCapture* m_resultCapture;
        std::map m_generatorsByTestName;
    };

    namespace {
        Context* currentContext = NULL;
    }
    IMutableContext& getCurrentMutableContext() {
        if( !currentContext )
            currentContext = new Context();
        return *currentContext;
    }
    IContext& getCurrentContext() {
        return getCurrentMutableContext();
    }

    Stream createStream( std::string const& streamName ) {
        if( streamName == "stdout" ) return Stream( Catch::cout().rdbuf(), false );
        if( streamName == "stderr" ) return Stream( Catch::cerr().rdbuf(), false );
        if( streamName == "debug" ) return Stream( new StreamBufImpl, true );

        throw std::domain_error( "Unknown stream: " + streamName );
    }

    void cleanUpContext() {
        delete currentContext;
        currentContext = NULL;
    }
}

// #included from: catch_console_colour_impl.hpp
#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED

namespace Catch {
    namespace {

        struct IColourImpl {
            virtual ~IColourImpl() {}
            virtual void use( Colour::Code _colourCode ) = 0;
        };

        struct NoColourImpl : IColourImpl {
            void use( Colour::Code ) {}

            static IColourImpl* instance() {
                static NoColourImpl s_instance;
                return &s_instance;
            }
        };

    } // anon namespace
} // namespace Catch

#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
#   ifdef CATCH_PLATFORM_WINDOWS
#       define CATCH_CONFIG_COLOUR_WINDOWS
#   else
#       define CATCH_CONFIG_COLOUR_ANSI
#   endif
#endif

#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////

#ifndef NOMINMAX
#define NOMINMAX
#endif

#ifdef __AFXDLL
#include 
#else
#include 
#endif

namespace Catch {
namespace {

    class Win32ColourImpl : public IColourImpl {
    public:
        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
        {
            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
            originalAttributes = csbiInfo.wAttributes;
        }

        virtual void use( Colour::Code _colourCode ) {
            switch( _colourCode ) {
                case Colour::None:      return setTextAttribute( originalAttributes );
                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
                case Colour::Grey:      return setTextAttribute( 0 );

                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );

                case Colour::Bright: throw std::logic_error( "not a colour" );
            }
        }

    private:
        void setTextAttribute( WORD _textAttribute ) {
            SetConsoleTextAttribute( stdoutHandle, _textAttribute );
        }
        HANDLE stdoutHandle;
        WORD originalAttributes;
    };

    IColourImpl* platformColourInstance() {
        static Win32ColourImpl s_instance;
        return &s_instance;
    }

} // end anon namespace
} // end namespace Catch

#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////

#include 

namespace Catch {
namespace {

    // use POSIX/ ANSI console terminal codes
    // Thanks to Adam Strzelecki for original contribution
    // (http://github.com/nanoant)
    // https://github.com/philsquared/Catch/pull/131
    class PosixColourImpl : public IColourImpl {
    public:
        virtual void use( Colour::Code _colourCode ) {
            switch( _colourCode ) {
                case Colour::None:
                case Colour::White:     return setColour( "[0m" );
                case Colour::Red:       return setColour( "[0;31m" );
                case Colour::Green:     return setColour( "[0;32m" );
                case Colour::Blue:      return setColour( "[0:34m" );
                case Colour::Cyan:      return setColour( "[0;36m" );
                case Colour::Yellow:    return setColour( "[0;33m" );
                case Colour::Grey:      return setColour( "[1;30m" );

                case Colour::LightGrey:     return setColour( "[0;37m" );
                case Colour::BrightRed:     return setColour( "[1;31m" );
                case Colour::BrightGreen:   return setColour( "[1;32m" );
                case Colour::BrightWhite:   return setColour( "[1;37m" );

                case Colour::Bright: throw std::logic_error( "not a colour" );
            }
        }
        static IColourImpl* instance() {
            static PosixColourImpl s_instance;
            return &s_instance;
        }

    private:
        void setColour( const char* _escapeCode ) {
            Catch::cout() << '\033' << _escapeCode;
        }
    };

    IColourImpl* platformColourInstance() {
        Ptr config = getCurrentContext().getConfig();
        return (config && config->forceColour()) || isatty(STDOUT_FILENO)
            ? PosixColourImpl::instance()
            : NoColourImpl::instance();
    }

} // end anon namespace
} // end namespace Catch

#else  // not Windows or ANSI ///////////////////////////////////////////////

namespace Catch {

    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }

} // end namespace Catch

#endif // Windows/ ANSI/ None

namespace Catch {

    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast( _other ).m_moved = true; }
    Colour::~Colour(){ if( !m_moved ) use( None ); }

    void Colour::use( Code _colourCode ) {
        static IColourImpl* impl = isDebuggerActive()
            ? NoColourImpl::instance()
            : platformColourInstance();
        impl->use( _colourCode );
    }

} // end namespace Catch

// #included from: catch_generators_impl.hpp
#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED

#include 
#include 
#include 

namespace Catch {

    struct GeneratorInfo : IGeneratorInfo {

        GeneratorInfo( std::size_t size )
        :   m_size( size ),
            m_currentIndex( 0 )
        {}

        bool moveNext() {
            if( ++m_currentIndex == m_size ) {
                m_currentIndex = 0;
                return false;
            }
            return true;
        }

        std::size_t getCurrentIndex() const {
            return m_currentIndex;
        }

        std::size_t m_size;
        std::size_t m_currentIndex;
    };

    ///////////////////////////////////////////////////////////////////////////

    class GeneratorsForTest : public IGeneratorsForTest {

    public:
        ~GeneratorsForTest() {
            deleteAll( m_generatorsInOrder );
        }

        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
            std::map::const_iterator it = m_generatorsByName.find( fileInfo );
            if( it == m_generatorsByName.end() ) {
                IGeneratorInfo* info = new GeneratorInfo( size );
                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
                m_generatorsInOrder.push_back( info );
                return *info;
            }
            return *it->second;
        }

        bool moveNext() {
            std::vector::const_iterator it = m_generatorsInOrder.begin();
            std::vector::const_iterator itEnd = m_generatorsInOrder.end();
            for(; it != itEnd; ++it ) {
                if( (*it)->moveNext() )
                    return true;
            }
            return false;
        }

    private:
        std::map m_generatorsByName;
        std::vector m_generatorsInOrder;
    };

    IGeneratorsForTest* createGeneratorsForTest()
    {
        return new GeneratorsForTest();
    }

} // end namespace Catch

// #included from: catch_assertionresult.hpp
#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED

namespace Catch {

    AssertionInfo::AssertionInfo(   std::string const& _macroName,
                                    SourceLineInfo const& _lineInfo,
                                    std::string const& _capturedExpression,
                                    ResultDisposition::Flags _resultDisposition )
    :   macroName( _macroName ),
        lineInfo( _lineInfo ),
        capturedExpression( _capturedExpression ),
        resultDisposition( _resultDisposition )
    {}

    AssertionResult::AssertionResult() {}

    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
    :   m_info( info ),
        m_resultData( data )
    {}

    AssertionResult::~AssertionResult() {}

    // Result was a success
    bool AssertionResult::succeeded() const {
        return Catch::isOk( m_resultData.resultType );
    }

    // Result was a success, or failure is suppressed
    bool AssertionResult::isOk() const {
        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
    }

    ResultWas::OfType AssertionResult::getResultType() const {
        return m_resultData.resultType;
    }

    bool AssertionResult::hasExpression() const {
        return !m_info.capturedExpression.empty();
    }

    bool AssertionResult::hasMessage() const {
        return !m_resultData.message.empty();
    }

    std::string AssertionResult::getExpression() const {
        if( isFalseTest( m_info.resultDisposition ) )
            return "!" + m_info.capturedExpression;
        else
            return m_info.capturedExpression;
    }
    std::string AssertionResult::getExpressionInMacro() const {
        if( m_info.macroName.empty() )
            return m_info.capturedExpression;
        else
            return m_info.macroName + "( " + m_info.capturedExpression + " )";
    }

    bool AssertionResult::hasExpandedExpression() const {
        return hasExpression() && getExpandedExpression() != getExpression();
    }

    std::string AssertionResult::getExpandedExpression() const {
        return m_resultData.reconstructedExpression;
    }

    std::string AssertionResult::getMessage() const {
        return m_resultData.message;
    }
    SourceLineInfo AssertionResult::getSourceInfo() const {
        return m_info.lineInfo;
    }

    std::string AssertionResult::getTestMacroName() const {
        return m_info.macroName;
    }

} // end namespace Catch

// #included from: catch_test_case_info.hpp
#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED

namespace Catch {

    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
        if( startsWith( tag, "." ) ||
            tag == "hide" ||
            tag == "!hide" )
            return TestCaseInfo::IsHidden;
        else if( tag == "!throws" )
            return TestCaseInfo::Throws;
        else if( tag == "!shouldfail" )
            return TestCaseInfo::ShouldFail;
        else if( tag == "!mayfail" )
            return TestCaseInfo::MayFail;
        else
            return TestCaseInfo::None;
    }
    inline bool isReservedTag( std::string const& tag ) {
        return TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] );
    }
    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
        if( isReservedTag( tag ) ) {
            {
                Colour colourGuard( Colour::Red );
                Catch::cerr()
                    << "Tag name [" << tag << "] not allowed.\n"
                    << "Tag names starting with non alpha-numeric characters are reserved\n";
            }
            {
                Colour colourGuard( Colour::FileName );
                Catch::cerr() << _lineInfo << std::endl;
            }
            exit(1);
        }
    }

    TestCase makeTestCase(  ITestCase* _testCase,
                            std::string const& _className,
                            std::string const& _name,
                            std::string const& _descOrTags,
                            SourceLineInfo const& _lineInfo )
    {
        bool isHidden( startsWith( _name, "./" ) ); // Legacy support

        // Parse out tags
        std::set tags;
        std::string desc, tag;
        bool inTag = false;
        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
            char c = _descOrTags[i];
            if( !inTag ) {
                if( c == '[' )
                    inTag = true;
                else
                    desc += c;
            }
            else {
                if( c == ']' ) {
                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
                    if( prop == TestCaseInfo::IsHidden )
                        isHidden = true;
                    else if( prop == TestCaseInfo::None )
                        enforceNotReservedTag( tag, _lineInfo );

                    tags.insert( tag );
                    tag.clear();
                    inTag = false;
                }
                else
                    tag += c;
            }
        }
        if( isHidden ) {
            tags.insert( "hide" );
            tags.insert( "." );
        }

        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
        return TestCase( _testCase, info );
    }

    TestCaseInfo::TestCaseInfo( std::string const& _name,
                                std::string const& _className,
                                std::string const& _description,
                                std::set const& _tags,
                                SourceLineInfo const& _lineInfo )
    :   name( _name ),
        className( _className ),
        description( _description ),
        tags( _tags ),
        lineInfo( _lineInfo ),
        properties( None )
    {
        std::ostringstream oss;
        for( std::set::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it ) {
            oss << "[" << *it << "]";
            std::string lcaseTag = toLower( *it );
            properties = static_cast( properties | parseSpecialTag( lcaseTag ) );
            lcaseTags.insert( lcaseTag );
        }
        tagsAsString = oss.str();
    }

    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
    :   name( other.name ),
        className( other.className ),
        description( other.description ),
        tags( other.tags ),
        lcaseTags( other.lcaseTags ),
        tagsAsString( other.tagsAsString ),
        lineInfo( other.lineInfo ),
        properties( other.properties )
    {}

    bool TestCaseInfo::isHidden() const {
        return ( properties & IsHidden ) != 0;
    }
    bool TestCaseInfo::throws() const {
        return ( properties & Throws ) != 0;
    }
    bool TestCaseInfo::okToFail() const {
        return ( properties & (ShouldFail | MayFail ) ) != 0;
    }
    bool TestCaseInfo::expectedToFail() const {
        return ( properties & (ShouldFail ) ) != 0;
    }

    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}

    TestCase::TestCase( TestCase const& other )
    :   TestCaseInfo( other ),
        test( other.test )
    {}

    TestCase TestCase::withName( std::string const& _newName ) const {
        TestCase other( *this );
        other.name = _newName;
        return other;
    }

    void TestCase::swap( TestCase& other ) {
        test.swap( other.test );
        name.swap( other.name );
        className.swap( other.className );
        description.swap( other.description );
        tags.swap( other.tags );
        lcaseTags.swap( other.lcaseTags );
        tagsAsString.swap( other.tagsAsString );
        std::swap( TestCaseInfo::properties, static_cast( other ).properties );
        std::swap( lineInfo, other.lineInfo );
    }

    void TestCase::invoke() const {
        test->invoke();
    }

    bool TestCase::operator == ( TestCase const& other ) const {
        return  test.get() == other.test.get() &&
                name == other.name &&
                className == other.className;
    }

    bool TestCase::operator < ( TestCase const& other ) const {
        return name < other.name;
    }
    TestCase& TestCase::operator = ( TestCase const& other ) {
        TestCase temp( other );
        swap( temp );
        return *this;
    }

    TestCaseInfo const& TestCase::getTestCaseInfo() const
    {
        return *this;
    }

} // end namespace Catch

// #included from: catch_version.hpp
#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED

namespace Catch {

    // These numbers are maintained by a script
    Version libraryVersion( 1, 1, 14, "develop" );
}

// #included from: catch_message.hpp
#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED

namespace Catch {

    MessageInfo::MessageInfo(   std::string const& _macroName,
                                SourceLineInfo const& _lineInfo,
                                ResultWas::OfType _type )
    :   macroName( _macroName ),
        lineInfo( _lineInfo ),
        type( _type ),
        sequence( ++globalCount )
    {}

    // This may need protecting if threading support is added
    unsigned int MessageInfo::globalCount = 0;

    ////////////////////////////////////////////////////////////////////////////

    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
    : m_info( builder.m_info )
    {
        m_info.message = builder.m_stream.str();
        getResultCapture().pushScopedMessage( m_info );
    }
    ScopedMessage::ScopedMessage( ScopedMessage const& other )
    : m_info( other.m_info )
    {}

    ScopedMessage::~ScopedMessage() {
        getResultCapture().popScopedMessage( m_info );
    }

} // end namespace Catch

// #included from: catch_legacy_reporter_adapter.hpp
#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED

// #included from: catch_legacy_reporter_adapter.h
#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED

namespace Catch
{
    // Deprecated
    struct IReporter : IShared {
        virtual ~IReporter();

        virtual bool shouldRedirectStdout() const = 0;

        virtual void StartTesting() = 0;
        virtual void EndTesting( Totals const& totals ) = 0;
        virtual void StartGroup( std::string const& groupName ) = 0;
        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
        virtual void Aborted() = 0;
        virtual void Result( AssertionResult const& result ) = 0;
    };

    class LegacyReporterAdapter : public SharedImpl
    {
    public:
        LegacyReporterAdapter( Ptr const& legacyReporter );
        virtual ~LegacyReporterAdapter();

        virtual ReporterPreferences getPreferences() const;
        virtual void noMatchingTestCases( std::string const& );
        virtual void testRunStarting( TestRunInfo const& );
        virtual void testGroupStarting( GroupInfo const& groupInfo );
        virtual void testCaseStarting( TestCaseInfo const& testInfo );
        virtual void sectionStarting( SectionInfo const& sectionInfo );
        virtual void assertionStarting( AssertionInfo const& );
        virtual bool assertionEnded( AssertionStats const& assertionStats );
        virtual void sectionEnded( SectionStats const& sectionStats );
        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
        virtual void testRunEnded( TestRunStats const& testRunStats );
        virtual void skipTest( TestCaseInfo const& );

    private:
        Ptr m_legacyReporter;
    };
}

namespace Catch
{
    LegacyReporterAdapter::LegacyReporterAdapter( Ptr const& legacyReporter )
    :   m_legacyReporter( legacyReporter )
    {}
    LegacyReporterAdapter::~LegacyReporterAdapter() {}

    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
        ReporterPreferences prefs;
        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
        return prefs;
    }

    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
        m_legacyReporter->StartTesting();
    }
    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
        m_legacyReporter->StartGroup( groupInfo.name );
    }
    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
        m_legacyReporter->StartTestCase( testInfo );
    }
    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
    }
    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
        // Not on legacy interface
    }

    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
            for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
                    it != itEnd;
                    ++it ) {
                if( it->type == ResultWas::Info ) {
                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
                    rb << it->message;
                    rb.setResultType( ResultWas::Info );
                    AssertionResult result = rb.build();
                    m_legacyReporter->Result( result );
                }
            }
        }
        m_legacyReporter->Result( assertionStats.assertionResult );
        return true;
    }
    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
        if( sectionStats.missingAssertions )
            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
    }
    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
        m_legacyReporter->EndTestCase
            (   testCaseStats.testInfo,
                testCaseStats.totals,
                testCaseStats.stdOut,
                testCaseStats.stdErr );
    }
    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
        if( testGroupStats.aborting )
            m_legacyReporter->Aborted();
        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
    }
    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
        m_legacyReporter->EndTesting( testRunStats.totals );
    }
    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
    }
}

// #included from: catch_timer.hpp

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc++11-long-long"
#endif

#ifdef CATCH_PLATFORM_WINDOWS
#include 
#else
#include 
#endif

namespace Catch {

    namespace {
#ifdef CATCH_PLATFORM_WINDOWS
        uint64_t getCurrentTicks() {
            static uint64_t hz=0, hzo=0;
            if (!hz) {
                QueryPerformanceFrequency((LARGE_INTEGER*)&hz);
                QueryPerformanceCounter((LARGE_INTEGER*)&hzo);
            }
            uint64_t t;
            QueryPerformanceCounter((LARGE_INTEGER*)&t);
            return ((t-hzo)*1000000)/hz;
        }
#else
        uint64_t getCurrentTicks() {
            timeval t;
            gettimeofday(&t,NULL);
            return static_cast( t.tv_sec ) * 1000000ull + static_cast( t.tv_usec );
        }
#endif
    }

    void Timer::start() {
        m_ticks = getCurrentTicks();
    }
    unsigned int Timer::getElapsedMicroseconds() const {
        return static_cast(getCurrentTicks() - m_ticks);
    }
    unsigned int Timer::getElapsedMilliseconds() const {
        return static_cast(getElapsedMicroseconds()/1000);
    }
    double Timer::getElapsedSeconds() const {
        return getElapsedMicroseconds()/1000000.0;
    }

} // namespace Catch

#ifdef __clang__
#pragma clang diagnostic pop
#endif
// #included from: catch_common.hpp
#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED

namespace Catch {

    bool startsWith( std::string const& s, std::string const& prefix ) {
        return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
    }
    bool endsWith( std::string const& s, std::string const& suffix ) {
        return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix;
    }
    bool contains( std::string const& s, std::string const& infix ) {
        return s.find( infix ) != std::string::npos;
    }
    void toLowerInPlace( std::string& s ) {
        std::transform( s.begin(), s.end(), s.begin(), ::tolower );
    }
    std::string toLower( std::string const& s ) {
        std::string lc = s;
        toLowerInPlace( lc );
        return lc;
    }
    std::string trim( std::string const& str ) {
        static char const* whitespaceChars = "\n\r\t ";
        std::string::size_type start = str.find_first_not_of( whitespaceChars );
        std::string::size_type end = str.find_last_not_of( whitespaceChars );

        return start != std::string::npos ? str.substr( start, 1+end-start ) : "";
    }

    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
        bool replaced = false;
        std::size_t i = str.find( replaceThis );
        while( i != std::string::npos ) {
            replaced = true;
            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
            if( i < str.size()-withThis.size() )
                i = str.find( replaceThis, i+withThis.size() );
            else
                i = std::string::npos;
        }
        return replaced;
    }

    pluralise::pluralise( std::size_t count, std::string const& label )
    :   m_count( count ),
        m_label( label )
    {}

    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
        os << pluraliser.m_count << " " << pluraliser.m_label;
        if( pluraliser.m_count != 1 )
            os << "s";
        return os;
    }

    SourceLineInfo::SourceLineInfo() : line( 0 ){}
    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
    :   file( _file ),
        line( _line )
    {}
    SourceLineInfo::SourceLineInfo( SourceLineInfo const& other )
    :   file( other.file ),
        line( other.line )
    {}
    bool SourceLineInfo::empty() const {
        return file.empty();
    }
    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
        return line == other.line && file == other.file;
    }
    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const {
        return line < other.line || ( line == other.line  && file < other.file );
    }

    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
        os << info.file << "(" << info.line << ")";
#else
        os << info.file << ":" << info.line;
#endif
        return os;
    }

    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
        std::ostringstream oss;
        oss << locationInfo << ": Internal Catch error: '" << message << "'";
        if( alwaysTrue() )
            throw std::logic_error( oss.str() );
    }
}

// #included from: catch_section.hpp
#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED

namespace Catch {

    SectionInfo::SectionInfo
        (   SourceLineInfo const& _lineInfo,
            std::string const& _name,
            std::string const& _description )
    :   name( _name ),
        description( _description ),
        lineInfo( _lineInfo )
    {}

    Section::Section( SectionInfo const& info )
    :   m_info( info ),
        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
    {
        m_timer.start();
    }

    Section::~Section() {
        if( m_sectionIncluded )
            getResultCapture().sectionEnded( m_info, m_assertions, m_timer.getElapsedSeconds() );
    }

    // This indicates whether the section should be executed or not
    Section::operator bool() const {
        return m_sectionIncluded;
    }

} // end namespace Catch

// #included from: catch_debugger.hpp
#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED

#include 

#ifdef CATCH_PLATFORM_MAC

    #include 
    #include 
    #include 
    #include 
    #include 

    namespace Catch{

        // The following function is taken directly from the following technical note:
        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html

        // Returns true if the current process is being debugged (either
        // running under the debugger or has a debugger attached post facto).
        bool isDebuggerActive(){

            int                 mib[4];
            struct kinfo_proc   info;
            size_t              size;

            // Initialize the flags so that, if sysctl fails for some bizarre
            // reason, we get a predictable result.

            info.kp_proc.p_flag = 0;

            // Initialize mib, which tells sysctl the info we want, in this case
            // we're looking for information about a specific process ID.

            mib[0] = CTL_KERN;
            mib[1] = KERN_PROC;
            mib[2] = KERN_PROC_PID;
            mib[3] = getpid();

            // Call sysctl.

            size = sizeof(info);
            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) {
                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
                return false;
            }

            // We're being debugged if the P_TRACED flag is set.

            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
        }
    } // namespace Catch

#elif defined(_MSC_VER)
    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
    namespace Catch {
        bool isDebuggerActive() {
            return IsDebuggerPresent() != 0;
        }
    }
#elif defined(__MINGW32__)
    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
    namespace Catch {
        bool isDebuggerActive() {
            return IsDebuggerPresent() != 0;
        }
    }
#else
    namespace Catch {
       inline bool isDebuggerActive() { return false; }
    }
#endif // Platform

#ifdef CATCH_PLATFORM_WINDOWS
    extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* );
    namespace Catch {
        void writeToDebugConsole( std::string const& text ) {
            ::OutputDebugStringA( text.c_str() );
        }
    }
#else
    namespace Catch {
        void writeToDebugConsole( std::string const& text ) {
            // !TBD: Need a version for Mac/ XCode and other IDEs
            Catch::cout() << text;
        }
    }
#endif // Platform

// #included from: catch_tostring.hpp
#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED

namespace Catch {

namespace Detail {

    std::string unprintableString = "{?}";

    namespace {
        struct Endianness {
            enum Arch { Big, Little };

            static Arch which() {
                union _{
                    int asInt;
                    char asChar[sizeof (int)];
                } u;

                u.asInt = 1;
                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
            }
        };
    }

    std::string rawMemoryToString( const void *object, std::size_t size )
    {
        // Reverse order for little endian architectures
        int i = 0, end = static_cast( size ), inc = 1;
        if( Endianness::which() == Endianness::Little ) {
            i = end-1;
            end = inc = -1;
        }

        unsigned char const *bytes = static_cast(object);
        std::ostringstream os;
        os << "0x" << std::setfill('0') << std::hex;
        for( ; i != end; i += inc )
             os << std::setw(2) << static_cast(bytes[i]);
       return os.str();
    }
}

std::string toString( std::string const& value ) {
    std::string s = value;
    if( getCurrentContext().getConfig()->showInvisibles() ) {
        for(size_t i = 0; i < s.size(); ++i ) {
            std::string subs;
            switch( s[i] ) {
            case '\n': subs = "\\n"; break;
            case '\t': subs = "\\t"; break;
            default: break;
            }
            if( !subs.empty() ) {
                s = s.substr( 0, i ) + subs + s.substr( i+1 );
                ++i;
            }
        }
    }
    return "\"" + s + "\"";
}
std::string toString( std::wstring const& value ) {

    std::string s;
    s.reserve( value.size() );
    for(size_t i = 0; i < value.size(); ++i )
        s += value[i] <= 0xff ? static_cast( value[i] ) : '?';
    return Catch::toString( s );
}

std::string toString( const char* const value ) {
    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
}

std::string toString( char* const value ) {
    return Catch::toString( static_cast( value ) );
}

std::string toString( const wchar_t* const value )
{
	return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
}

std::string toString( wchar_t* const value )
{
	return Catch::toString( static_cast( value ) );
}

std::string toString( int value ) {
    std::ostringstream oss;
    if( value > 8192 )
        oss << "0x" << std::hex << value;
    else
        oss << value;
    return oss.str();
}

std::string toString( unsigned long value ) {
    std::ostringstream oss;
    if( value > 8192 )
        oss << "0x" << std::hex << value;
    else
        oss << value;
    return oss.str();
}

std::string toString( unsigned int value ) {
    return Catch::toString( static_cast( value ) );
}

template
std::string fpToString( T value, int precision ) {
    std::ostringstream oss;
    oss << std::setprecision( precision )
        << std::fixed
        << value;
    std::string d = oss.str();
    std::size_t i = d.find_last_not_of( '0' );
    if( i != std::string::npos && i != d.size()-1 ) {
        if( d[i] == '.' )
            i++;
        d = d.substr( 0, i+1 );
    }
    return d;
}

std::string toString( const double value ) {
    return fpToString( value, 10 );
}
std::string toString( const float value ) {
    return fpToString( value, 5 ) + "f";
}

std::string toString( bool value ) {
    return value ? "true" : "false";
}

std::string toString( char value ) {
    return value < ' '
        ? toString( static_cast( value ) )
        : Detail::makeString( value );
}

std::string toString( signed char value ) {
    return toString( static_cast( value ) );
}

std::string toString( unsigned char value ) {
    return toString( static_cast( value ) );
}

#ifdef CATCH_CONFIG_CPP11_NULLPTR
std::string toString( std::nullptr_t ) {
    return "nullptr";
}
#endif

#ifdef __OBJC__
    std::string toString( NSString const * const& nsstring ) {
        if( !nsstring )
            return "nil";
        return "@" + toString([nsstring UTF8String]);
    }
    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) {
        if( !nsstring )
            return "nil";
        return "@" + toString([nsstring UTF8String]);
    }
    std::string toString( NSObject* const& nsObject ) {
        return toString( [nsObject description] );
    }
#endif

} // end namespace Catch

// #included from: catch_result_builder.hpp
#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED

namespace Catch {

    ResultBuilder::ResultBuilder(   char const* macroName,
                                    SourceLineInfo const& lineInfo,
                                    char const* capturedExpression,
                                    ResultDisposition::Flags resultDisposition )
    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition ),
        m_shouldDebugBreak( false ),
        m_shouldThrow( false )
    {}

    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
        m_data.resultType = result;
        return *this;
    }
    ResultBuilder& ResultBuilder::setResultType( bool result ) {
        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
        return *this;
    }
    ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) {
        m_exprComponents.lhs = lhs;
        return *this;
    }
    ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) {
        m_exprComponents.rhs = rhs;
        return *this;
    }
    ResultBuilder& ResultBuilder::setOp( std::string const& op ) {
        m_exprComponents.op = op;
        return *this;
    }

    void ResultBuilder::endExpression() {
        m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition );
        captureExpression();
    }

    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
        m_assertionInfo.resultDisposition = resultDisposition;
        m_stream.oss << Catch::translateActiveException();
        captureResult( ResultWas::ThrewException );
    }

    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
        setResultType( resultType );
        captureExpression();
    }

    void ResultBuilder::captureExpression() {
        AssertionResult result = build();
        getResultCapture().assertionEnded( result );

        if( !result.isOk() ) {
            if( getCurrentContext().getConfig()->shouldDebugBreak() )
                m_shouldDebugBreak = true;
            if( getCurrentContext().getRunner()->aborting() || m_assertionInfo.resultDisposition == ResultDisposition::Normal )
                m_shouldThrow = true;
        }
    }
    void ResultBuilder::react() {
        if( m_shouldThrow )
            throw Catch::TestFailureException();
    }

    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }

    AssertionResult ResultBuilder::build() const
    {
        assert( m_data.resultType != ResultWas::Unknown );

        AssertionResultData data = m_data;

        // Flip bool results if testFalse is set
        if( m_exprComponents.testFalse ) {
            if( data.resultType == ResultWas::Ok )
                data.resultType = ResultWas::ExpressionFailed;
            else if( data.resultType == ResultWas::ExpressionFailed )
                data.resultType = ResultWas::Ok;
        }

        data.message = m_stream.oss.str();
        data.reconstructedExpression = reconstructExpression();
        if( m_exprComponents.testFalse ) {
            if( m_exprComponents.op == "" )
                data.reconstructedExpression = "!" + data.reconstructedExpression;
            else
                data.reconstructedExpression = "!(" + data.reconstructedExpression + ")";
        }
        return AssertionResult( m_assertionInfo, data );
    }
    std::string ResultBuilder::reconstructExpression() const {
        if( m_exprComponents.op == "" )
            return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs;
        else if( m_exprComponents.op == "matches" )
            return m_exprComponents.lhs + " " + m_exprComponents.rhs;
        else if( m_exprComponents.op != "!" ) {
            if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 &&
                m_exprComponents.lhs.find("\n") == std::string::npos &&
                m_exprComponents.rhs.find("\n") == std::string::npos )
                return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs;
            else
                return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs;
        }
        else
            return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}";
    }

} // end namespace Catch

// #included from: catch_tag_alias_registry.hpp
#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED

// #included from: catch_tag_alias_registry.h
#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED

#include 

namespace Catch {

    class TagAliasRegistry : public ITagAliasRegistry {
    public:
        virtual ~TagAliasRegistry();
        virtual Option find( std::string const& alias ) const;
        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
        void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
        static TagAliasRegistry& get();

    private:
        std::map m_registry;
    };

} // end namespace Catch

#include 
#include 

namespace Catch {

    TagAliasRegistry::~TagAliasRegistry() {}

    Option TagAliasRegistry::find( std::string const& alias ) const {
        std::map::const_iterator it = m_registry.find( alias );
        if( it != m_registry.end() )
            return it->second;
        else
            return Option();
    }

    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
        std::string expandedTestSpec = unexpandedTestSpec;
        for( std::map::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
                it != itEnd;
                ++it ) {
            std::size_t pos = expandedTestSpec.find( it->first );
            if( pos != std::string::npos ) {
                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
                                    it->second.tag +
                                    expandedTestSpec.substr( pos + it->first.size() );
            }
        }
        return expandedTestSpec;
    }

    void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {

        if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) {
            std::ostringstream oss;
            oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo;
            throw std::domain_error( oss.str().c_str() );
        }
        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
            std::ostringstream oss;
            oss << "error: tag alias, \"" << alias << "\" already registered.\n"
                << "\tFirst seen at " << find(alias)->lineInfo << "\n"
                << "\tRedefined at " << lineInfo;
            throw std::domain_error( oss.str().c_str() );
        }
    }

    TagAliasRegistry& TagAliasRegistry::get() {
        static TagAliasRegistry instance;
        return instance;

    }

    ITagAliasRegistry::~ITagAliasRegistry() {}
    ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); }

    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
        try {
            TagAliasRegistry::get().add( alias, tag, lineInfo );
        }
        catch( std::exception& ex ) {
            Colour colourGuard( Colour::Red );
            Catch::cerr() << ex.what() << std::endl;
            exit(1);
        }
    }

} // end namespace Catch

// #included from: ../reporters/catch_reporter_xml.hpp
#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED

// #included from: catch_reporter_bases.hpp
#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED

#include 

namespace Catch {

    struct StreamingReporterBase : SharedImpl {

        StreamingReporterBase( ReporterConfig const& _config )
        :   m_config( _config.fullConfig() ),
            stream( _config.stream() )
        {}

        virtual ~StreamingReporterBase();

        virtual void noMatchingTestCases( std::string const& ) {}

        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) {
            currentTestRunInfo = _testRunInfo;
        }
        virtual void testGroupStarting( GroupInfo const& _groupInfo ) {
            currentGroupInfo = _groupInfo;
        }

        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) {
            currentTestCaseInfo = _testInfo;
        }
        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
            m_sectionStack.push_back( _sectionInfo );
        }

        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) {
            m_sectionStack.pop_back();
        }
        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) {
            currentTestCaseInfo.reset();
        }
        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) {
            currentGroupInfo.reset();
        }
        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) {
            currentTestCaseInfo.reset();
            currentGroupInfo.reset();
            currentTestRunInfo.reset();
        }

        virtual void skipTest( TestCaseInfo const& ) {
            // Don't do anything with this by default.
            // It can optionally be overridden in the derived class.
        }

        Ptr m_config;
        std::ostream& stream;

        LazyStat currentTestRunInfo;
        LazyStat currentGroupInfo;
        LazyStat currentTestCaseInfo;

        std::vector m_sectionStack;
    };

    struct CumulativeReporterBase : SharedImpl {
        template
        struct Node : SharedImpl<> {
            explicit Node( T const& _value ) : value( _value ) {}
            virtual ~Node() {}

            typedef std::vector > ChildNodes;
            T value;
            ChildNodes children;
        };
        struct SectionNode : SharedImpl<> {
            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
            virtual ~SectionNode();

            bool operator == ( SectionNode const& other ) const {
                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
            }
            bool operator == ( Ptr const& other ) const {
                return operator==( *other );
            }

            SectionStats stats;
            typedef std::vector > ChildSections;
            typedef std::vector Assertions;
            ChildSections childSections;
            Assertions assertions;
            std::string stdOut;
            std::string stdErr;
        };

        struct BySectionInfo {
            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
			BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
            bool operator() ( Ptr const& node ) const {
                return node->stats.sectionInfo.lineInfo == m_other.lineInfo;
            }
        private:
			void operator=( BySectionInfo const& );
            SectionInfo const& m_other;
        };

        typedef Node TestCaseNode;
        typedef Node TestGroupNode;
        typedef Node TestRunNode;

        CumulativeReporterBase( ReporterConfig const& _config )
        :   m_config( _config.fullConfig() ),
            stream( _config.stream() )
        {}
        ~CumulativeReporterBase();

        virtual void testRunStarting( TestRunInfo const& ) {}
        virtual void testGroupStarting( GroupInfo const& ) {}

        virtual void testCaseStarting( TestCaseInfo const& ) {}

        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
            Ptr node;
            if( m_sectionStack.empty() ) {
                if( !m_rootSection )
                    m_rootSection = new SectionNode( incompleteStats );
                node = m_rootSection;
            }
            else {
                SectionNode& parentNode = *m_sectionStack.back();
                SectionNode::ChildSections::const_iterator it =
                    std::find_if(   parentNode.childSections.begin(),
                                    parentNode.childSections.end(),
                                    BySectionInfo( sectionInfo ) );
                if( it == parentNode.childSections.end() ) {
                    node = new SectionNode( incompleteStats );
                    parentNode.childSections.push_back( node );
                }
                else
                    node = *it;
            }
            m_sectionStack.push_back( node );
            m_deepestSection = node;
        }

        virtual void assertionStarting( AssertionInfo const& ) {}

        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
            assert( !m_sectionStack.empty() );
            SectionNode& sectionNode = *m_sectionStack.back();
            sectionNode.assertions.push_back( assertionStats );
            return true;
        }
        virtual void sectionEnded( SectionStats const& sectionStats ) {
            assert( !m_sectionStack.empty() );
            SectionNode& node = *m_sectionStack.back();
            node.stats = sectionStats;
            m_sectionStack.pop_back();
        }
        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
            Ptr node = new TestCaseNode( testCaseStats );
            assert( m_sectionStack.size() == 0 );
            node->children.push_back( m_rootSection );
            m_testCases.push_back( node );
            m_rootSection.reset();

            assert( m_deepestSection );
            m_deepestSection->stdOut = testCaseStats.stdOut;
            m_deepestSection->stdErr = testCaseStats.stdErr;
        }
        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
            Ptr node = new TestGroupNode( testGroupStats );
            node->children.swap( m_testCases );
            m_testGroups.push_back( node );
        }
        virtual void testRunEnded( TestRunStats const& testRunStats ) {
            Ptr node = new TestRunNode( testRunStats );
            node->children.swap( m_testGroups );
            m_testRuns.push_back( node );
            testRunEndedCumulative();
        }
        virtual void testRunEndedCumulative() = 0;

        virtual void skipTest( TestCaseInfo const& ) {}

        Ptr m_config;
        std::ostream& stream;
        std::vector m_assertions;
        std::vector > > m_sections;
        std::vector > m_testCases;
        std::vector > m_testGroups;

        std::vector > m_testRuns;

        Ptr m_rootSection;
        Ptr m_deepestSection;
        std::vector > m_sectionStack;

    };

    template
    char const* getLineOfChars() {
        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
        if( !*line ) {
            memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
        }
        return line;
    }

} // end namespace Catch

// #included from: ../internal/catch_reporter_registrars.hpp
#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED

namespace Catch {

    template
    class LegacyReporterRegistrar {

        class ReporterFactory : public IReporterFactory {
            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
                return new LegacyReporterAdapter( new T( config ) );
            }

            virtual std::string getDescription() const {
                return T::getDescription();
            }
        };

    public:

        LegacyReporterRegistrar( std::string const& name ) {
            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
        }
    };

    template
    class ReporterRegistrar {

        class ReporterFactory : public IReporterFactory {

            // *** Please Note ***:
            // - If you end up here looking at a compiler error because it's trying to register
            // your custom reporter class be aware that the native reporter interface has changed
            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
            // However please consider updating to the new interface as the old one is now
            // deprecated and will probably be removed quite soon!
            // Please contact me via github if you have any questions at all about this.
            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
            // no idea who is actually using custom reporters at all (possibly no-one!).
            // The new interface is designed to minimise exposure to interface changes in the future.
            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
                return new T( config );
            }

            virtual std::string getDescription() const {
                return T::getDescription();
            }
        };

    public:

        ReporterRegistrar( std::string const& name ) {
            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
        }
    };
}

#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
    namespace{ Catch::LegacyReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); }
#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
    namespace{ Catch::ReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); }

// #included from: ../internal/catch_xmlwriter.hpp
#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED

#include 
#include 
#include 

namespace Catch {

    class XmlWriter {
    public:

        class ScopedElement {
        public:
            ScopedElement( XmlWriter* writer )
            :   m_writer( writer )
            {}

            ScopedElement( ScopedElement const& other )
            :   m_writer( other.m_writer ){
                other.m_writer = NULL;
            }

            ~ScopedElement() {
                if( m_writer )
                    m_writer->endElement();
            }

            ScopedElement& writeText( std::string const& text, bool indent = true ) {
                m_writer->writeText( text, indent );
                return *this;
            }

            template
            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
                m_writer->writeAttribute( name, attribute );
                return *this;
            }

        private:
            mutable XmlWriter* m_writer;
        };

        XmlWriter()
        :   m_tagIsOpen( false ),
            m_needsNewline( false ),
            m_os( &Catch::cout() )
        {}

        XmlWriter( std::ostream& os )
        :   m_tagIsOpen( false ),
            m_needsNewline( false ),
            m_os( &os )
        {}

        ~XmlWriter() {
            while( !m_tags.empty() )
                endElement();
        }

//#  ifndef CATCH_CPP11_OR_GREATER
//        XmlWriter& operator = ( XmlWriter const& other ) {
//            XmlWriter temp( other );
//            swap( temp );
//            return *this;
//        }
//#  else
//        XmlWriter( XmlWriter const& )              = default;
//        XmlWriter( XmlWriter && )                  = default;
//        XmlWriter& operator = ( XmlWriter const& ) = default;
//        XmlWriter& operator = ( XmlWriter && )     = default;
//#  endif
//
//        void swap( XmlWriter& other ) {
//            std::swap( m_tagIsOpen, other.m_tagIsOpen );
//            std::swap( m_needsNewline, other.m_needsNewline );
//            std::swap( m_tags, other.m_tags );
//            std::swap( m_indent, other.m_indent );
//            std::swap( m_os, other.m_os );
//        }

        XmlWriter& startElement( std::string const& name ) {
            ensureTagClosed();
            newlineIfNecessary();
            stream() << m_indent << "<" << name;
            m_tags.push_back( name );
            m_indent += "  ";
            m_tagIsOpen = true;
            return *this;
        }

        ScopedElement scopedElement( std::string const& name ) {
            ScopedElement scoped( this );
            startElement( name );
            return scoped;
        }

        XmlWriter& endElement() {
            newlineIfNecessary();
            m_indent = m_indent.substr( 0, m_indent.size()-2 );
            if( m_tagIsOpen ) {
                stream() << "/>\n";
                m_tagIsOpen = false;
            }
            else {
                stream() << m_indent << "\n";
            }
            m_tags.pop_back();
            return *this;
        }

        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
            if( !name.empty() && !attribute.empty() ) {
                stream() << " " << name << "=\"";
                writeEncodedText( attribute );
                stream() << "\"";
            }
            return *this;
        }

        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
            stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
            return *this;
        }

        template
        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
            if( !name.empty() )
                stream() << " " << name << "=\"" << attribute << "\"";
            return *this;
        }

        XmlWriter& writeText( std::string const& text, bool indent = true ) {
            if( !text.empty() ){
                bool tagWasOpen = m_tagIsOpen;
                ensureTagClosed();
                if( tagWasOpen && indent )
                    stream() << m_indent;
                writeEncodedText( text );
                m_needsNewline = true;
            }
            return *this;
        }

        XmlWriter& writeComment( std::string const& text ) {
            ensureTagClosed();
            stream() << m_indent << "";
            m_needsNewline = true;
            return *this;
        }

        XmlWriter& writeBlankLine() {
            ensureTagClosed();
            stream() << "\n";
            return *this;
        }

        void setStream( std::ostream& os ) {
            m_os = &os;
        }

    private:
        XmlWriter( XmlWriter const& );
        void operator=( XmlWriter const& );

        std::ostream& stream() {
            return *m_os;
        }

        void ensureTagClosed() {
            if( m_tagIsOpen ) {
                stream() << ">\n";
                m_tagIsOpen = false;
            }
        }

        void newlineIfNecessary() {
            if( m_needsNewline ) {
                stream() << "\n";
                m_needsNewline = false;
            }
        }

        void writeEncodedText( std::string const& text ) {
            static const char* charsToEncode = "<&\"";
            std::string mtext = text;
            std::string::size_type pos = mtext.find_first_of( charsToEncode );
            while( pos != std::string::npos ) {
                stream() << mtext.substr( 0, pos );

                switch( mtext[pos] ) {
                    case '<':
                        stream() << "<";
                        break;
                    case '&':
                        stream() << "&";
                        break;
                    case '\"':
                        stream() << """;
                        break;
                }
                mtext = mtext.substr( pos+1 );
                pos = mtext.find_first_of( charsToEncode );
            }
            stream() << mtext;
        }

        bool m_tagIsOpen;
        bool m_needsNewline;
        std::vector m_tags;
        std::string m_indent;
        std::ostream* m_os;
    };

}
namespace Catch {
    class XmlReporter : public StreamingReporterBase {
    public:
        XmlReporter( ReporterConfig const& _config )
        :   StreamingReporterBase( _config ),
            m_sectionDepth( 0 )
        {}

        virtual ~XmlReporter();

        static std::string getDescription() {
            return "Reports test results as an XML document";
        }

    public: // StreamingReporterBase
        virtual ReporterPreferences getPreferences() const {
            ReporterPreferences prefs;
            prefs.shouldRedirectStdOut = true;
            return prefs;
        }

        virtual void noMatchingTestCases( std::string const& s ) {
            StreamingReporterBase::noMatchingTestCases( s );
        }

        virtual void testRunStarting( TestRunInfo const& testInfo ) {
            StreamingReporterBase::testRunStarting( testInfo );
            m_xml.setStream( stream );
            m_xml.startElement( "Catch" );
            if( !m_config->name().empty() )
                m_xml.writeAttribute( "name", m_config->name() );
        }

        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
            StreamingReporterBase::testGroupStarting( groupInfo );
            m_xml.startElement( "Group" )
                .writeAttribute( "name", groupInfo.name );
        }

        virtual void testCaseStarting( TestCaseInfo const& testInfo ) {
            StreamingReporterBase::testCaseStarting(testInfo);
            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );

            if ( m_config->showDurations() == ShowDurations::Always )
                m_testCaseTimer.start();
        }

        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
            StreamingReporterBase::sectionStarting( sectionInfo );
            if( m_sectionDepth++ > 0 ) {
                m_xml.startElement( "Section" )
                    .writeAttribute( "name", trim( sectionInfo.name ) )
                    .writeAttribute( "description", sectionInfo.description );
            }
        }

        virtual void assertionStarting( AssertionInfo const& ) { }

        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
            const AssertionResult& assertionResult = assertionStats.assertionResult;

            // Print any info messages in  tags.
            if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
                for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
                        it != itEnd;
                        ++it ) {
                    if( it->type == ResultWas::Info ) {
                        m_xml.scopedElement( "Info" )
                            .writeText( it->message );
                    } else if ( it->type == ResultWas::Warning ) {
                        m_xml.scopedElement( "Warning" )
                            .writeText( it->message );
                    }
                }
            }

            // Drop out if result was successful but we're not printing them.
            if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) )
                return true;

            // Print the expression if there is one.
            if( assertionResult.hasExpression() ) {
                m_xml.startElement( "Expression" )
                    .writeAttribute( "success", assertionResult.succeeded() )
					.writeAttribute( "type", assertionResult.getTestMacroName() )
                    .writeAttribute( "filename", assertionResult.getSourceInfo().file )
                    .writeAttribute( "line", assertionResult.getSourceInfo().line );

                m_xml.scopedElement( "Original" )
                    .writeText( assertionResult.getExpression() );
                m_xml.scopedElement( "Expanded" )
                    .writeText( assertionResult.getExpandedExpression() );
            }

            // And... Print a result applicable to each result type.
            switch( assertionResult.getResultType() ) {
                case ResultWas::ThrewException:
                    m_xml.scopedElement( "Exception" )
                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
                        .writeText( assertionResult.getMessage() );
                    break;
                case ResultWas::FatalErrorCondition:
                    m_xml.scopedElement( "Fatal Error Condition" )
                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
                        .writeText( assertionResult.getMessage() );
                    break;
                case ResultWas::Info:
                    m_xml.scopedElement( "Info" )
                        .writeText( assertionResult.getMessage() );
                    break;
                case ResultWas::Warning:
                    // Warning will already have been written
                    break;
                case ResultWas::ExplicitFailure:
                    m_xml.scopedElement( "Failure" )
                        .writeText( assertionResult.getMessage() );
                    break;
                default:
                    break;
            }

            if( assertionResult.hasExpression() )
                m_xml.endElement();

            return true;
        }

        virtual void sectionEnded( SectionStats const& sectionStats ) {
            StreamingReporterBase::sectionEnded( sectionStats );
            if( --m_sectionDepth > 0 ) {
                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
                e.writeAttribute( "successes", sectionStats.assertions.passed );
                e.writeAttribute( "failures", sectionStats.assertions.failed );
                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );

                if ( m_config->showDurations() == ShowDurations::Always )
                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );

                m_xml.endElement();
            }
        }

        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
            StreamingReporterBase::testCaseEnded( testCaseStats );
            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );

            if ( m_config->showDurations() == ShowDurations::Always )
                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );

            m_xml.endElement();
        }

        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
            StreamingReporterBase::testGroupEnded( testGroupStats );
            // TODO: Check testGroupStats.aborting and act accordingly.
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
            m_xml.endElement();
        }

        virtual void testRunEnded( TestRunStats const& testRunStats ) {
            StreamingReporterBase::testRunEnded( testRunStats );
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
            m_xml.endElement();
        }

    private:
        Timer m_testCaseTimer;
        XmlWriter m_xml;
        int m_sectionDepth;
    };

     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )

} // end namespace Catch

// #included from: ../reporters/catch_reporter_junit.hpp
#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED

#include 

namespace Catch {

    class JunitReporter : public CumulativeReporterBase {
    public:
        JunitReporter( ReporterConfig const& _config )
        :   CumulativeReporterBase( _config ),
            xml( _config.stream() )
        {}

        ~JunitReporter();

        static std::string getDescription() {
            return "Reports test results in an XML format that looks like Ant's junitreport target";
        }

        virtual void noMatchingTestCases( std::string const& /*spec*/ ) {}

        virtual ReporterPreferences getPreferences() const {
            ReporterPreferences prefs;
            prefs.shouldRedirectStdOut = true;
            return prefs;
        }

        virtual void testRunStarting( TestRunInfo const& runInfo ) {
            CumulativeReporterBase::testRunStarting( runInfo );
            xml.startElement( "testsuites" );
        }

        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
            suiteTimer.start();
            stdOutForSuite.str("");
            stdErrForSuite.str("");
            unexpectedExceptions = 0;
            CumulativeReporterBase::testGroupStarting( groupInfo );
        }

        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException )
                unexpectedExceptions++;
            return CumulativeReporterBase::assertionEnded( assertionStats );
        }

        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
            stdOutForSuite << testCaseStats.stdOut;
            stdErrForSuite << testCaseStats.stdErr;
            CumulativeReporterBase::testCaseEnded( testCaseStats );
        }

        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
            double suiteTime = suiteTimer.getElapsedSeconds();
            CumulativeReporterBase::testGroupEnded( testGroupStats );
            writeGroup( *m_testGroups.back(), suiteTime );
        }

        virtual void testRunEndedCumulative() {
            xml.endElement();
        }

        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
            TestGroupStats const& stats = groupNode.value;
            xml.writeAttribute( "name", stats.groupInfo.name );
            xml.writeAttribute( "errors", unexpectedExceptions );
            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
            xml.writeAttribute( "tests", stats.totals.assertions.total() );
            xml.writeAttribute( "hostname", "tbd" ); // !TBD
            if( m_config->showDurations() == ShowDurations::Never )
                xml.writeAttribute( "time", "" );
            else
                xml.writeAttribute( "time", suiteTime );
            xml.writeAttribute( "timestamp", "tbd" ); // !TBD

            // Write test cases
            for( TestGroupNode::ChildNodes::const_iterator
                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
                    it != itEnd;
                    ++it )
                writeTestCase( **it );

            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
        }

        void writeTestCase( TestCaseNode const& testCaseNode ) {
            TestCaseStats const& stats = testCaseNode.value;

            // All test cases have exactly one section - which represents the
            // test case itself. That section may have 0-n nested sections
            assert( testCaseNode.children.size() == 1 );
            SectionNode const& rootSection = *testCaseNode.children.front();

            std::string className = stats.testInfo.className;

            if( className.empty() ) {
                if( rootSection.childSections.empty() )
                    className = "global";
            }
            writeSection( className, "", rootSection );
        }

        void writeSection(  std::string const& className,
                            std::string const& rootName,
                            SectionNode const& sectionNode ) {
            std::string name = trim( sectionNode.stats.sectionInfo.name );
            if( !rootName.empty() )
                name = rootName + "/" + name;

            if( !sectionNode.assertions.empty() ||
                !sectionNode.stdOut.empty() ||
                !sectionNode.stdErr.empty() ) {
                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
                if( className.empty() ) {
                    xml.writeAttribute( "classname", name );
                    xml.writeAttribute( "name", "root" );
                }
                else {
                    xml.writeAttribute( "classname", className );
                    xml.writeAttribute( "name", name );
                }
                xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );

                writeAssertions( sectionNode );

                if( !sectionNode.stdOut.empty() )
                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
                if( !sectionNode.stdErr.empty() )
                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
            }
            for( SectionNode::ChildSections::const_iterator
                    it = sectionNode.childSections.begin(),
                    itEnd = sectionNode.childSections.end();
                    it != itEnd;
                    ++it )
                if( className.empty() )
                    writeSection( name, "", **it );
                else
                    writeSection( className, name, **it );
        }

        void writeAssertions( SectionNode const& sectionNode ) {
            for( SectionNode::Assertions::const_iterator
                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
                    it != itEnd;
                    ++it )
                writeAssertion( *it );
        }
        void writeAssertion( AssertionStats const& stats ) {
            AssertionResult const& result = stats.assertionResult;
            if( !result.isOk() ) {
                std::string elementName;
                switch( result.getResultType() ) {
                    case ResultWas::ThrewException:
                    case ResultWas::FatalErrorCondition:
                        elementName = "error";
                        break;
                    case ResultWas::ExplicitFailure:
                        elementName = "failure";
                        break;
                    case ResultWas::ExpressionFailed:
                        elementName = "failure";
                        break;
                    case ResultWas::DidntThrowException:
                        elementName = "failure";
                        break;

                    // We should never see these here:
                    case ResultWas::Info:
                    case ResultWas::Warning:
                    case ResultWas::Ok:
                    case ResultWas::Unknown:
                    case ResultWas::FailureBit:
                    case ResultWas::Exception:
                        elementName = "internalError";
                        break;
                }

                XmlWriter::ScopedElement e = xml.scopedElement( elementName );

                xml.writeAttribute( "message", result.getExpandedExpression() );
                xml.writeAttribute( "type", result.getTestMacroName() );

                std::ostringstream oss;
                if( !result.getMessage().empty() )
                    oss << result.getMessage() << "\n";
                for( std::vector::const_iterator
                        it = stats.infoMessages.begin(),
                        itEnd = stats.infoMessages.end();
                            it != itEnd;
                            ++it )
                    if( it->type == ResultWas::Info )
                        oss << it->message << "\n";

                oss << "at " << result.getSourceInfo();
                xml.writeText( oss.str(), false );
            }
        }

        XmlWriter xml;
        Timer suiteTimer;
        std::ostringstream stdOutForSuite;
        std::ostringstream stdErrForSuite;
        unsigned int unexpectedExceptions;
    };

    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )

} // end namespace Catch

// #included from: ../reporters/catch_reporter_console.hpp
#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED

namespace Catch {

    struct ConsoleReporter : StreamingReporterBase {
        ConsoleReporter( ReporterConfig const& _config )
        :   StreamingReporterBase( _config ),
            m_headerPrinted( false )
        {}

        virtual ~ConsoleReporter();
        static std::string getDescription() {
            return "Reports test results as plain lines of text";
        }
        virtual ReporterPreferences getPreferences() const {
            ReporterPreferences prefs;
            prefs.shouldRedirectStdOut = false;
            return prefs;
        }

        virtual void noMatchingTestCases( std::string const& spec ) {
            stream << "No test cases matched '" << spec << "'" << std::endl;
        }

        virtual void assertionStarting( AssertionInfo const& ) {
        }

        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
            AssertionResult const& result = _assertionStats.assertionResult;

            bool printInfoMessages = true;

            // Drop out if result was successful and we're not printing those
            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
                if( result.getResultType() != ResultWas::Warning )
                    return false;
                printInfoMessages = false;
            }

            lazyPrint();

            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
            printer.print();
            stream << std::endl;
            return true;
        }

        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
            m_headerPrinted = false;
            StreamingReporterBase::sectionStarting( _sectionInfo );
        }
        virtual void sectionEnded( SectionStats const& _sectionStats ) {
            if( _sectionStats.missingAssertions ) {
                lazyPrint();
                Colour colour( Colour::ResultError );
                if( m_sectionStack.size() > 1 )
                    stream << "\nNo assertions in section";
                else
                    stream << "\nNo assertions in test case";
                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
            }
            if( m_headerPrinted ) {
                if( m_config->showDurations() == ShowDurations::Always )
                    stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
                m_headerPrinted = false;
            }
            else {
                if( m_config->showDurations() == ShowDurations::Always )
                    stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
            }
            StreamingReporterBase::sectionEnded( _sectionStats );
        }

        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
            StreamingReporterBase::testCaseEnded( _testCaseStats );
            m_headerPrinted = false;
        }
        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
            if( currentGroupInfo.used ) {
                printSummaryDivider();
                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
                printTotals( _testGroupStats.totals );
                stream << "\n" << std::endl;
            }
            StreamingReporterBase::testGroupEnded( _testGroupStats );
        }
        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
            printTotalsDivider( _testRunStats.totals );
            printTotals( _testRunStats.totals );
            stream << std::endl;
            StreamingReporterBase::testRunEnded( _testRunStats );
        }

    private:

        class AssertionPrinter {
            void operator= ( AssertionPrinter const& );
        public:
            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
            :   stream( _stream ),
                stats( _stats ),
                result( _stats.assertionResult ),
                colour( Colour::None ),
                message( result.getMessage() ),
                messages( _stats.infoMessages ),
                printInfoMessages( _printInfoMessages )
            {
                switch( result.getResultType() ) {
                    case ResultWas::Ok:
                        colour = Colour::Success;
                        passOrFail = "PASSED";
                        //if( result.hasMessage() )
                        if( _stats.infoMessages.size() == 1 )
                            messageLabel = "with message";
                        if( _stats.infoMessages.size() > 1 )
                            messageLabel = "with messages";
                        break;
                    case ResultWas::ExpressionFailed:
                        if( result.isOk() ) {
                            colour = Colour::Success;
                            passOrFail = "FAILED - but was ok";
                        }
                        else {
                            colour = Colour::Error;
                            passOrFail = "FAILED";
                        }
                        if( _stats.infoMessages.size() == 1 )
                            messageLabel = "with message";
                        if( _stats.infoMessages.size() > 1 )
                            messageLabel = "with messages";
                        break;
                    case ResultWas::ThrewException:
                        colour = Colour::Error;
                        passOrFail = "FAILED";
                        messageLabel = "due to unexpected exception with message";
                        break;
                    case ResultWas::FatalErrorCondition:
                        colour = Colour::Error;
                        passOrFail = "FAILED";
                        messageLabel = "due to a fatal error condition";
                        break;
                    case ResultWas::DidntThrowException:
                        colour = Colour::Error;
                        passOrFail = "FAILED";
                        messageLabel = "because no exception was thrown where one was expected";
                        break;
                    case ResultWas::Info:
                        messageLabel = "info";
                        break;
                    case ResultWas::Warning:
                        messageLabel = "warning";
                        break;
                    case ResultWas::ExplicitFailure:
                        passOrFail = "FAILED";
                        colour = Colour::Error;
                        if( _stats.infoMessages.size() == 1 )
                            messageLabel = "explicitly with message";
                        if( _stats.infoMessages.size() > 1 )
                            messageLabel = "explicitly with messages";
                        break;
                    // These cases are here to prevent compiler warnings
                    case ResultWas::Unknown:
                    case ResultWas::FailureBit:
                    case ResultWas::Exception:
                        passOrFail = "** internal error **";
                        colour = Colour::Error;
                        break;
                }
            }

            void print() const {
                printSourceInfo();
                if( stats.totals.assertions.total() > 0 ) {
                    if( result.isOk() )
                        stream << "\n";
                    printResultType();
                    printOriginalExpression();
                    printReconstructedExpression();
                }
                else {
                    stream << "\n";
                }
                printMessage();
            }

        private:
            void printResultType() const {
                if( !passOrFail.empty() ) {
                    Colour colourGuard( colour );
                    stream << passOrFail << ":\n";
                }
            }
            void printOriginalExpression() const {
                if( result.hasExpression() ) {
                    Colour colourGuard( Colour::OriginalExpression );
                    stream  << "  ";
                    stream << result.getExpressionInMacro();
                    stream << "\n";
                }
            }
            void printReconstructedExpression() const {
                if( result.hasExpandedExpression() ) {
                    stream << "with expansion:\n";
                    Colour colourGuard( Colour::ReconstructedExpression );
                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
                }
            }
            void printMessage() const {
                if( !messageLabel.empty() )
                    stream << messageLabel << ":" << "\n";
                for( std::vector::const_iterator it = messages.begin(), itEnd = messages.end();
                        it != itEnd;
                        ++it ) {
                    // If this assertion is a warning ignore any INFO messages
                    if( printInfoMessages || it->type != ResultWas::Info )
                        stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
                }
            }
            void printSourceInfo() const {
                Colour colourGuard( Colour::FileName );
                stream << result.getSourceInfo() << ": ";
            }

            std::ostream& stream;
            AssertionStats const& stats;
            AssertionResult const& result;
            Colour::Code colour;
            std::string passOrFail;
            std::string messageLabel;
            std::string message;
            std::vector messages;
            bool printInfoMessages;
        };

        void lazyPrint() {

            if( !currentTestRunInfo.used )
                lazyPrintRunInfo();
            if( !currentGroupInfo.used )
                lazyPrintGroupInfo();

            if( !m_headerPrinted ) {
                printTestCaseAndSectionHeader();
                m_headerPrinted = true;
            }
        }
        void lazyPrintRunInfo() {
            stream  << "\n" << getLineOfChars<'~'>() << "\n";
            Colour colour( Colour::SecondaryText );
            stream  << currentTestRunInfo->name
                    << " is a Catch v"  << libraryVersion.majorVersion << "."
                    << libraryVersion.minorVersion << " b"
                    << libraryVersion.buildNumber;
            if( libraryVersion.branchName != std::string( "master" ) )
                stream << " (" << libraryVersion.branchName << ")";
            stream  << " host application.\n"
                    << "Run with -? for options\n\n";

            if( m_config->rngSeed() != 0 )
                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";

            currentTestRunInfo.used = true;
        }
        void lazyPrintGroupInfo() {
            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
                printClosedHeader( "Group: " + currentGroupInfo->name );
                currentGroupInfo.used = true;
            }
        }
        void printTestCaseAndSectionHeader() {
            assert( !m_sectionStack.empty() );
            printOpenHeader( currentTestCaseInfo->name );

            if( m_sectionStack.size() > 1 ) {
                Colour colourGuard( Colour::Headers );

                std::vector::const_iterator
                    it = m_sectionStack.begin()+1, // Skip first section (test case)
                    itEnd = m_sectionStack.end();
                for( ; it != itEnd; ++it )
                    printHeaderString( it->name, 2 );
            }

            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;

            if( !lineInfo.empty() ){
                stream << getLineOfChars<'-'>() << "\n";
                Colour colourGuard( Colour::FileName );
                stream << lineInfo << "\n";
            }
            stream << getLineOfChars<'.'>() << "\n" << std::endl;
        }

        void printClosedHeader( std::string const& _name ) {
            printOpenHeader( _name );
            stream << getLineOfChars<'.'>() << "\n";
        }
        void printOpenHeader( std::string const& _name ) {
            stream  << getLineOfChars<'-'>() << "\n";
            {
                Colour colourGuard( Colour::Headers );
                printHeaderString( _name );
            }
        }

        // if string has a : in first line will set indent to follow it on
        // subsequent lines
        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
            std::size_t i = _string.find( ": " );
            if( i != std::string::npos )
                i+=2;
            else
                i = 0;
            stream << Text( _string, TextAttributes()
                                        .setIndent( indent+i)
                                        .setInitialIndent( indent ) ) << "\n";
        }

        struct SummaryColumn {

            SummaryColumn( std::string const& _label, Colour::Code _colour )
            :   label( _label ),
                colour( _colour )
            {}
            SummaryColumn addRow( std::size_t count ) {
                std::ostringstream oss;
                oss << count;
                std::string row = oss.str();
                for( std::vector::iterator it = rows.begin(); it != rows.end(); ++it ) {
                    while( it->size() < row.size() )
                        *it = " " + *it;
                    while( it->size() > row.size() )
                        row = " " + row;
                }
                rows.push_back( row );
                return *this;
            }

            std::string label;
            Colour::Code colour;
            std::vector rows;

        };

        void printTotals( Totals const& totals ) {
            if( totals.testCases.total() == 0 ) {
                stream << Colour( Colour::Warning ) << "No tests ran\n";
            }
            else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) {
                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
                stream << " ("
                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
                        << pluralise( totals.testCases.passed, "test case" ) << ")"
                        << "\n";
            }
            else {

                std::vector columns;
                columns.push_back( SummaryColumn( "", Colour::None )
                                        .addRow( totals.testCases.total() )
                                        .addRow( totals.assertions.total() ) );
                columns.push_back( SummaryColumn( "passed", Colour::Success )
                                        .addRow( totals.testCases.passed )
                                        .addRow( totals.assertions.passed ) );
                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
                                        .addRow( totals.testCases.failed )
                                        .addRow( totals.assertions.failed ) );
                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
                                        .addRow( totals.testCases.failedButOk )
                                        .addRow( totals.assertions.failedButOk ) );

                printSummaryRow( "test cases", columns, 0 );
                printSummaryRow( "assertions", columns, 1 );
            }
        }
        void printSummaryRow( std::string const& label, std::vector const& cols, std::size_t row ) {
            for( std::vector::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
                std::string value = it->rows[row];
                if( it->label.empty() ) {
                    stream << label << ": ";
                    if( value != "0" )
                        stream << value;
                    else
                        stream << Colour( Colour::Warning ) << "- none -";
                }
                else if( value != "0" ) {
                    stream  << Colour( Colour::LightGrey ) << " | ";
                    stream  << Colour( it->colour )
                            << value << " " << it->label;
                }
            }
            stream << "\n";
        }

        static std::size_t makeRatio( std::size_t number, std::size_t total ) {
            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
        }
        static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
            if( i > j && i > k )
                return i;
            else if( j > k )
                return j;
            else
                return k;
        }

        void printTotalsDivider( Totals const& totals ) {
            if( totals.testCases.total() > 0 ) {
                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
                    findMax( failedRatio, failedButOkRatio, passedRatio )--;

                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
                if( totals.testCases.allPassed() )
                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
                else
                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
            }
            else {
                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
            }
            stream << "\n";
        }
        void printSummaryDivider() {
            stream << getLineOfChars<'-'>() << "\n";
        }

    private:
        bool m_headerPrinted;
    };

    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )

} // end namespace Catch

// #included from: ../reporters/catch_reporter_compact.hpp
#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED

namespace Catch {

    struct CompactReporter : StreamingReporterBase {

        CompactReporter( ReporterConfig const& _config )
        : StreamingReporterBase( _config )
        {}

        virtual ~CompactReporter();

        static std::string getDescription() {
            return "Reports test results on a single line, suitable for IDEs";
        }

        virtual ReporterPreferences getPreferences() const {
            ReporterPreferences prefs;
            prefs.shouldRedirectStdOut = false;
            return prefs;
        }

        virtual void noMatchingTestCases( std::string const& spec ) {
            stream << "No test cases matched '" << spec << "'" << std::endl;
        }

        virtual void assertionStarting( AssertionInfo const& ) {
        }

        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
            AssertionResult const& result = _assertionStats.assertionResult;

            bool printInfoMessages = true;

            // Drop out if result was successful and we're not printing those
            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
                if( result.getResultType() != ResultWas::Warning )
                    return false;
                printInfoMessages = false;
            }

            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
            printer.print();

            stream << std::endl;
            return true;
        }

        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
            printTotals( _testRunStats.totals );
            stream << "\n" << std::endl;
            StreamingReporterBase::testRunEnded( _testRunStats );
        }

    private:
        class AssertionPrinter {
            void operator= ( AssertionPrinter const& );
        public:
            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
            : stream( _stream )
            , stats( _stats )
            , result( _stats.assertionResult )
            , messages( _stats.infoMessages )
            , itMessage( _stats.infoMessages.begin() )
            , printInfoMessages( _printInfoMessages )
            {}

            void print() {
                printSourceInfo();

                itMessage = messages.begin();

                switch( result.getResultType() ) {
                    case ResultWas::Ok:
                        printResultType( Colour::ResultSuccess, passedString() );
                        printOriginalExpression();
                        printReconstructedExpression();
                        if ( ! result.hasExpression() )
                            printRemainingMessages( Colour::None );
                        else
                            printRemainingMessages();
                        break;
                    case ResultWas::ExpressionFailed:
                        if( result.isOk() )
                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
                        else
                            printResultType( Colour::Error, failedString() );
                        printOriginalExpression();
                        printReconstructedExpression();
                        printRemainingMessages();
                        break;
                    case ResultWas::ThrewException:
                        printResultType( Colour::Error, failedString() );
                        printIssue( "unexpected exception with message:" );
                        printMessage();
                        printExpressionWas();
                        printRemainingMessages();
                        break;
                    case ResultWas::FatalErrorCondition:
                        printResultType( Colour::Error, failedString() );
                        printIssue( "fatal error condition with message:" );
                        printMessage();
                        printExpressionWas();
                        printRemainingMessages();
                        break;
                    case ResultWas::DidntThrowException:
                        printResultType( Colour::Error, failedString() );
                        printIssue( "expected exception, got none" );
                        printExpressionWas();
                        printRemainingMessages();
                        break;
                    case ResultWas::Info:
                        printResultType( Colour::None, "info" );
                        printMessage();
                        printRemainingMessages();
                        break;
                    case ResultWas::Warning:
                        printResultType( Colour::None, "warning" );
                        printMessage();
                        printRemainingMessages();
                        break;
                    case ResultWas::ExplicitFailure:
                        printResultType( Colour::Error, failedString() );
                        printIssue( "explicitly" );
                        printRemainingMessages( Colour::None );
                        break;
                    // These cases are here to prevent compiler warnings
                    case ResultWas::Unknown:
                    case ResultWas::FailureBit:
                    case ResultWas::Exception:
                        printResultType( Colour::Error, "** internal error **" );
                        break;
                }
            }

        private:
            // Colour::LightGrey

            static Colour::Code dimColour() { return Colour::FileName; }

#ifdef CATCH_PLATFORM_MAC
            static const char* failedString() { return "FAILED"; }
            static const char* passedString() { return "PASSED"; }
#else
            static const char* failedString() { return "failed"; }
            static const char* passedString() { return "passed"; }
#endif

            void printSourceInfo() const {
                Colour colourGuard( Colour::FileName );
                stream << result.getSourceInfo() << ":";
            }

            void printResultType( Colour::Code colour, std::string passOrFail ) const {
                if( !passOrFail.empty() ) {
                    {
                        Colour colourGuard( colour );
                        stream << " " << passOrFail;
                    }
                    stream << ":";
                }
            }

            void printIssue( std::string issue ) const {
                stream << " " << issue;
            }

            void printExpressionWas() {
                if( result.hasExpression() ) {
                    stream << ";";
                    {
                        Colour colour( dimColour() );
                        stream << " expression was:";
                    }
                    printOriginalExpression();
                }
            }

            void printOriginalExpression() const {
                if( result.hasExpression() ) {
                    stream << " " << result.getExpression();
                }
            }

            void printReconstructedExpression() const {
                if( result.hasExpandedExpression() ) {
                    {
                        Colour colour( dimColour() );
                        stream << " for: ";
                    }
                    stream << result.getExpandedExpression();
                }
            }

            void printMessage() {
                if ( itMessage != messages.end() ) {
                    stream << " '" << itMessage->message << "'";
                    ++itMessage;
                }
            }

            void printRemainingMessages( Colour::Code colour = dimColour() ) {
                if ( itMessage == messages.end() )
                    return;

                // using messages.end() directly yields compilation error:
                std::vector::const_iterator itEnd = messages.end();
                const std::size_t N = static_cast( std::distance( itMessage, itEnd ) );

                {
                    Colour colourGuard( colour );
                    stream << " with " << pluralise( N, "message" ) << ":";
                }

                for(; itMessage != itEnd; ) {
                    // If this assertion is a warning ignore any INFO messages
                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
                        stream << " '" << itMessage->message << "'";
                        if ( ++itMessage != itEnd ) {
                            Colour colourGuard( dimColour() );
                            stream << " and";
                        }
                    }
                }
            }

        private:
            std::ostream& stream;
            AssertionStats const& stats;
            AssertionResult const& result;
            std::vector messages;
            std::vector::const_iterator itMessage;
            bool printInfoMessages;
        };

        // Colour, message variants:
        // - white: No tests ran.
        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
        // - white: Passed [both/all] N test cases (no assertions).
        // -   red: Failed N tests cases, failed M assertions.
        // - green: Passed [both/all] N tests cases with M assertions.

        std::string bothOrAll( std::size_t count ) const {
            return count == 1 ? "" : count == 2 ? "both " : "all " ;
        }

        void printTotals( const Totals& totals ) const {
            if( totals.testCases.total() == 0 ) {
                stream << "No tests ran.";
            }
            else if( totals.testCases.failed == totals.testCases.total() ) {
                Colour colour( Colour::ResultError );
                const std::string qualify_assertions_failed =
                    totals.assertions.failed == totals.assertions.total() ?
                        bothOrAll( totals.assertions.failed ) : "";
                stream <<
                    "Failed " << bothOrAll( totals.testCases.failed )
                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
                    "failed " << qualify_assertions_failed <<
                                 pluralise( totals.assertions.failed, "assertion" ) << ".";
            }
            else if( totals.assertions.total() == 0 ) {
                stream <<
                    "Passed " << bothOrAll( totals.testCases.total() )
                              << pluralise( totals.testCases.total(), "test case" )
                              << " (no assertions).";
            }
            else if( totals.assertions.failed ) {
                Colour colour( Colour::ResultError );
                stream <<
                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << ".";
            }
            else {
                Colour colour( Colour::ResultSuccess );
                stream <<
                    "Passed " << bothOrAll( totals.testCases.passed )
                              << pluralise( totals.testCases.passed, "test case"  ) <<
                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << ".";
            }
        }
    };

    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )

} // end namespace Catch

namespace Catch {
    NonCopyable::~NonCopyable() {}
    IShared::~IShared() {}
    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
    IContext::~IContext() {}
    IResultCapture::~IResultCapture() {}
    ITestCase::~ITestCase() {}
    ITestCaseRegistry::~ITestCaseRegistry() {}
    IRegistryHub::~IRegistryHub() {}
    IMutableRegistryHub::~IMutableRegistryHub() {}
    IExceptionTranslator::~IExceptionTranslator() {}
    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
    IReporter::~IReporter() {}
    IReporterFactory::~IReporterFactory() {}
    IReporterRegistry::~IReporterRegistry() {}
    IStreamingReporter::~IStreamingReporter() {}
    AssertionStats::~AssertionStats() {}
    SectionStats::~SectionStats() {}
    TestCaseStats::~TestCaseStats() {}
    TestGroupStats::~TestGroupStats() {}
    TestRunStats::~TestRunStats() {}
    CumulativeReporterBase::SectionNode::~SectionNode() {}
    CumulativeReporterBase::~CumulativeReporterBase() {}

    StreamingReporterBase::~StreamingReporterBase() {}
    ConsoleReporter::~ConsoleReporter() {}
    CompactReporter::~CompactReporter() {}
    IRunner::~IRunner() {}
    IMutableContext::~IMutableContext() {}
    IConfig::~IConfig() {}
    XmlReporter::~XmlReporter() {}
    JunitReporter::~JunitReporter() {}
    TestRegistry::~TestRegistry() {}
    FreeFunctionTestCase::~FreeFunctionTestCase() {}
    IGeneratorInfo::~IGeneratorInfo() {}
    IGeneratorsForTest::~IGeneratorsForTest() {}
    TestSpec::Pattern::~Pattern() {}
    TestSpec::NamePattern::~NamePattern() {}
    TestSpec::TagPattern::~TagPattern() {}
    TestSpec::ExcludedPattern::~ExcludedPattern() {}

    Matchers::Impl::StdString::Equals::~Equals() {}
    Matchers::Impl::StdString::Contains::~Contains() {}
    Matchers::Impl::StdString::StartsWith::~StartsWith() {}
    Matchers::Impl::StdString::EndsWith::~EndsWith() {}

    void Config::dummy() {}
}

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#endif

#ifdef CATCH_CONFIG_MAIN
// #included from: internal/catch_default_main.hpp
#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED

#ifndef __OBJC__

// Standard C/C++ main entry point
int main (int argc, char * const argv[]) {
    return Catch::Session().run( argc, argv );
}

#else // __OBJC__

// Objective-C entry point
int main (int argc, char * const argv[]) {
#if !CATCH_ARC_ENABLED
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
#endif

    Catch::registerTestMethods();
    int result = Catch::Session().run( argc, (char* const*)argv );

#if !CATCH_ARC_ENABLED
    [pool drain];
#endif

    return result;
}

#endif // __OBJC__

#endif

#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
#  undef CLARA_CONFIG_MAIN
#endif

//////

// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
#ifdef CATCH_CONFIG_PREFIX_ALL

#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" )
#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" )

#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS" )
#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" )
#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" )

#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" )
#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" )
#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" )
#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" )
#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" )

#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" )
#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" )
#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" )

#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" )
#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" )

#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg )
#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )

#ifdef CATCH_CONFIG_VARIADIC_MACROS
    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ )
    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ )
#else
    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg )
    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg )
#endif
#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )

#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )

#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )

// "BDD-style" convenience wrappers
#ifdef CATCH_CONFIG_VARIADIC_MACROS
#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
#else
#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
#endif
#define CATCH_GIVEN( desc )    CATCH_SECTION( "Given: " desc, "" )
#define CATCH_WHEN( desc )     CATCH_SECTION( " When: " desc, "" )
#define CATCH_AND_WHEN( desc ) CATCH_SECTION( "  And: " desc, "" )
#define CATCH_THEN( desc )     CATCH_SECTION( " Then: " desc, "" )
#define CATCH_AND_THEN( desc ) CATCH_SECTION( "  And: " desc, "" )

// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
#else

#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" )
#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" )

#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "REQUIRE_THROWS" )
#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" )
#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" )

#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" )
#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" )
#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" )
#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" )
#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" )

#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS" )
#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" )
#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" )

#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" )
#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" )

#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg )
#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )

#ifdef CATCH_CONFIG_VARIADIC_MACROS
    #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
    #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
    #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
    #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
    #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ )
    #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ )
#else
    #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
    #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg )
    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg )
#endif
#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )

#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )

#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )

#endif

#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )

// "BDD-style" convenience wrappers
#ifdef CATCH_CONFIG_VARIADIC_MACROS
#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
#else
#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
#endif
#define GIVEN( desc )    SECTION( "   Given: " desc, "" )
#define WHEN( desc )     SECTION( "    When: " desc, "" )
#define AND_WHEN( desc ) SECTION( "And when: " desc, "" )
#define THEN( desc )     SECTION( "    Then: " desc, "" )
#define AND_THEN( desc ) SECTION( "     And: " desc, "" )

using Catch::Detail::Approx;

// #included from: internal/catch_reenable_warnings.h

#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED

#ifdef __clang__
#    ifdef __ICC // icpc defines the __clang__ macro
#        pragma warning(pop)
#    else
#        pragma clang diagnostic pop
#    endif
#elif defined __GNUC__
#    pragma GCC diagnostic pop
#endif

#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED

clasp-3.2.2/liblp/tests/common.h000066400000000000000000000043501304134206100165210ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 
#ifndef LIBLP_TEST_COMMON_H_INCLUDED
#define LIBLP_TEST_COMMON_H_INCLUDED
#include 
#include 
namespace Potassco {
namespace Test {
template 
using Vec = std::vector;

struct Rule {
	Head_t           ht;
	Vec      head;
	Body_t           bt;
	Weight_t         bnd;
	Vec body;
	bool operator==(const Rule& rhs) const {
		return ht == rhs.ht && head == rhs.head && bt == rhs.bt && bnd == rhs.bnd && body == rhs.body;
	}
};
struct Edge {
	int s;
	int t;
	Vec cond;
	bool operator==(const Edge& rhs) const {
		return s == rhs.s && t == rhs.t && cond == rhs.cond;
	}
};
struct Heuristic {
	Atom_t      atom;
	Heuristic_t type;
	int         bias;
	unsigned    prio;
	Vec  cond;
	bool operator==(const Heuristic& rhs) const {
		return atom == rhs.atom && type == rhs.type && bias == rhs.bias && prio == rhs.prio && cond == rhs.cond;
	}
};

class ReadObserver : public AbstractProgram {
public:
	virtual void initProgram(bool inc) override {
		incremental = inc;
	}
	virtual void beginStep() override {
		++nStep;
	}
	virtual void endStep() override {}
	
	virtual void heuristic(Atom_t a, Heuristic_t t, int bias, unsigned prio, const LitSpan& cond) override {
		heuristics.push_back({a, t, bias, prio, {begin(cond), end(cond)}});
	}
	virtual void acycEdge(int s, int t, const LitSpan& cond) override {
		edges.push_back({s, t, {begin(cond), end(cond)}});
	}
	Vec heuristics;
	Vec      edges;
	int  nStep = 0;
	bool incremental = false;
};


}}

#endif
clasp-3.2.2/liblp/tests/main.cpp000066400000000000000000000001671304134206100165120ustar00rootroot00000000000000#define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
#include "catch.hpp"
clasp-3.2.2/liblp/tests/smodels.cpp000066400000000000000000000561541304134206100172430ustar00rootroot00000000000000// 
// Copyright (c) 2015, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 

#include "catch.hpp"
#include "common.h"
#include 
#include 
#include 
#include 
#include 
namespace Potassco {
namespace Test {
namespace Smodels {
using AtomTab = std::vector;
using LitVec = std::vector;
using RawRule = std::vector;
static void finalize(std::stringstream& str, const AtomTab& atoms = AtomTab(), const std::string& bpos = "", const std::string& bneg = "1") {
	str << "0\n";
	for (const auto& s : atoms) str << s << "\n";
	str << "0\nB+\n" << bpos;
	if (!bpos.empty() && bpos.back() != '\n') str << "\n";
	str << "0\nB-\n";
	str << bneg;
	if (!bneg.empty() && bneg.back() != '\n') str << "\n";
	str << "0\n1\n";
}

enum class Rule_t : unsigned {
	Basic = 1, Cardinality = 2, Choice = 3, Weight = 5, Optimize = 6, Disjunctive = 8,
	ClaspAssignExt = 91, ClaspReleaseExt = 92
};

class ReadObserver : public Test::ReadObserver {
public:
	virtual void rule(Head_t ht, const AtomSpan& head, const LitSpan& body) override {
		if (empty(head)) {
			if (ht == Head_t::Choice) return;
			compute.push_back(-lit(body[0]));
		}
		else {
			Rule_t rt = Rule_t::Basic;
			std::vector r(1, at(head, 0));
			if (size(head) > 1 || ht == Head_t::Choice) {
				r[0] = static_cast(size(head));
				r.insert(r.end(), begin(head), end(head));
				rt = ht == Head_t::Choice ? Rule_t::Choice : Rule_t::Disjunctive;
			}
			r.insert(r.end(), begin(body), end(body));
			rules[rt].push_back(std::move(r));
		}
	}
	virtual void rule(Head_t ht, const AtomSpan& head, Weight_t bound, const WeightLitSpan& body) override {
		int rt = isSmodelsRule(ht, head, bound, body);
		REQUIRE(rt != 0);
		REQUIRE(size(head) == 1);
		std::vector r(1, at(head, 0));
		r.push_back(bound);
		for (auto&& x : body) {
			r.push_back(lit(x));
			if (rt == (int)Rule_t::Weight) r.push_back(weight(x));
		}
		rules[static_cast(rt)].push_back(std::move(r));
	}
	virtual void minimize(Weight_t prio, const WeightLitSpan& lits) override {
		std::vector r; r.reserve((size(lits) * 2) + 1);
		r.push_back(prio);
		for (auto&& x : lits) {
			r.push_back(lit(x));
			r.push_back(weight(x));
		}
		rules[Rule_t::Optimize].push_back(std::move(r));
	}
	virtual void project(const AtomSpan&) override {}
	virtual void output(const StringSpan& str, const LitSpan& cond) override {
		REQUIRE(size(cond) == 1);
		atoms[*begin(cond)].assign(begin(str), end(str));
	}

	virtual void external(Atom_t a, Value_t v) override {
		if (v != Value_t::Release) {
			rules[Rule_t::ClaspAssignExt].push_back(RawRule{static_cast(a), static_cast(v)});
		}
		else {
			rules[Rule_t::ClaspReleaseExt].push_back(RawRule{static_cast(a)});
		}
	}
	virtual void assume(const LitSpan&) override {}

	using RuleMap = std::map > >;
	using AtomMap = std::unordered_map;
	RuleMap rules;
	LitVec  compute;
	AtomMap atoms;
};
TEST_CASE("Smodels reader ", "[smodels]") {
	std::stringstream input;
	ReadObserver observer;
	SECTION("read empty") {
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.nStep == 1);
		REQUIRE(observer.incremental == false);
		REQUIRE(observer.compute.size() == 1);
		REQUIRE(observer.compute[0] == -1);
	}
	SECTION("read basic rule") {
		input << "1 2 4 2 4 2 3 5\n";
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
		RawRule exp = {2, -4, -2, 3, 5};
		REQUIRE(observer.rules[Rule_t::Basic][0] == exp);
	}
	SECTION("read choice/disjunctive rule") {
		input << "3 2 3 4 2 1 5 6\n";
		input << "8 2 3 4 2 1 5 6\n";
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Choice].size() == 1);
		REQUIRE(observer.rules[Rule_t::Disjunctive].size() == 1);

		RawRule r1 = {2, 3, 4, -5, 6};
		REQUIRE(observer.rules[Rule_t::Choice][0] == r1);
		REQUIRE(observer.rules[Rule_t::Disjunctive][0] == r1);
	}
	SECTION("read card/weight rule") {
		input << "2 2 2 1 1 3 4\n";
		input << "5 3 3 3 1 4 5 6 1 2 3\n";
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Cardinality].size() == 1);
		REQUIRE(observer.rules[Rule_t::Weight].size() == 1);

		RawRule r1 = {2, 1, -3, 4};
		RawRule r2 = {3, 3, -4, 1, 5, 2, 6, 3};
		REQUIRE(observer.rules[Rule_t::Cardinality][0] == r1);
		REQUIRE(observer.rules[Rule_t::Weight][0] == r2);
	}
	SECTION("read min rule") {
		input << "6 0 3 1 4 5 6 1 3 2\n";
		input << "6 0 3 1 4 5 6 1 3 2\n";
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Optimize].size() == 2);
		RawRule r = {0, -4, 1, 5, 3, 6, 2};
		REQUIRE(observer.rules[Rule_t::Optimize][0] == r);
		r[0] = 1;
		REQUIRE(observer.rules[Rule_t::Optimize][1] == r);
	}
	SECTION("read atom names") {
		finalize(input, {"1 Foo", "2 Bar", "3 Test(X,Y)"});
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.atoms.size() == 3);
		REQUIRE(observer.atoms[1] == "Foo");
		REQUIRE(observer.atoms[2] == "Bar");
		REQUIRE(observer.atoms[3] == "Test(X,Y)");
	}
	SECTION("read compute") {
		finalize(input, {}, "2\n3", "1\n4\n5");
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.compute.size() == 5);
		const auto& c = observer.compute;
		REQUIRE(std::find(c.begin(), c.end(), 2) != c.end());
		REQUIRE(std::find(c.begin(), c.end(), 3) != c.end());
		REQUIRE(std::find(c.begin(), c.end(), -1) != c.end());
		REQUIRE(std::find(c.begin(), c.end(), -4) != c.end());
		REQUIRE(std::find(c.begin(), c.end(), -5) != c.end());
	}
	SECTION("read external") {
		input << "0\n0\nB+\n0\nB-\n0\nE\n1\n2\n4\n0\n1\n";
		REQUIRE(Potassco::readSmodels(input, observer) == 0);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt].size() == 3);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][0] == RawRule({1, 0}));
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][1] == RawRule({2, 0}));
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][2] == RawRule({4, 0}));
	}
}

TEST_CASE("SmodelsExtReader ", "[smodels][smodels_ext]") {
	std::stringstream input;
	ReadObserver observer;
	SmodelsInput::Options opts; opts.enableClaspExt();
	SECTION("read incremental") {
		input << "90 0\n";
		finalize(input);
		input << "90 0\n";
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer, 0, opts) == 0);
		REQUIRE(observer.incremental == true);
		REQUIRE(observer.nStep == 2);
	}
	SECTION("read external") {
		input << "91 2 0\n";
		input << "91 3 1\n";
		input << "91 4 2\n";
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer, 0, opts) == 0);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt].size() == 3);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][0] == RawRule({2, static_cast(Value_t::False)}));
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][1] == RawRule({3, static_cast(Value_t::True)}));
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][2] == RawRule({4, static_cast(Value_t::Free)}));
	}
	SECTION("read release") {
		input << "91 2 0\n";
		input << "92 2\n";
		finalize(input);
		REQUIRE(Potassco::readSmodels(input, observer, 0, opts) == 0);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt].size() == 1);
		REQUIRE(observer.rules[Rule_t::ClaspReleaseExt].size() == 1);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][0] == RawRule({2, static_cast(Value_t::False)}));
		REQUIRE(observer.rules[Rule_t::ClaspReleaseExt][0] == RawRule({2}));
	}
}

TEST_CASE("Write smodels", "[smodels]") {
	std::stringstream str, exp;
	SmodelsOutput writer(str, false, 0);
	ReadObserver observer;
	writer.initProgram(false);
	SECTION("empty program is valid") {
		writer.endStep();
		exp << "0\n0\nB+\n0\nB-\n0\n1\n";
		REQUIRE(str.str() == exp.str());
	}
	SECTION("body literals are correctly reordered") {
		Atom_t a = 1;
		Vec body ={2, -3, -4, 5};
		writer.rule(Head_t::Disjunctive, toSpan(&a, 1), toSpan(body));
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
		RawRule r ={1, -3, -4, 2, 5};
		REQUIRE(observer.rules[Rule_t::Basic][0] == r);
	}
	SECTION("body literals with weights are correctly reordered") {
		Atom_t a = 1;
		Vec body ={{2, 2}, {-3, 1}, {-4, 3}, {5, 4}};
		writer.rule(Head_t::Disjunctive, toSpan(&a, 1), 4, toSpan(body));
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Weight].size() == 1);
		RawRule r ={1, 4, -3, 1, -4, 3, 2, 2, 5, 4};
		REQUIRE(observer.rules[Rule_t::Weight][0] == r);
	}
	SECTION("weights are removed from count bodies") {
		Atom_t a = 1;
		Vec body ={{2, 1}, {-3, 1}, {-4, 1}, {5, 1}};
		writer.rule(Head_t::Disjunctive, toSpan(&a, 1), 3, toSpan(body));
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Cardinality].size() == 1);
		RawRule r ={1, 3, -3, -4, 2, 5};
		REQUIRE(observer.rules[Rule_t::Cardinality][0] == r);
	}
	SECTION("all head atoms are written") {
		Vec atoms ={1, 2, 3, 4};
		writer.rule(Head_t::Disjunctive, toSpan(atoms), toSpan());
		writer.rule(Head_t::Choice, toSpan(atoms), toSpan());
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Disjunctive].size() == 1);
		REQUIRE(observer.rules[Rule_t::Choice].size() == 1);
		RawRule r ={4, 1, 2, 3, 4};
		REQUIRE(observer.rules[Rule_t::Disjunctive][0] == r);
		REQUIRE(observer.rules[Rule_t::Choice][0] == r);
	}
	SECTION("minimize rules are written without priority") {
		Vec body ={{2, 2}, {-3, 1}, {-4, 3}, {5, 4}};
		writer.minimize(10, toSpan(body));
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Optimize].size() == 1);
		RawRule r ={0, -3, 1, -4, 3, 2, 2, 5, 4};
		REQUIRE(observer.rules[Rule_t::Optimize][0] == r);
	}
	SECTION("output is written to symbol table") {
		Lit_t a = 1;
		std::string an = "Hallo";
		writer.output(toSpan(an), toSpan(&a, 1));
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		REQUIRE(observer.atoms[a] == an);
	}
	SECTION("output must be added after rules") {
		Lit_t a = 1;
		std::string an = "Hallo";
		writer.output(toSpan(an), toSpan(&a, 1));
		Atom_t b = 2;
		REQUIRE_THROWS(writer.rule(Head_t::Disjunctive, toSpan(&b, 1), toSpan()));
	}
	SECTION("compute statement is written via assume") {
		Atom_t a = 1;
		Vec body ={2, -3, -4, 5};
		writer.rule(Head_t::Disjunctive, toSpan(&a, 1), toSpan(body));
		Lit_t na = -1;
		writer.assume(toSpan(&na, 1));
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
		RawRule r ={1, -3, -4, 2, 5};
		REQUIRE(observer.rules[Rule_t::Basic][0] == r);
		REQUIRE(observer.compute.size() == 1);
		REQUIRE(observer.compute[0] == na);
	}
	SECTION("compute statement can contain multiple literals") {
		Vec compute ={-1, 2, -3, -4, 5, 6};
		writer.assume(toSpan(compute));
		writer.endStep();
		REQUIRE(readSmodels(str, observer) == 0);
		// B+ followed by B-
		std::stable_partition(compute.begin(), compute.end(), [](Lit_t x) {return x > 0; });
		REQUIRE(observer.compute == compute);
	}
	SECTION("only one compute statement supported") {
		Lit_t na = -1, b = 2;
		writer.assume(toSpan(&na, 1));
		REQUIRE_THROWS(writer.assume(toSpan(&b, 1)));
	}
	SECTION("complex directives are not supported") {
		REQUIRE_THROWS(writer.project(toSpan()));
		REQUIRE_THROWS(writer.external(1, Value_t::False));
		REQUIRE_THROWS(writer.heuristic(1, Heuristic_t::Sign, 1, 0, toSpan()));
		REQUIRE_THROWS(writer.acycEdge(1, 2, toSpan()));
	}
}

TEST_CASE("Match heuristic predicate", "[smodels]") {
	const char* in;
	StringSpan  atom;
	Heuristic_t type;
	int bias; unsigned prio;
	SECTION("do not match invalid predicate name") {
		REQUIRE(0 == matchDomHeuPred(in = "heuristic()", atom, type, bias, prio));
		REQUIRE(0 == matchDomHeuPred(in = "_heu()", atom, type, bias, prio));
	}
	SECTION("do not match predicate with wrong arity") {
		REQUIRE(-1 == matchDomHeuPred(in = "_heuristic(x)", atom, type, bias, prio));
		REQUIRE(-2 == matchDomHeuPred(in = "_heuristic(x,sign)", atom, type, bias, prio));
		REQUIRE(-4 == matchDomHeuPred(in = "_heuristic(x,sign,1,2,3)", atom, type, bias, prio));
	}
	SECTION("do not match predicate with invalid parameter") {
		REQUIRE(-2 == matchDomHeuPred(in = "_heuristic(x,invalid,1)", atom, type, bias, prio));
		REQUIRE(-3 == matchDomHeuPred(in = "_heuristic(x,sign,foo)", atom, type, bias, prio));
		REQUIRE(-4 == matchDomHeuPred(in = "_heuristic(x,sign,1,-10)", atom, type, bias, prio));
		REQUIRE(-3 == matchDomHeuPred(in = "_heuristic(x,sign,1a,-10)", atom, type, bias, prio));
		REQUIRE(-2 == matchDomHeuPred(in = "_heuristic(x,sign(),1)", atom, type, bias, prio));
	}
	SECTION("match _heuristic/3 and assign implicit priority") {
		REQUIRE(1 == matchDomHeuPred(in = "_heuristic(x,level,-10)", atom, type, bias, prio));
		REQUIRE(prio == 10);
		REQUIRE(1 == matchDomHeuPred(in = "_heuristic(x,sign,-2147483648)", atom, type, bias, prio));
		REQUIRE(prio == static_cast(2147483647)+1);
		REQUIRE(bias == std::numeric_limits::min());
	}
	SECTION("match _heuristic/4") {
		REQUIRE(1 == matchDomHeuPred(in = "_heuristic(x,level,-10,123)", atom, type, bias, prio));
		REQUIRE(bias == -10);
		REQUIRE(prio == 123);
	}
	SECTION("match complex atom name") {
		REQUIRE(1 == matchDomHeuPred(in = "_heuristic(_heuristic(x,y,z),init,1)", atom, type, bias, prio));
		REQUIRE(type == Heuristic_t::Init);
	}
}


TEST_CASE("SmodelsOutput supports extended programs", "[smodels_ext]") {
	std::stringstream str, exp;
	SmodelsOutput out(str, true, 0);
	SmodelsConvert writer(out, true);
	writer.initProgram(true);
	writer.beginStep();
	exp << "90 0\n";
	Vec      head = {1, 2};
	Vec       body = {3, -4};
	Vec min  = {{-1, 2}, {2, 1}};
	writer.rule(Head_t::Choice, toSpan(head), toSpan(body));
	exp << (int)Rule_t::Choice << " 2 2 3 2 1 5 4\n";
	writer.external(3, Value_t::False);
	writer.external(4, Value_t::False);
	writer.minimize(0, toSpan(min));
	writer.heuristic(1, Heuristic_t::Sign, 1, 0, toSpan());
	exp << "1 6 0 0\n";
	exp << (int)Rule_t::Optimize << " 0 2 1 2 3 2 1\n";
	exp << (int)Rule_t::ClaspAssignExt << " 4 0\n";
	exp << (int)Rule_t::ClaspAssignExt << " 5 0\n";
	exp << "0\n6 _heuristic(_atom(2),sign,1,0)\n2 _atom(2)\n0\nB+\n0\nB-\n1\n0\n1\n";
	writer.endStep();
	writer.beginStep();
	exp << "90 0\n";
	head[0] = 3; head[1] = 4;
	writer.rule(Head_t::Choice, toSpan(head), toSpan());
	exp << (int)Rule_t::Choice << " 2 4 5 0 0\n";
	writer.endStep();
	exp << "0\n0\nB+\n0\nB-\n1\n0\n1\n";
	REQUIRE(str.str() == exp.str());
}


TEST_CASE("Convert to smodels", "[convert]") {
	using BodyLits = std::initializer_list;
	using AggLits  = std::initializer_list;
	ReadObserver observer;
	SmodelsConvert convert(observer, true);
	convert.initProgram(false);
	convert.beginStep();
	SECTION("convert rule") {
		Atom_t a = 1;
		BodyLits lits = {4, -3, -2, 5};
		convert.rule(Head_t::Disjunctive, {&a, 1}, {begin(lits), lits.size()});
		REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
		RawRule r ={convert.get(a), convert.get(4), convert.get(-3), convert.get(-2), convert.get(5)};
		REQUIRE(observer.rules[Rule_t::Basic][0] == r);
	}
	SECTION("convert mixed rule") {
		std::initializer_list h = {1, 2, 3};
		AggLits  lits = {{4, 2}, {-3, 3}, {-2, 1}, {5, 4}};
		convert.rule(Head_t::Choice, {begin(h), h.size()}, 3, {begin(lits), lits.size()});
		REQUIRE(observer.rules[Rule_t::Choice].size() == 1);
		REQUIRE(observer.rules[Rule_t::Weight].size() == 1);
		int aux = (int)convert.maxAtom();
		RawRule cr = {3, convert.get(1), convert.get(2), convert.get(3), aux};
		RawRule sr = {aux, 3, convert.get(4), 2, convert.get(-3), 3, convert.get(-2), 1, convert.get(5), 4};
		REQUIRE(cr == observer.rules[Rule_t::Choice][0]);
		REQUIRE(sr == observer.rules[Rule_t::Weight][0]);
	}

	SECTION("convert minimize") {
		AggLits m1 = {{4, 1}, {-3, -2}, {-2, 1}, {5, -1}};
		AggLits m2 = {{8, 1}, {-7, 2}, {-6, 1}, {9, 1}};
		convert.minimize(3, {begin(m2), 2});
		convert.minimize(10, {begin(m1), m1.size()});
		convert.minimize(3, {begin(m2)+2, 2});
		REQUIRE(observer.rules[Rule_t::Optimize].size() == 0);
		convert.endStep();
		REQUIRE(observer.rules[Rule_t::Optimize].size() == 2);

		RawRule m3 = {3, convert.get(8), 1, convert.get(-7), 2, convert.get(-6), 1, convert.get(9), 1};
		RawRule m10 ={10, convert.get(4), 1, convert.get(3), 2, convert.get(-2), 1, convert.get(-5), 1};
		REQUIRE(observer.rules[Rule_t::Optimize][0] == m3);
		REQUIRE(observer.rules[Rule_t::Optimize][1] == m10);
	}
	SECTION("convert output") {
		LitVec c = {1, -2, 3};
		convert.output({"Foo", 3}, toSpan(c));
		convert.endStep();
		REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
		REQUIRE(convert.maxAtom() == 5);
		Atom_t aux = observer.rules[Rule_t::Basic][0][0];
		REQUIRE(std::strcmp(convert.getName(aux), "Foo") == 0);
	}

	SECTION("convert external") {
		convert.external(1, Value_t::Free);
		convert.external(2, Value_t::True);
		convert.external(3, Value_t::False);
		convert.external(4, Value_t::Release);
		convert.endStep();
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt].size() == 3);
		REQUIRE(observer.rules[Rule_t::ClaspReleaseExt].size() == 1);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][0][1] == Value_t::Free);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][1][1] == Value_t::True);
		REQUIRE(observer.rules[Rule_t::ClaspAssignExt][2][1] == Value_t::False);
	}
	SECTION("edges are converted to atoms") {
		Lit_t a = 1;
		convert.output({"a", 1}, {&a, 1});
		convert.acycEdge(0, 1, {&a, 1});
		LitVec c = {1, 2, 3};
		convert.acycEdge(1, 0, toSpan(c));
		convert.endStep();
		REQUIRE(observer.rules[Rule_t::Basic].size() == 2);
		REQUIRE(observer.atoms[observer.rules[Rule_t::Basic][0][0]] == "_edge(0,1)");
		REQUIRE(observer.atoms[observer.rules[Rule_t::Basic][1][0]] == "_edge(1,0)");
	}

	SECTION("heuristics are converted to atoms") {
		SECTION("empty condition") {
			Lit_t a = 1;
			convert.heuristic(static_cast(a), Heuristic_t::Factor, 10, 2, toSpan());
			convert.output({"a", 1}, {&a, 1});
			convert.endStep();
			REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
			REQUIRE(convert.maxAtom() == 3);
			REQUIRE(observer.atoms[observer.rules[Rule_t::Basic][0][0]] == "_heuristic(a,factor,10,2)");
		}
		SECTION("named condition requires aux atom while unnamed does not") {
			Lit_t a = 1, b = 2, c = 3;
			convert.output({"a", 1}, {&a, 1});
			convert.output({"b", 1}, {&b, 1});
			convert.heuristic(static_cast(a), Heuristic_t::Level, 10, 2, toSpan(&b, 1));
			convert.heuristic(static_cast(a), Heuristic_t::Init, 10, 2, toSpan(&c, 1));
			convert.endStep();
			REQUIRE(observer.rules[Rule_t::Basic].size() == 1);			
			REQUIRE(observer.atoms[observer.rules[Rule_t::Basic][0][0]] == "_heuristic(a,level,10,2)");
			REQUIRE(observer.atoms[convert.get(c)] == "_heuristic(a,init,10,2)");
		}
		SECTION("unused atom is ignored") {
			Lit_t a = 1;
			convert.heuristic(static_cast(a), Heuristic_t::Sign, -1, 2, toSpan());
			convert.endStep();
			REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
			REQUIRE(convert.maxAtom() == 2);
			REQUIRE(observer.atoms.empty());
		}
		SECTION("unnamed atom requires aux name") {
			Atom_t a = 1;
			convert.rule(Head_t::Choice, {&a, 1}, toSpan());
			convert.heuristic(a, Heuristic_t::Sign, -1, 2, toSpan());
			convert.endStep();
			REQUIRE(observer.rules[Rule_t::Basic].size() == 1);
			REQUIRE(convert.maxAtom() == 3);
			REQUIRE(observer.atoms[2] == "_atom(2)");
			REQUIRE(observer.atoms[3] == "_heuristic(_atom(2),sign,-1,2)");
		}
	}
}
inline StringSpan toSpan(const char* str) {
	return Potassco::toSpan(str, std::strlen(str));
}
using Potassco::toSpan;

TEST_CASE("Test Atom to directive conversion", "[clasp]") {
	ReadObserver observer;
	std::stringstream str;
	SmodelsOutput writer(str, false, 0);
	SmodelsInput::Options opts; opts.enableClaspExt().convertEdges().convertHeuristic();
	std::vector atoms = {1, 2, 3, 4, 5, 6};
	writer.initProgram(false);
	writer.beginStep();
	writer.rule(Potassco::Head_t::Choice, Potassco::toSpan(atoms), Potassco::toSpan());
	SECTION("_edge(X,Y) atoms are converted to edges directives") {
		Lit_t a = 1, b = 2, c = 3;
		writer.output(toSpan("_edge(1,2)"), toSpan(&a, 1));
		writer.output(toSpan("_edge(\"1,2\",\"2,1\")"), toSpan(&b, 1));
		writer.output(toSpan("_edge(\"2,1\",\"1,2\")"), toSpan(&c, 1));
		writer.endStep();
		REQUIRE(readSmodels(str, observer, 0, opts) == 0);
		REQUIRE(observer.edges.size() == 3);
		REQUIRE(observer.edges[0].cond == Vec({a}));
		REQUIRE(observer.edges[0].s == 0);
		REQUIRE(observer.edges[0].t == 1);
		REQUIRE(observer.edges[1].cond == Vec({b}));
		REQUIRE(observer.edges[1].s == observer.edges[2].t);
		REQUIRE(observer.edges[2].cond == Vec({c}));
	}
	SECTION("Test acyc") {
		Lit_t a = 1, b = 2;
		SECTION("_acyc_ atoms are converted to edge directives") {
			writer.output(toSpan("_acyc_1_1234_4321"), toSpan(&a, 1));
			writer.output(toSpan("_acyc_1_4321_1234"), toSpan(&b, 1));
		}
		SECTION("_acyc_ and _edge atoms can be mixed") {
			writer.output(toSpan("_acyc_1_1234_4321"), toSpan(&a, 1));
			writer.output(toSpan("_edge(4321,1234)"), toSpan(&b, 1));
		}
		writer.endStep();
		REQUIRE(readSmodels(str, observer, 0, opts) == 0);
		REQUIRE(observer.edges.size() == 2);
		REQUIRE(observer.edges[0].cond == Vec({a}));
		REQUIRE(observer.edges[1].cond == Vec({b}));
		REQUIRE(observer.edges[0].s == observer.edges[1].t);
		REQUIRE(observer.edges[0].t == observer.edges[1].s);
	}
	SECTION("_heuristic atoms are converted to heuristic directive") {
		Lit_t a = 1, b = 2, h1 = 3, h2 = 4, h3 = 5, h4 = 6;
		writer.output(toSpan("f(a,b,c,d(q(r(s))))"), toSpan(&a, 1));
		writer.output(toSpan("f(\"a,b(c,d)\")"), toSpan(&b, 1));
		writer.output(toSpan("_heuristic(f(a,b,c,d(q(r(s)))),sign,-1)"), toSpan(&h1, 1));
		writer.output(toSpan("_heuristic(f(a,b,c,d(q(r(s)))),true,1)"), toSpan(&h2, 1));
		writer.output(toSpan("_heuristic(f(\"a,b(c,d)\"),level,-1,10)"), toSpan(&h3, 1));
		writer.output(toSpan("_heuristic(f(\"a,b(c,d)\"),factor,2,1)"), toSpan(&h4, 1));
		writer.endStep();
		REQUIRE(readSmodels(str, observer, 0, opts) == 0);
		REQUIRE(observer.heuristics.size() == 4);
		Heuristic exp[] ={
			{static_cast(a), Heuristic_t::Sign, -1, 1, {h1}},
			{static_cast(a), Heuristic_t::True, 1, 1, {h2}},
			{static_cast(b), Heuristic_t::Level, -1, 10, {h3}},
			{static_cast(b), Heuristic_t::Factor, 2, 1, {h4}}
		};
		REQUIRE(std::equal(std::begin(exp), std::end(exp), observer.heuristics.begin()) == true);
	}
}

}}}
clasp-3.2.2/liblp/tests/text.cpp000066400000000000000000000116041304134206100165500ustar00rootroot00000000000000// 
// Copyright (c) 2016, Benjamin Kaufmann
// 
// This file is part of Potassco.
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see .
// 

#include "catch.hpp"
#include "common.h"
#include 
#include 
#include 
namespace Potassco {
namespace Test {
namespace Text {

bool read(AspifTextInput& in, std::stringstream& str) {
	return in.accept(str) && in.parse();
}
TEST_CASE("Text reader ", "[text]") {
	std::stringstream input, output;
	AspifOutput out(output);
	AspifTextInput prg(&out);

	SECTION("read empty") {
		REQUIRE(read(prg, input));
		REQUIRE(output.str() == "asp 1 0 0\n0\n");
	}
	SECTION("read fact") {
		input << "x1.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("1 0 1 1 0 0") != std::string::npos);
	}
	SECTION("read basic rule") {
		input << "x1 :- not   x2.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("1 0 1 1 0 1 -2") != std::string::npos);
	}
	SECTION("read choice rule") {
		input << "{x1} :- not x2.\n";
		input << "{x2, x3}.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("1 1 1 1 0 1 -2") != std::string::npos);
		REQUIRE(output.str().find("1 1 2 2 3 0 0") != std::string::npos);
	}
	SECTION("read disjunctive rule") {
		input << "x1 | x2 :- not x3.";
		input << "x1 ; x2 :- not x4.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("1 0 2 1 2 0 1 -3") != std::string::npos);
		REQUIRE(output.str().find("1 0 2 1 2 0 1 -4") != std::string::npos);
	}
	SECTION("read weight rule") {
		input << "x1 :- 2 {x2, x3=2, not x4 = 3, x5}.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("1 0 1 1 1 2 4 2 1 3 2 -4 3 5 1") != std::string::npos);
	}
	SECTION("read alternative atom names") {
		input << "a :- not b, x_3.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("1 0 1 1 0 2 -2 3") != std::string::npos);
	}
	SECTION("read integrity constraint") {
		input << ":- x1, not x2.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("1 0 0 0 2 1 -2") != std::string::npos);
	}
	SECTION("read minimize constraint") {
		input << "#minimize {x1, x2, x3}.\n";
		input << "#minimize {not x1=2, x4, not x5 = 3}@1.\n";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("2 0 3 1 1 2 1 3 1") != std::string::npos);
		REQUIRE(output.str().find("2 1 3 -1 2 4 1 -5 3") != std::string::npos);
	}
	SECTION("read project") {
		input << "#project {a,x2}.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("3 2 1 2") != std::string::npos);
	}
	SECTION("read output") {
		input << "#output foo (1, \"x1, x2\") : x1, x2.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("4 15 foo(1,\"x1, x2\") 2 1 2") != std::string::npos);
	}
	SECTION("read external") {
		input << "#external x1.\n";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("5 1 2") != std::string::npos);
	}
	SECTION("read external with value") {
		input << "#external x2. [true]\n";
		input << "#external x3. [false]\n";
		input << "#external x4. [free]\n";
		input << "#external x5. [release]\n";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("5 2 1") != std::string::npos);
		REQUIRE(output.str().find("5 3 2") != std::string::npos);
		REQUIRE(output.str().find("5 4 0") != std::string::npos);
		REQUIRE(output.str().find("5 5 3") != std::string::npos);
	}
	SECTION("read external with unknown value") {
		input << "#external x2. [open]\n";
		REQUIRE_THROWS(read(prg, input));
	}
	SECTION("read assume") {
		input << "#assume {a, not x2}.";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("6 2 1 -2") != std::string::npos);
	}
	SECTION("read heuristic") {
		input << "#heuristic x1. [1, level]";
		input << "#heuristic x2 : x1. [2@1, true]";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("7 0 1 1 0 0") != std::string::npos);
		REQUIRE(output.str().find("7 4 2 2 1 1 1") != std::string::npos);
	}
	SECTION("read edge") {
		input << "#edge (1,2) : x1.";
		input << "#edge (2,1).";
		REQUIRE(read(prg, input));
		REQUIRE(output.str().find("8 1 2 1 1") != std::string::npos);
		REQUIRE(output.str().find("8 2 1 0") != std::string::npos);
	}
	SECTION("read incremental") {
		input << "#incremental.\n";
		input << "{x1}.\n";
		input << "#step.\n";
		input << "{x2}.\n";
		REQUIRE(read(prg, input));
		REQUIRE(prg.parse());
		REQUIRE(output.str() == 
			"asp 1 0 0 incremental\n"
			"1 1 1 1 0 0\n"
			"0\n"
			"1 1 1 2 0 0\n"
			"0\n");
	}
}


}}}
clasp-3.2.2/libprogram_opts/000077500000000000000000000000001304134206100160155ustar00rootroot00000000000000clasp-3.2.2/libprogram_opts/CMakeLists.txt000066400000000000000000000002731304134206100205570ustar00rootroot00000000000000file(GLOB LIBOPTS_SRC src/*.cpp)
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
SET(LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/lib)
add_library(program_opts STATIC ${LIBOPTS_SRC})
clasp-3.2.2/libprogram_opts/Makefile000066400000000000000000000022051304134206100174540ustar00rootroot00000000000000SHELL        ?= /bin/sh
AR           ?= ar
CXX          ?= g++
BUILD_DIR    ?= .
ROOT_DIR     ?= .
CXXFLAGS     ?= -O3 -DNDEBUG
FLAGS        ?= 
ifneq ($(FLAGS),)
-include $(FLAGS)
endif
INCLUDE      := -I $(ROOT_DIR) 
ALL_CXXFLAGS := -W -Wall $(INCLUDE) $(CXXFLAGS) 
TARGET       := $(BUILD_DIR)/lib/libprogram_opts.a
SOURCES      := $(patsubst $(ROOT_DIR)/src/%.cpp,%.cpp,$(wildcard $(ROOT_DIR)/src/*.cpp))
DEPS         := $(patsubst %.cpp,$(BUILD_DIR)/%.dep, $(SOURCES))
OBJECTS      := $(patsubst %.cpp,$(BUILD_DIR)/%.o, $(SOURCES))
vpath %.cpp $(ROOT_DIR)/src
vpath %.h   $(ROOT_DIR)/program_opts

$(TARGET):	$(FLAGS) $(DEPS) $(OBJECTS)
	$(AR)  cvrs $(TARGET) $(OBJECTS)


ifneq ($(MAKECMDGOALS),clean)
-include $(DEPS)
endif

$(BUILD_DIR)/%.dep: %.cpp $(FLAGS)
	$(CXX) $(ALL_CXXFLAGS) -MT $(BUILD_DIR)/$*.o -MM $< > $@

$(BUILD_DIR)/%.o: %.cpp $(FLAGS)
	$(CXX) $(ALL_CXXFLAGS) -c $< -o $@


.PHONY:	clean 

ifeq ($(findstring Windows,$(OS)),)
clean:
	@$(RM) $(TARGET)
	@$(RM) $(OBJECTS)
	@$(RM) $(DEPS)
else
RM := del /F /Q
clean:
	@$(RM) $(subst /,\,$(TARGET))  2>nul
	@$(RM) $(subst /,\,$(OBJECTS)) 2>nul
	@$(RM) $(subst /,\,$(DEPS))    2>nul
endif
clasp-3.2.2/libprogram_opts/program_opts/000077500000000000000000000000001304134206100205315ustar00rootroot00000000000000clasp-3.2.2/libprogram_opts/program_opts/application.h000066400000000000000000000125101304134206100232040ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann 2004
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef APP_OPTIONS_H_INCLUDED
#define APP_OPTIONS_H_INCLUDED

#ifdef _MSC_VER
#pragma warning (disable : 4200) // nonstandard extension used : zero-sized array
#pragma once
#endif

#include 
#include 
#include "program_options.h"
#include 
#include 

namespace ProgramOptions {
typedef std::vector StringSeq;
/////////////////////////////////////////////////////////////////////////////////////////
// Application base class
/////////////////////////////////////////////////////////////////////////////////////////
#define WRITE_STDERR(type,sys,msg) ( fprintf(stderr, "*** %-5s: (%s): %s\n", (type),(sys),(msg)), fflush(stderr) )
class Application {
public:
	//! Description of and max value for help option.
	typedef std::pair HelpOpt;
	/*!
	 * \name Basic functions.
	 */
	//@{
	//! Returns the name of this application.
	virtual const char* getName()       const   = 0;
	//! Returns the version number of this application.
	virtual const char* getVersion()    const   = 0;
	//! Returns a null-terminated array of signals that this application handles.
	virtual const int*  getSignals()    const { return 0; }
	//! Returns the usage information of this application.
	virtual const char* getUsage()      const { return "[options]"; }
	//! Returns the application's help option and its description.
	virtual HelpOpt     getHelpOption() const { return HelpOpt("Print help information and exit", 1); }
	//! Returns the parser function for handling positional options.
	virtual PosOption   getPositional() const { return 0; }
	//! Prints the given error message to stderr.
	virtual void        error(const char* msg) const { WRITE_STDERR("ERROR", getName(), msg); }
	//! Prints the given info message to stderr.
	virtual void        info(const char*  msg) const { WRITE_STDERR("Info",  getName(), msg); }
	//! Prints the given warning message to stderr.
	virtual void        warn(const char*  msg) const { WRITE_STDERR("Warn",  getName(), msg); }
	//@}

	/*!
	 * \name Main functions.
	 */
	//@{
	//! Runs this application with the given command-line arguments.
	int main(int argc, char** argv);
	//! Sets the value that should be returned as the application's exit code.
	void setExitCode(int n);
	//! Returns the application's exit code.
	int  getExitCode() const;
	//! Returns the application object that is running.
	static Application* getInstance();
	//! Prints the application's help information (called if options contain '--help').
	virtual void        printHelp(const OptionContext& root);
	//! Prints the application's version message (called if options contain '--version').
	virtual void        printVersion();
	//! Prints the application's usage message (default is: "usage: getName() getUsage()").
	virtual void        printUsage();
	//@}
protected:
	/*!
	 * \name Life cycle and option handling
	 */
	//@{
	//! Adds all application options to the given context.
	virtual void        initOptions(OptionContext& root) = 0;
	//! Validates parsed options. Shall throw to signal error.
	virtual void        validateOptions(const OptionContext& root, const ParsedOptions& parsed, const ParsedValues& values) = 0;
	//! Called once after option processing is done.
	virtual void        setup() = 0;
	//! Shall run the application. Called after setup and option processing.
	virtual void        run()   = 0;
	//! Called after run returned. The default is a noop.
	virtual void        shutdown();
	//! Called on an exception from run(). The default terminates the application.
	virtual void        onUnhandledException();
	//! Called when a signal is received. The default terminates the application.
	virtual bool        onSignal(int);
	//@}
protected:
	Application();
	virtual ~Application();
	void     shutdown(bool hasError);
	void     exit(int exitCode) const;
	unsigned verbose() const;
	void     setVerbose(unsigned v);
	void     killAlarm();
	int      blockSignals();
	void     unblockSignals(bool deliverPending);
	void     processSignal(int sigNum);
private:
	bool getOptions(int argc, char** argv);
	int                   exitCode_;  // application's exit code
	unsigned              timeout_;   // active time limit or 0 for no limit
	unsigned              verbose_;   // active verbosity level
	bool                  fastExit_;  // force fast exit?
	volatile long         blocked_;   // temporarily block signals?
	volatile long         pending_;   // pending signal or 0 if no pending signal
	static Application*   instance_s; // running instance (only valid during run()).
	static void sigHandler(int sig);  // signal/timeout handler
};

}
#endif
clasp-3.2.2/libprogram_opts/program_opts/detail/000077500000000000000000000000001304134206100217735ustar00rootroot00000000000000clasp-3.2.2/libprogram_opts/program_opts/detail/alarm.h000066400000000000000000000047561304134206100232540ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
#ifndef ALARM_HELPER_H_INCLUDED
#define ALARM_HELPER_H_INCLUDED
/////////////////////////////////////////////////////////////////////////////////////////
// Alarm handling
/////////////////////////////////////////////////////////////////////////////////////////
#include 
//! Schedules an alarm signal.
/*!
 * The function causes the system to generate a SIGALRM
 * signal for the process after the number of real-time seconds
 * given in sec.
 *
 * If seconds is 0, a pending alarm request, if  any,  is  cancelled.
 *
 * Alarm requests are not stacked; only one SIGALRM generation
 * can be scheduled with this function;
 *
 * setAlarm() returns a value > 0 if the alarm request was set.
 * Otherwise it returns 0.
 */
int  setAlarm(unsigned sec);

//! Sets the SIGALRM handler
void setAlarmHandler(void(*f)(int));

unsigned long initMainThread();
void resetMainThread();
void protectMainThread(bool);

// Implementation:
//  - On POSIX-systems setAlarm() calls alarm() and setAlarmHandler() calls signal()
//  - On Windows a separate alarm thread is created that
//    waits for sec seconds on a termination event and,
//    if the event is not signaled, calls the installed alarm handler in the context
//    of the alarm thread.
//    NOTE: Since the handler is called from a different thread, alarm
//    handling is subject to race-conditions.
//    USe lockAlarm(), unlockAlarm() to protect functions that
//    are not thread-safe and are called by the handler
#if defined(_WIN32) || defined(_WIN64)
void lockAlarm();
void unlockAlarm();
#else
inline void lockAlarm()    {}
inline void unlockAlarm()  {}
#endif

struct ScopedAlarmLock {
	ScopedAlarmLock()  { lockAlarm(); }
	~ScopedAlarmLock() { unlockAlarm();  }
};

#define SCOPE_ALARM_LOCK() ScopedAlarmLock __alarm_lock__


#if !defined(SIGALRM)
#define SIGALRM 14
#endif

#endif
clasp-3.2.2/libprogram_opts/program_opts/detail/notifier.h000066400000000000000000000040731304134206100237670ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann 2010
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_NOTIFIER_H_INCLUDED
#define PROGRAM_OPTIONS_NOTIFIER_H_INCLUDED

namespace ProgramOptions { namespace detail {

///////////////////////////////////////////////////////////////////////////////
// Notifier
///////////////////////////////////////////////////////////////////////////////
// HACK:
// This should actually be replaced with a proper and typesafe delegate class.
// At least, it should be parametrized on the actual parameter type since
// the invocation of f via the generic func is not strictly conforming.
// Yet, it should work on all major compilers - we do not mess with
// the address and the alignment of void* should be compatible with that of T*.
template 
struct Notifier {
	typedef bool (*notify_func_type)(void*, const std::string& name, ParamT);
	Notifier() : obj(0), func(0) {}
	template 
	Notifier(O* o, bool (*f)(O*, const std::string&, ParamT)) {
		obj = o;
		func= reinterpret_cast(f);
	}
	void*            obj;
	notify_func_type func;
	bool notify(const std::string& name, ParamT val) const {
		return func(obj, name, val);
	}
	bool empty() const { return func == 0; }
};

template 
struct Notify {
	typedef bool (*type)(ObjT*, const std::string& name, ParamT);
};

} }
#endif
clasp-3.2.2/libprogram_opts/program_opts/detail/refcountable.h000066400000000000000000000043421304134206100246200ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann 2010
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_REFCOUNTABLE_H_INCLUDED
#define PROGRAM_OPTIONS_REFCOUNTABLE_H_INCLUDED
namespace ProgramOptions { namespace detail {

class RefCountable {
public:
	RefCountable() : refCount_(1) {}
	int  addRef()         { return ++refCount_; }
	int  release()        { return --refCount_; }
	int  refCount() const { return refCount_;   }
private:
	int refCount_;
};

template 
class IntrusiveSharedPtr {
public:
	typedef T element_type;
	explicit IntrusiveSharedPtr(T* p = 0) throw()
		: ptr_(p) { /* NO add ref */ }
	IntrusiveSharedPtr(const IntrusiveSharedPtr& o) throw()
		: ptr_(o.ptr_) { addRef(); }
	~IntrusiveSharedPtr() throw () { release(); }
	IntrusiveSharedPtr& operator=(const IntrusiveSharedPtr& other) {
		other.addRef();
		this->release();
		this->ptr_ = other.ptr_;
		return *this;
	}
	T&     operator*() const throw()   { return *ptr_; }
	T*     operator->() const throw()  { return ptr_;  }
	T*     get() const throw()         { return ptr_; }
	void   reset() throw()             { release(); ptr_ = 0; }
	bool   unique() const throw()      { return  !ptr_ || ptr_->refCount() == 1; }
	int    count() const  throw()      { return ptr_ ? ptr_->refCount() : 0; }
	void   swap(IntrusiveSharedPtr& b) {
		T* temp = ptr_;
		ptr_    = b.ptr_;
		b.ptr_  = temp;
	}
private:
	T* ptr_;
	void addRef()  const { if (ptr_) ptr_->addRef(); }
	void release() const {
		if (ptr_ && ptr_->release() == 0) {
			delete ptr_;
		}
	}
};

}}
#endif
clasp-3.2.2/libprogram_opts/program_opts/detail/value_store.h000066400000000000000000000045301304134206100244760ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann 2010
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_VALUE_STORE_IMPL_H_INCLUDED
#define PROGRAM_OPTIONS_VALUE_STORE_IMPL_H_INCLUDED

#include 

namespace detail {
template 
struct VTable {
	static void clone(const void* o, void** out) {
		*out = new T(*static_cast(o));
	}
	static void destroy(const void* o, void** out) {
		delete static_cast(o);
		*out = 0;
	}
	static void typeinfo(const void*, void** out)  {
		*out = const_cast( static_cast(&typeid(T)) );
	}
	static vtable_type vtable_s;
};
template 
struct OptVTable {
	static void clone(const void* o, void** out) {
		new (&*out) T(*static_cast(o));
	}
	static void destroy(const void* o, void** out) {
		static_cast(o)->~T();
		*out = 0;
	}
	static vtable_type vtable_s;
};
template 
vtable_type VTable::vtable_s = {
	  0
	, &VTable::clone
	, &VTable::destroy
	, &VTable::typeinfo
};
template 
vtable_type OptVTable::vtable_s = {
	(vcall_type)0x1
	, &OptVTable::clone
	, &OptVTable::destroy
	, &VTable::typeinfo
};
template  struct bool2type {};
template 
inline vptr_type vtable_select(bool2type<0>, const T* = 0) {
	return &VTable::vtable_s;
}
template 
inline vptr_type vtable_select(bool2type<1>, const T* = 0) {
	return &OptVTable::vtable_s;
}
template 
inline vptr_type vtable(const T* x) {
	return vtable_select(bool2type(), x);
}

template 
inline vptr_type base_vtable(const T* x) {
	return vtable_select(bool2type<0>(), x);
}

}

#endif
clasp-3.2.2/libprogram_opts/program_opts/errors.h000066400000000000000000000064271304134206100222270ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann 2004
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_ERRORS_H_INCLUDED
#define PROGRAM_OPTIONS_ERRORS_H_INCLUDED
#include 
#include 
namespace ProgramOptions {

//! Base class for all exceptions.
class Error : public std::logic_error {
public:
	explicit Error(const std::string& what) : std::logic_error(what) {}
};

//! Used for signaling errors on command-line and in declaring options.
class SyntaxError : public Error {
public:
	enum Type {
		missing_value,
		extra_value,
		invalid_format
	};
	SyntaxError(Type t, const std::string& key);
	~SyntaxError() throw () {}
	Type               type() const { return type_; }
	const std::string& key()  const { return key_;  }
private:
	std::string key_;
	Type        type_;
};

//! Used for signaling errors in OptionContext.
class ContextError : public Error {
public:
	enum Type {
		duplicate_option,
		unknown_option,
		ambiguous_option,
		unknown_group,
	};
	ContextError(const std::string& ctx, Type t, const std::string& key, const std::string& desc = "");
	~ContextError() throw () {}
	Type               type() const { return type_; }
	const std::string& key()  const { return key_;  }
	const std::string& ctx()  const { return ctx_;  }
private:
	std::string ctx_;
	std::string key_;
	Type        type_;
};

class DuplicateOption : public ContextError {
public:
	DuplicateOption(const std::string& ctx, const std::string& key) : ContextError(ctx, ContextError::duplicate_option, key) {}
	~DuplicateOption() throw () {}
};
class UnknownOption : public ContextError {
public:
	UnknownOption(const std::string& ctx, const std::string& key) : ContextError(ctx, ContextError::unknown_option, key) {}
	~UnknownOption() throw () {}
};
class AmbiguousOption : public ContextError {
public:
	AmbiguousOption(const std::string& ctx, const std::string& key, const std::string& alt) : ContextError(ctx, ContextError::ambiguous_option, key, alt) {}
	~AmbiguousOption() throw () {}
};

//! Used for signaling validation errors when trying to assign option values.
class ValueError : public Error {
public:
	enum Type {
		multiple_occurences,
		invalid_default,
		invalid_value
	};
	ValueError(const std::string& ctx, Type t, const std::string& opt, const std::string& value);
	~ValueError() throw () {}
	Type               type() const { return type_; }
	const std::string& key()  const { return key_;  }
	const std::string& ctx()  const { return ctx_;  }
	const std::string& value()const { return value_;}
private:
	std::string ctx_;
	std::string key_;
	std::string value_;
	Type        type_;
};


}
#endif
clasp-3.2.2/libprogram_opts/program_opts/mapped_value.h000066400000000000000000000055571304134206100233600ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann 2010
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_MAPPED_VALUE_H_INCLUDED
#define PROGRAM_OPTIONS_MAPPED_VALUE_H_INCLUDED
#ifdef _MSC_VER
#pragma warning (disable : 4786)
#pragma warning (disable : 4503)
#endif
#include "typed_value.h"
#include "value_store.h"
#include 
#include 
#include 
#if defined(_MSC_VER) && _MSC_VER <= 1200
namespace std { using ::size_t; }
#endif

namespace ProgramOptions {
///////////////////////////////////////////////////////////////////////////////
// ValueMap
///////////////////////////////////////////////////////////////////////////////
//! Type for storing anonymous values.
/*!
 * Maps option names to their values.
 */
class ValueMap {
public:
	ValueMap() {}
	~ValueMap(){}
	bool               empty() const { return map_.empty(); }
	size_t             size()  const { return map_.size(); }
	size_t             count(const std::string& name) const { return map_.count(name); }
	void               clear()       { map_.clear(); }
	const ValueStore& operator[](const std::string& name) const {
		MapType::const_iterator it = map_.find(name);
		if (it == map_.end()) {
			throw UnknownOption("ValueMap", name);
		}
		return it->second;
	}
	template 
	static bool add(ValueMap* this_, const std::string& name, const T* value) {
		MapType::iterator it = this_->map_.find(name);
		if (it == this_->map_.end()) {
			it = this_->map_.insert(it, MapType::value_type(name, ValueStore()));
		}
		if (it->second.extract_raw() != value) {
			it->second.assimilate(const_cast(value));
		}
		return true;
	}
private:
	ValueMap(const ValueMap&);
	ValueMap& operator=(const ValueMap&);
	typedef std::map MapType;
	MapType map_;
};

/*!
 * Creates a value that is created on demand and stored in a given value map.
 *
 * \see OptionGroup::addOptions()
 */
template 
inline NotifiedValue* store(ValueMap& map, typename detail::Parser::type p = &string_cast) {
	return notify(&map, &ValueMap::add, p);
}

inline NotifiedValue* flag(ValueMap& map, FlagAction a = store_true) {
	return flag(&map, &ValueMap::add, a);
}

}
#endif
clasp-3.2.2/libprogram_opts/program_opts/program_options.h000066400000000000000000000455421304134206100241360ustar00rootroot00000000000000//
//  Copyright (c) Benjamin Kaufmann 2004
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program. If not, see .
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_PROGRAM_OPTIONS_H_INCLUDED
#define PROGRAM_OPTIONS_PROGRAM_OPTIONS_H_INCLUDED
#include "value.h"
#include "detail/refcountable.h"
#include 
#include 
#include 
#include 
#include 
#include 
namespace ProgramOptions {

//! Represents one program option.
/*!
 * An Option consists of a description (long name, short name, description),
 * a (typed) value, and an optional default value.
 *
 * \note
 *   When printing an option, occurrences of %D, %I and %A in its description are replaced
 *   with the option's default value, implicit value and the argument name,
 *   respectively.
 */
class Option : public detail::RefCountable {
public:
	/*!
	* \pre longName != ""
	* \pre vd != 0
	* \param longName    name (and unique key) of the option
	* \param shortName   possible alias name
	* \param description description of the option, used for printing help
	* \param value       value object to be associated with this option
	*/
	Option( const std::string& longName, char shortName,
		const char* description, Value* value);

	~Option();

	const std::string& name()           const  { return name_; }
	char               alias()          const  { return value_->alias(); }
	Value*             value()          const  { return value_; }
	const char*        description()    const  { return description_; }
	const char*        argName()        const  { return value_->arg(); }
	bool               assignDefault()  const;
	std::size_t        maxColumn()      const;
	DescriptionLevel   descLevel()      const  { return value_->level(); }
private:
	std::string name_;        // name (and unique key) of option
	const char* description_; // description of the option (used for --help)
	Value*      value_;       // the option's value manager
};

typedef detail::IntrusiveSharedPtr