ruby-minisat 1.14.2

data/minisat/MiniSat_v1.14/TODO

@@ -0,0 +1,73 @@
+==================================================
+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

@@ -0,0 +1,96 @@
+/**************************************************************************************[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

data/test/test_minisat.rb

@@ -0,0 +1,143 @@
+require "test/unit"
+require "rubygems"
+require "minisat"
+
+class TestMiniSat < Test::Unit::TestCase
+  def setup
+    @solver = MiniSat::Solver.new
+  end
+
+  def test_variable_pos
+    var = @solver.new_var
+    assert_nothing_raised { +var }
+  end
+
+  def test_variable_neg
+    var = @solver.new_var
+    assert_nothing_raised { -var }
+  end
+
+  def test_variable_value
+    var1 = @solver.new_var
+    var2 = @solver.new_var
+    assert_raise(RuntimeError) { var1.value }
+    @solver << var1 << -var2
+    @solver.solve
+    assert_equal(true , var1.value)
+    assert_equal(false, var2.value)
+  end
+
+  def test_solver_add_clause
+    var1 = @solver.new_var
+    var2 = @solver.new_var
+    @solver.add_clause(-var1, -var2)
+    @solver.add_clause(var1)
+    @solver.solve
+    assert_equal(true , var1.value)
+    assert_equal(false, var2.value)
+  end
+
+  def test_solver_add_clause_2
+    var1 = @solver.new_var
+    var2 = @solver.new_var
+    @solver << [-var1, -var2] << var1
+    @solver.solve
+    assert_equal(true , var1.value)
+    assert_equal(false, var2.value)
+  end
+
+  def test_solver_result
+    var1 = @solver.new_var
+    var2 = @solver.new_var
+    @solver << [-var1, -var2] << var1
+    @solver.solve
+    assert_equal(@solver[var1], var1.value)
+    assert_equal(@solver[var2], var2.value)
+  end
+
+  def test_solver_clause_size
+    var1 = @solver.new_var
+    var2 = @solver.new_var
+    assert_equal(0, @solver.clause_size)
+    @solver << [-var1, -var2]
+    assert_equal(1, @solver.clause_size)
+    @solver << var1
+    assert_equal(2, @solver.clause_size)
+  end
+
+  def test_solver_satisfied?
+    assert_equal(false, @solver.satisfied?)
+    var = @solver.new_var
+    @solver << var
+    @solver.solve
+    assert_equal(true, @solver.satisfied?)
+    @solver << -var
+    @solver.solve
+    assert_equal(false, @solver.satisfied?)
+  end
+
+  def test_solver_simplify_db
+    @solver.solve
+    assert_nothing_raised { @solver.simplify_db }
+  end
+
+  def test_solver_solve
+    var1 = @solver.new_var
+    var2 = @solver.new_var
+    @solver << [var1, var2]
+    assert_equal(false, @solver.solve(-var1, -var2))
+    assert_equal(true , @solver.solve(-var1))
+    assert_equal(false, var1.value)
+    assert_equal(true , var2.value)
+  end
+
+  def test_solver_solved?
+    assert_equal(false, @solver.solved?)
+    var = @solver.new_var
+    @solver << var
+    @solver.solve
+    assert_equal(true, @solver.solved?)
+    @solver << -var
+    @solver.solve
+    assert_equal(true, @solver.solved?)
+  end
+
+  def test_var_size
+    assert_equal(0, @solver.var_size)
+    var1 = @solver.new_var
+    assert_equal(1, @solver.var_size)
+    var2 = @solver.new_var
+    assert_equal(2, @solver.var_size)
+  end
+
+  def test_senario1
+    a = @solver.new_var
+    b = @solver.new_var
+    
+    @solver << [a, b] << [-a, b] << [a, -b]
+    
+    assert_equal(true, @solver.solve)
+    assert_equal(true, @solver[a])
+    assert_equal(true, @solver[b])
+  end
+
+  def test_senario2
+    a = @solver.new_var
+    b = @solver.new_var
+    
+    @solver << [-a, -b] << [-a, b] << [a, -b]
+    
+    assert_equal(true, @solver.solve)
+    assert_equal(false, @solver[a])
+    assert_equal(false, @solver[b])
+  end
+
+  def test_senario3
+    a = @solver.new_var
+    b = @solver.new_var
+    
+    @solver << [a, b] << [-a, b] << [a, -b] << [-a, -b]
+    
+    assert_equal(false, @solver.solve)
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-minisat
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 14
+  - 2
+  version: 1.14.2
+platform: ruby
+authors: 
+- Yusuke Endoh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-07 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: ruby binding for MiniSat, which is an open-source SAT solver
+email: mame@tsg.ne.jp
+executables: []
+
+extensions: 
+- ext/minisat/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/compat18.rb
+- examples/example.rb
+- examples/example2.rb
+- examples/kakuro.rb
+- examples/kakuro.sample
+- examples/lonely7.rb
+- examples/nonogram.rb
+- examples/nonogram.sample
+- examples/numberlink.rb
+- examples/numberlink.sample
+- examples/shikaku.rb
+- examples/shikaku.sample
+- examples/slitherlink.rb
+- examples/slitherlink.sample
+- examples/sudoku.rb
+- examples/sudoku.sample
+- ext/minisat/extconf.rb
+- ext/minisat/minisat-wrap.cpp
+- ext/minisat/minisat.c
+- ext/minisat/minisat.h
+- minisat/MiniSat_v1.14.2006-Aug-29.src.zip
+- minisat/MiniSat_v1.14/Global.h
+- minisat/MiniSat_v1.14/Heap.h
+- minisat/MiniSat_v1.14/LICENSE
+- minisat/MiniSat_v1.14/Main.C
+- minisat/MiniSat_v1.14/Makefile
+- minisat/MiniSat_v1.14/README
+- minisat/MiniSat_v1.14/Solver.C
+- minisat/MiniSat_v1.14/Solver.h
+- minisat/MiniSat_v1.14/Solver.o
+- minisat/MiniSat_v1.14/SolverTypes.h
+- minisat/MiniSat_v1.14/Sort.h
+- minisat/MiniSat_v1.14/TODO
+- minisat/MiniSat_v1.14/VarOrder.h
+- test/test_minisat.rb
+has_rdoc: true
+homepage: http://github.com/mame/ruby-minisat
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ruby binding for MiniSat, which is an open-source SAT solver
+test_files: 
+- test/test_minisat.rb
+- examples/compat18.rb
+- examples/shikaku.rb
+- examples/kakuro.rb
+- examples/example2.rb
+- examples/example.rb
+- examples/numberlink.rb
+- examples/lonely7.rb
+- examples/slitherlink.rb
+- examples/sudoku.rb
+- examples/nonogram.rb