ruby-minisat 1.14.2 → 2.2.0

data/minisat/MiniSat_v1.14/Solver.h

@@ -1,206 +0,0 @@
-/****************************************************************************************[Solver.h]
-MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef Solver_h
-#define Solver_h
-
-#include "SolverTypes.h"
-#include "VarOrder.h"
-
-// Redfine if you want output to go somewhere else:
-#define reportf(format, args...) ( printf(format , ## args), fflush(stdout) )
-
-
-//=================================================================================================
-// Solver -- the main class:
-
-
-struct SolverStats {
-    int64   starts, decisions, propagations, conflicts;
-    int64   clauses_literals, learnts_literals, max_literals, tot_literals;
-    SolverStats() : starts(0), decisions(0), propagations(0), conflicts(0)
-      , clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0) { }
-};
-
-
-struct SearchParams {
-    double  var_decay, clause_decay, random_var_freq;    // (reasonable values are: 0.95, 0.999, 0.02)    
-    SearchParams(double v = 1, double c = 1, double r = 0) : var_decay(v), clause_decay(c), random_var_freq(r) { }
-};
-
-
-
-class Solver {
-protected:
-    // Solver state:
-    //
-    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
-    vec<Clause*>        clauses;          // List of problem clauses.
-    vec<Clause*>        learnts;          // List of learnt clauses.
-    int                 n_bin_clauses;    // Keep track of number of binary clauses "inlined" into the watcher lists (we do this primarily to get identical behavior to the version without the binary clauses trick).
-    double              cla_inc;          // Amount to bump next clause with.
-    double              cla_decay;        // INVERSE decay factor for clause activity: stores 1/decay.
-
-    vec<double>         activity;         // A heuristic measurement of the activity of a variable.
-    double              var_inc;          // Amount to bump next variable with.
-    double              var_decay;        // INVERSE decay factor for variable activity: stores 1/decay. Use negative value for static variable order.
-    VarOrder            order;            // Keeps track of the decision variable order.
-
-    vec<vec<GClause> >  watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
-    vec<char>           assigns;          // The current assignments (lbool:s stored as char:s).
-    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
-    vec<int>            trail_lim;        // Separator indices for different decision levels in 'trail'.
-    vec<GClause>        reason;           // 'reason[var]' is the clause that implied the variables current value, or 'NULL' if none.
-    vec<int>            level;            // 'level[var]' is the decision level at which assignment was made.
-    int                 root_level;       // Level of first proper decision.
-    int                 qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
-    int                 simpDB_assigns;   // Number of top-level assignments since last execution of 'simplifyDB()'.
-    int64               simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplifyDB()'.
-
-    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which is used:
-    //
-    vec<char>           analyze_seen;
-    vec<Lit>            analyze_stack;
-    vec<Lit>            analyze_toclear;
-    Clause*             propagate_tmpbin;
-    Clause*             analyze_tmpbin;
-    Clause*             solve_tmpunit;
-    vec<Lit>            addBinary_tmp;
-    vec<Lit>            addTernary_tmp;
-
-    // Main internal methods:
-    //
-    bool        assume           (Lit p);
-    void        cancelUntil      (int level);
-    void        record           (const vec<Lit>& clause);
-
-    void        analyze          (Clause* confl, vec<Lit>& out_learnt, int& out_btlevel); // (bt = backtrack)
-    bool        analyze_removable(Lit p, uint min_level);                                 // (helper method for 'analyze()')
-    void        analyzeFinal     (Clause* confl,  bool skip_first = false);
-    bool        enqueue          (Lit fact, GClause from = GClause_new((Clause*)NULL));
-    Clause*     propagate        ();
-    void        reduceDB         ();
-    Lit         pickBranchLit    (const SearchParams& params);
-    lbool       search           (int nof_conflicts, int nof_learnts, const SearchParams& params);
-    double      progressEstimate ();
-
-    // Activity:
-    //
-    void     varBumpActivity(Lit p) {
-        if (var_decay < 0) return;     // (negative decay means static variable order -- don't bump)
-        if ( (activity[var(p)] += var_inc) > 1e100 ) varRescaleActivity();
-        order.update(var(p)); }
-    void     varDecayActivity  () { if (var_decay >= 0) var_inc *= var_decay; }
-    void     varRescaleActivity();
-    void     claDecayActivity  () { cla_inc *= cla_decay; }
-    void     claRescaleActivity();
-
-    // Operations on clauses:
-    //
-    void     newClause(const vec<Lit>& ps, bool learnt = false);
-    void     claBumpActivity (Clause* c) { if ( (c->activity() += cla_inc) > 1e20 ) claRescaleActivity(); }
-    void     remove          (Clause* c, bool just_dealloc = false);
-    bool     locked          (const Clause* c) const { GClause r = reason[var((*c)[0])]; return !r.isLit() && r.clause() == c; }
-    bool     simplify        (Clause* c) const;
-
-    int      decisionLevel() const { return trail_lim.size(); }
-
-public:
-    Solver() : ok               (true)
-             , n_bin_clauses    (0)
-             , cla_inc          (1)
-             , cla_decay        (1)
-             , var_inc          (1)
-             , var_decay        (1)
-             , order            (assigns, activity)
-             , qhead            (0)
-             , simpDB_assigns   (0)
-             , simpDB_props     (0)
-             , default_params   (SearchParams(0.95, 0.999, 0.02))
-             , expensive_ccmin  (true)
-             , verbosity        (0)
-             , progress_estimate(0)
-             {
-                vec<Lit> dummy(2,lit_Undef);
-                propagate_tmpbin = Clause_new(false, dummy);
-                analyze_tmpbin   = Clause_new(false, dummy);
-                dummy.pop();
-                solve_tmpunit    = Clause_new(false, dummy);
-                addBinary_tmp .growTo(2);
-                addTernary_tmp.growTo(3);
-             }
-
-   ~Solver() {
-       for (int i = 0; i < learnts.size(); i++) remove(learnts[i], true);
-       for (int i = 0; i < clauses.size(); i++) if (clauses[i] != NULL) remove(clauses[i], true); }
-
-    // Helpers: (semi-internal)
-    //
-    lbool   value(Var x) const { return toLbool(assigns[x]); }
-    lbool   value(Lit p) const { return sign(p) ? ~toLbool(assigns[var(p)]) : toLbool(assigns[var(p)]); }
-
-    int     nAssigns() { return trail.size(); }
-    int     nClauses() { return clauses.size() + n_bin_clauses; }   // (minor difference from MiniSat without the GClause trick: learnt binary clauses will be counted as original clauses)
-    int     nLearnts() { return learnts.size(); }
-
-    // Statistics: (read-only member variable)
-    //
-    SolverStats     stats;
-
-    // Mode of operation:
-    //
-    SearchParams    default_params;     // Restart frequency etc.
-    bool            expensive_ccmin;    // Controls conflict clause minimization. TRUE by default.
-    int             verbosity;          // Verbosity level. 0=silent, 1=some progress report, 2=everything
-
-    // Problem specification:
-    //
-    Var     newVar    ();
-    int     nVars     ()                    { return assigns.size(); }
-    void    addUnit   (Lit p)               { if (ok) ok = enqueue(p); }
-    void    addBinary (Lit p, Lit q)        { addBinary_tmp [0] = p; addBinary_tmp [1] = q; addClause(addBinary_tmp); }
-    void    addTernary(Lit p, Lit q, Lit r) { addTernary_tmp[0] = p; addTernary_tmp[1] = q; addTernary_tmp[2] = r; addClause(addTernary_tmp); }
-    void    addClause (const vec<Lit>& ps)  { newClause(ps); }  // (used to be a difference between internal and external method...)
-
-    // Solving:
-    //
-    bool    okay() { return ok; }       // FALSE means solver is in an conflicting state (must never be used again!)
-    void    simplifyDB();
-    bool    solve(const vec<Lit>& assumps);
-    bool    solve() { vec<Lit> tmp; return solve(tmp); }
-
-    double      progress_estimate;  // Set by 'search()'.
-    vec<lbool>  model;              // If problem is satisfiable, this vector contains the model (if any).
-    vec<Lit>    conflict;           // If problem is unsatisfiable (possibly under assumptions), this vector represent the conflict clause expressed in the assumptions.
-};
-
-
-//=================================================================================================
-// Debug:
-
-
-#define L_LIT    "%sx%d"
-#define L_lit(p) sign(p)?"~":"", var(p)
-
-// Just like 'assert()' but expression will be evaluated in the release version as well.
-inline void check(bool expr) { assert(expr); }
-
-
-//=================================================================================================
-#endif

data/minisat/MiniSat_v1.14/SolverTypes.h

@@ -1,130 +0,0 @@
-/***********************************************************************************[SolverTypes.h]
-MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-
-#ifndef SolverTypes_h
-#define SolverTypes_h
-
-#ifndef Global_h
-#include "Global.h"
-#endif
-
-
-//=================================================================================================
-// Variables, literals, clause IDs:
-
-
-// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
-// so that they can be used as array indices.
-
-typedef int Var;
-#define var_Undef (-1)
-
-
-class Lit {
-    int     x;
-public:
-    Lit() : x(2*var_Undef) {}   // (lit_Undef)
-    explicit Lit(Var var, bool sgn = false) : x((var+var) + (int)sgn) {}
-    friend Lit operator ~ (Lit p);
-
-    friend bool sign  (Lit p);
-    friend int  var   (Lit p);
-    friend int  index (Lit p);
-    friend Lit  toLit (int i);
-    friend Lit  unsign(Lit p);
-    friend Lit  id    (Lit p, bool sgn);
-
-    friend bool operator == (Lit p, Lit q);
-    friend bool operator <  (Lit p, Lit q);
-
-    uint hash() const { return (uint)x; }
-};
-inline Lit operator ~ (Lit p) { Lit q; q.x = p.x ^ 1; return q; }
-inline bool sign  (Lit p) { return p.x & 1; }
-inline int  var   (Lit p) { return p.x >> 1; }
-inline int  index (Lit p) { return p.x; }                // A "toInt" method that guarantees small, positive integers suitable for array indexing.
-inline Lit  toLit (int i) { Lit p; p.x = i; return p; }  // Inverse of 'index()'.
-inline Lit  unsign(Lit p) { Lit q; q.x = p.x & ~1; return q; }
-inline Lit  id    (Lit p, bool sgn) { Lit q; q.x = p.x ^ (int)sgn; return q; }
-inline bool operator == (Lit p, Lit q) { return index(p) == index(q); }
-inline bool operator <  (Lit p, Lit q) { return index(p)  < index(q); }  // '<' guarantees that p, ~p are adjacent in the ordering.
-
-const Lit lit_Undef(var_Undef, false);  // }- Useful special constants.
-const Lit lit_Error(var_Undef, true );  // }
-
-inline int toDimacs(Lit p) { return sign(p) ? -var(p) - 1 : var(p) + 1; }
-
-
-//=================================================================================================
-// Clause -- a simple class for representing a clause:
-
-
-class Clause {
-    uint    size_learnt;
-    Lit     data[1];
-public:
-    // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
-    Clause(bool learnt, const vec<Lit>& ps) {
-        size_learnt = (ps.size() << 1) | (int)learnt;
-        for (int i = 0; i < ps.size(); i++) data[i] = ps[i];
-        if (learnt) activity() = 0; }
-
-    // -- use this function instead:
-    friend Clause* Clause_new(bool learnt, const vec<Lit>& ps);
-
-    int       size        ()      const { return size_learnt >> 1; }
-    bool      learnt      ()      const { return size_learnt & 1; }
-    Lit       operator [] (int i) const { return data[i]; }
-    Lit&      operator [] (int i)       { return data[i]; }
-    float&    activity    ()      const { return *((float*)&data[size()]); }
-};
-inline Clause* Clause_new(bool learnt, const vec<Lit>& ps) {
-    assert(sizeof(Lit)      == sizeof(uint));
-    assert(sizeof(float)    == sizeof(uint));
-    void*   mem = xmalloc<char>(sizeof(Clause) - sizeof(Lit) + sizeof(uint)*(ps.size() + (int)learnt));
-    return new (mem) Clause(learnt, ps); }
-
-
-//=================================================================================================
-// GClause -- Generalize clause:
-
-
-// Either a pointer to a clause or a literal.
-class GClause {
-    void*   data;
-    GClause(void* d) : data(d) {}
-public:
-    friend GClause GClause_new(Lit p);
-    friend GClause GClause_new(Clause* c);
-
-    bool        isLit    () const { return ((uintp)data & 1) == 1; }
-    Lit         lit      () const { return toLit(((intp)data) >> 1); }
-    Clause*     clause   () const { return (Clause*)data; }
-    bool        operator == (GClause c) const { return data == c.data; }
-    bool        operator != (GClause c) const { return data != c.data; }
-};
-inline GClause GClause_new(Lit p)     { return GClause((void*)(((intp)index(p) << 1) + 1)); }
-inline GClause GClause_new(Clause* c) { assert(((uintp)c & 1) == 0); return GClause((void*)c); }
-
-#define GClause_NULL GClause_new((Clause*)NULL)
-
-
-//=================================================================================================
-#endif

data/minisat/MiniSat_v1.14/TODO

@@ -1,73 +0,0 @@
-==================================================
-The 'ok' flag...
-==================================================
-
-The vector 'clauses[]' store all clauses of size >= 2, the vector
-'assigns[]' store clauses of size 1, the boolean 'ok' stores clauses
-of size 0 -- and there is only one such clause, the empty clause, so
-in other words, 'ok' stores "is there an empty clause or not".
-
-As Niklas S�rensson pointed out, the 'ok' flag is a bit error prone
-and probably best viewed as an abstraction provided by the public
-member functions for user convenience (you don't have to watch the
-return value after each 'addClause()'). This is currently not
-implemented, and the 'ok' flag is still present in the internal
-methods. This will change in the future.
-
-
-==================================================
-Assumptions
-==================================================
-
-The handling of assumptions and the 'root_level' is a bit clumsy.  We
-will probably change so that the conflict driven backtracking can undo
-beyond the 'root_level', and then let the assumptions be
-remade. Currently we have to put in a hack to assure unit clauses have
-a 'level' of zero, or else the 'analyzeFinal()' method will not work
-properly. These unit clauses will also be forgotten before the next
-incremental SAT, which is also undesirable (but doesn't seem to
-degrade performance).
-
-
-==================================================
-Floating points
-==================================================
-
-The IEEE standard allows, in principle, floating points to behave
-identical on different systems. However, the FPU can be set in different
-modes, and Linux defaults to 80 bits mantissa, while most other systems,
-including Free BSD, defaults to 64 bits. The latter is preferd, as 
-the 80 bit precision in Linux is only preserved as long as the 'double'
-is kept in a register (which depends on the C-compiler -- you have 
-no control). With proper #ifdef's for differnt systems, the FPU can
-be put into the right mode.
-
-Of course it doesn't affect the efficiency of the solver, but since we
-use floats in our activity heuristic, eventually the same solver can
-behave different on different systems. The most stop-gap incarnation
-of this is a statically linked Linux binary, which when ran on
-identical hardware but under FreeBSD, can produce different behavior.
-
-
-==================================================
-Proof logging (for the '1.14p' version)
-==================================================
-
-Proof logging is still missing the implementation of the 'compress()'
-method, that will pull out the "proof" from the "trace", i.e. remove
-the derivation of clauses that did not participate in the final
-conflict (deriving the empty clause).  It's just work, and it will
-happen, but currently you can only traverse the whole trace (which is
-still very useful).
-
-
-==================================================
-Conflict clause minimization & 'trail_pos[]'
-==================================================
-
-In proof logging mode, the order of literals in 'trail[]' (the
-assignment stack) must be recorded to do the logging correctly for
-conflict clause minimization. However, this position could actually,
-with some modification, replace the 'level[]' vector all together. It
-makes a lot of sense to do this, but for the time being we record
-both. This will change in the future.

data/minisat/MiniSat_v1.14/VarOrder.h

@@ -1,96 +0,0 @@
-/**************************************************************************************[VarOrder.h]
-MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-
-#ifndef VarOrder_h
-#define VarOrder_h
-
-#include "SolverTypes.h"
-#include "Heap.h"
-
-
-//=================================================================================================
-
-
-struct VarOrder_lt {
-    const vec<double>&  activity;
-    bool operator () (Var x, Var y) { return activity[x] > activity[y]; }
-    VarOrder_lt(const vec<double>&  act) : activity(act) { }
-};
-
-class VarOrder {
-    const vec<char>&    assigns;     // var->val. Pointer to external assignment table.
-    const vec<double>&  activity;    // var->act. Pointer to external activity table.
-    Heap<VarOrder_lt>   heap;
-    double              random_seed; // For the internal random number generator
-
-public:
-    VarOrder(const vec<char>& ass, const vec<double>& act) :
-        assigns(ass), activity(act), heap(VarOrder_lt(act)), random_seed(91648253)
-        { }
-
-    inline void newVar(void);
-    inline void update(Var x);                  // Called when variable increased in activity.
-    inline void undo(Var x);                    // Called when variable is unassigned and may be selected again.
-    inline Var  select(double random_freq =.0); // Selects a new, unassigned variable (or 'var_Undef' if none exists).
-};
-
-
-void VarOrder::newVar(void)
-{
-    heap.setBounds(assigns.size());
-    heap.insert(assigns.size()-1);
-}
-
-
-void VarOrder::update(Var x)
-{
-    if (heap.inHeap(x))
-        heap.increase(x);
-}
-
-
-void VarOrder::undo(Var x)
-{
-    if (!heap.inHeap(x))
-        heap.insert(x);
-}
-
-
-Var VarOrder::select(double random_var_freq)
-{
-    // Random decision:
-    if (drand(random_seed) < random_var_freq && !heap.empty()){
-        Var next = irand(random_seed,assigns.size());
-        if (toLbool(assigns[next]) == l_Undef)
-            return next;
-    }
-
-    // Activity based decision:
-    while (!heap.empty()){
-        Var next = heap.getmin();
-        if (toLbool(assigns[next]) == l_Undef)
-            return next;
-    }
-
-    return var_Undef;
-}
-
-
-//=================================================================================================
-#endif