cudd-rb 0.0.1

data/spec/cube/test_to_a012.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Cudd
+  describe Cube, 'to_a012' do
+
+    subject{ c.to_a012 }
+
+    before{ x; y; z  }
+
+    context 'on x' do
+      let(:c){ cube(x => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq([1, 2, 2])
+      end
+    end
+
+    context 'on !x' do
+      let(:c){ cube(x => false) }
+
+      it 'returns the expected bdd' do
+        subject.should eq([0, 2, 2])
+      end
+    end
+
+    context 'on x & y' do
+      let(:c){ cube(x => true, y => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq([1, 1, 2])
+      end
+    end
+
+  end
+end

data/spec/cube/test_to_bdd.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Cudd
+  describe Cube, 'to_bdd' do
+
+    subject{ c.to_bdd }
+
+    before{ x; y; z  }
+
+    context 'on an empty cube' do
+      let(:c){ cube([]) }
+
+      it "returns ONE" do
+        subject.should eq(one)
+      end
+    end
+
+    context 'on x' do
+      let(:c){ cube(x => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq(x)
+      end
+    end
+
+    context 'on !x' do
+      let(:c){ cube(x => false) }
+
+      it 'returns the expected bdd' do
+        subject.should eq(!x)
+      end
+    end
+
+    context 'on x & y' do
+      let(:c){ cube(x => true, y => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq(x & y)
+      end
+    end
+
+  end
+end

data/spec/cube/test_to_cube.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Cudd
+  describe Cube, 'to_cube' do
+
+    subject{ c.to_bdd }
+
+    before{ x; y; z  }
+
+    context 'on x & y' do
+      let(:c){ cube(x => true, y => true) }
+
+      it 'returns itself' do
+        subject.should eq(subject)
+      end
+    end
+
+  end
+end

data/spec/cube/test_to_dnf.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+module Cudd
+  describe Cube, 'to_dnf' do
+
+    subject{ c.to_dnf }
+
+    before{ x; y; z  }
+
+    context 'on singleton' do
+      let(:c){ cube(x => true) }
+
+      it 'uses default names' do
+        subject.should eq("v0")
+      end
+    end
+
+    context 'on negative singleton' do
+      let(:c){ cube(x => false) }
+
+      it 'uses default names' do
+        subject.should eq("!v0")
+      end
+    end
+
+    context 'on unnamed variables' do
+      let(:c){ cube(x => true, y => false) }
+
+      it 'uses default names' do
+        subject.should eq("v0 & !v1")
+      end
+    end
+
+    context 'on named variables' do
+      let(:u){ bdd_interface.new_var(:u) }
+      let(:v){ bdd_interface.new_var(:v) }
+      let(:c){ cube(u => true, v => false) }
+
+      it 'uses provided names' do
+        subject.should eq("u & !v")
+      end
+    end
+
+    context 'on variables that respond to to_dnf' do
+      let(:var){ Object.new }
+      let(:u){ bdd_interface.new_var(var) }
+      let(:c){ cube(u => true) }
+
+      it 'uses provided names' do
+        def var.to_dnf; "foo"; end
+        subject.should eq("foo")
+      end
+    end
+
+  end
+end

data/spec/cube/test_to_hash.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Cudd
+  describe Cube, 'to_hash' do
+
+    subject{ c.to_hash }
+
+    before{ x; y; z  }
+
+    context 'on x' do
+      let(:c){ cube(x => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq(x => true)
+      end
+    end
+
+    context 'on !x' do
+      let(:c){ cube(x => false) }
+
+      it 'returns the expected bdd' do
+        subject.should eq(x => false)
+      end
+    end
+
+    context 'on x & y' do
+      let(:c){ cube(x => true, y => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq(x => true, y => true)
+      end
+    end
+
+  end
+end

data/spec/cube/test_to_truths.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Cudd
+  describe Cube, 'to_truths' do
+
+    subject{ c.to_truths }
+
+    before{ x; y; z  }
+
+    context 'on x' do
+      let(:c){ cube(x => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq([true, nil, nil])
+      end
+    end
+
+    context 'on !x' do
+      let(:c){ cube(x => false) }
+
+      it 'returns the expected bdd' do
+        subject.should eq([false, nil, nil])
+      end
+    end
+
+    context 'on x & y' do
+      let(:c){ cube(x => true, y => true) }
+
+      it 'returns the expected bdd' do
+        subject.should eq([true, true, nil])
+      end
+    end
+
+  end
+end

data/spec/cudd/test_manager.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Cudd
+  describe ".manager" do
+
+    it 'passes the manager to the block, closes it afterwards and returns block result' do
+      manager = nil
+      result = Cudd.manager do |m|
+        manager = m
+        m.should be_a(Cudd::Manager)
+        m.should be_alive
+        m.should_not be_closed
+        12
+      end
+      result.should eq(12)
+      manager.should_not be_alive
+      manager.should be_closed
+    end
+
+    it 'returns an alive manager if no block' do
+      begin
+        manager = Cudd.manager
+        manager.should be_alive
+      ensure
+        manager.close if manager
+      end
+    end
+
+    it 'sets options correctly' do
+      Cudd.manager :maxMemory => 10 do |m|
+        m.options[:maxMemory].should eq(10)
+      end
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_and.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'and' do
+
+    subject{ bdd_interface.and(x,y) }
+
+    it_behaves_like "a BDD"
+
+    it 'is equal to (x & y)' do
+      subject.should eq(x & y)
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_bdd2cube.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Cudd
+  module Interfaces
+    describe BDD, "bdd2cube" do
+
+      before do
+        x; y; z
+      end
+
+      subject{ bdd_interface.bdd2cube(x & !y) }
+
+      it 'returns an Array' do
+        subject.should be_a(Array)
+      end
+
+      it 'encodes missing variables as well as explicit ones' do
+        subject.should eq([1, 0, 2])
+      end
+
+      it 'is available as BDD#to_cube' do
+        (x & !y).to_cube.should eq(subject)
+      end
+
+      it 'raises a NotACubeError on a BDD that is not a cube' do
+        lambda{
+          (x | y).to_cube
+        }.should raise_error(NotACubeError)
+      end
+
+    end
+  end
+end

data/spec/interfaces/bdd/test_bdd2dnf.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Cudd
+  module Interfaces
+    describe BDD, "bdd2dnf" do
+
+      before do
+        x; y; z
+      end
+
+      subject{ bdd.to_dnf }
+
+      context 'on ZERO' do
+        let(:bdd){ zero }
+        it{ should eq("false") }
+      end
+
+      context 'on ONE' do
+        let(:bdd){ one }
+        it{ should eq("true") }
+      end
+
+      context 'on an unnamed variable' do
+        let(:bdd){ x }
+        it{ should eq("v0") }
+      end
+
+      context 'on an named variable' do
+        let(:bdd){ bdd_interface.new_var(:foo) }
+        it{ should eq("foo") }
+      end
+
+      context 'on an complex formula' do
+        let(:bdd){ (x | y) & z }
+        it{ should eq("(!v0 & v1 & v2) | (v0 & v2)") }
+      end
+
+    end
+  end
+end

data/spec/interfaces/bdd/test_cofactor.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'cofactor' do
+
+    subject{ (x & y).cofactor(cube) }
+
+    context 'with x as cube' do
+      let(:cube){ x }
+
+      it_behaves_like "a BDD"
+
+      it{ should eq(y) }
+    end
+
+    context 'with !x as cube' do
+      let(:cube){ !x }
+
+      it_behaves_like "a BDD"
+
+      it{ should eq(zero) }
+    end
+
+    context 'with a {x => true} as cube' do
+      let(:cube){ { x => true } }
+
+      it_behaves_like "a BDD"
+
+      it{ should eq(y) }
+    end
+
+    context 'when it is a complex bdd' do
+      let(:cube){ x.xor(y)    }
+
+      it 'should raise a NotACubeError' do
+        pending{
+          lambda{
+            subject
+          }.should raise_error(NotACubeError)
+        }
+      end
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_cube.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module Cudd
+  module Interfaces
+    describe BDD, "cube" do
+
+      before do
+        x; y; z
+      end
+
+      subject{ cube(arg, as) }
+
+      describe "as => :012" do
+        let(:as){ :a012 }
+
+        context 'when already a cube' do
+          let(:arg){ [ 1, 0, 2 ] }
+          it { should eq([ 1, 0, 2 ]) }
+        end
+
+        context 'when an incomplete cube' do
+          let(:arg){ [ 1, 0 ] }
+          it { should eq([ 1, 0, 2 ]) }
+        end
+
+        context 'when truth values' do
+          let(:arg){ [ true, false, nil ] }
+          it { should eq([ 1, 0, 2 ]) }
+        end
+
+        context 'when an array of BDD variables' do
+          let(:arg){ [!y, x] }
+          it { should eq([ 1, 0, 2 ]) }
+        end
+
+        context 'when a Hash' do
+          let(:arg){ {x => 1, y => false} }
+          it { should eq([ 1, 0, 2 ]) }
+        end
+      end
+
+      describe 'as => :bdd' do
+        let(:as){ :bdd }
+
+        context 'when an array of BDD variables' do
+          let(:arg){ [!y, x] }
+          it { should eq(x & !y) }
+        end
+      end
+
+      describe 'as => :hash' do
+        let(:as){ :hash }
+
+        context 'when an array of BDD variables' do
+          let(:arg){ [!y, x] }
+          it { should eq(x => true, y => false) }
+        end
+      end
+
+    end
+  end
+end

data/spec/interfaces/bdd/test_cube2bdd.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Cudd
+  module Interfaces
+    describe BDD, "cube2bdd" do
+
+      before do
+        x; y; z
+      end
+
+      subject{ bdd_interface.cube2bdd([1, 0, 2]) }
+
+      it 'returns a BDD' do
+        subject.should be_a(Cudd::BDD)
+      end
+
+      it 'support 1, 0 and 2' do
+        subject.should eq(x & !y)
+      end
+
+    end
+  end
+end

data/spec/interfaces/bdd/test_each_cube.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+module Cudd
+  module Interfaces
+    describe BDD, "each_cube" do
+
+      subject{ formula.all_cubes } # formula.each_cube.to_a
+
+      before do
+        x; y; z;
+        formula.ref
+      end
+
+      after do
+        subject.each do |cube|
+          cube.should be_a(Cube)
+          formula.satisfied?(cube).should be_true
+        end
+        formula.deref if formula
+      end
+
+      context 'without a block' do
+        let(:formula){ x & y }
+
+        it 'returns an enumerator' do
+          formula.each_cube.should be_a(Enumerator)
+        end
+      end
+
+      context "on ZERO" do
+        let(:formula){ zero }
+
+        it 'yields no assignment' do
+          subject.should be_empty
+        end
+      end
+
+      context "on ONE" do
+        let(:formula){ one }
+
+        it 'yields one empty assignment' do
+          subject.should eq([cube([2,2,2])])
+        end
+      end
+
+      context "on x" do
+        let(:formula){ x }
+
+        it 'yields one assignment with x=true' do
+          subject.should eq([cube([1,2,2])])
+        end
+      end
+
+      context "on !x" do
+        let(:formula){ !x }
+
+        it 'yields one assignment with x=false' do
+          subject.should eq([cube([0,2,2])])
+        end
+      end
+
+      context 'on (x & y)' do
+        let(:formula){ x & y }
+
+        it 'returns one assignment with both x and y to true' do
+          subject.should eq([cube([1,1,2])])
+        end
+      end
+
+      context 'on (x | y)' do
+        let(:formula){ x | y }
+
+        it 'returns two assignments' do
+          subject.should eq([cube([0,1,2]), cube([1,2,2])])
+        end
+      end
+
+    end
+  end
+end 

data/spec/interfaces/bdd/test_eval.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'eval' do
+
+    subject{ bdd_interface.eval(formula, input) }
+
+    context 'on one' do
+      let(:formula){ one }
+      let(:input){ [] }
+
+      it 'is always satisfied' do
+        subject.should eq(one)
+      end
+    end
+    
+    context 'on zero' do
+      let(:formula){ zero }
+      let(:input){ [] }
+
+      it 'is never satisfied' do
+        subject.should eq(zero)
+      end
+    end
+    
+    context 'on (x & y) with satisfying input' do
+      let(:formula){ bdd_interface.and(x, y) }
+      let(:input){ [ 1, 1 ] }
+
+      it 'is satisfied' do
+        subject.should eq(one)
+      end
+    end
+
+    context 'on (x & y) with non satisfying input' do
+      let(:formula){ bdd_interface.and(x, y) }
+      let(:input){ [ 1, 0 ] }
+
+      it 'is not satisfied' do
+        subject.should eq(zero)
+      end
+    end
+
+    context 'on a non-satisfying Hash input' do
+      let(:formula){ bdd_interface.and(x, y) }
+      let(:input){ {x => 1, y => 0} }
+
+      it 'is not satisfied' do
+        subject.should eq(zero)
+      end
+    end
+
+    context 'on a satisfying Hash input' do
+      let(:formula){ bdd_interface.and(x, y) }
+      let(:input){ {x => 1, y => 1} }
+
+      it 'is satisfied' do
+        subject.should eq(one)
+      end
+    end
+
+    context 'on invalid input' do
+      let(:input){ [ ] }
+      
+      it 'complements input with missing 2' do
+        bdd_interface.eval(x, input).should eq(zero)
+        bdd_interface.eval(!x, input).should eq(one)
+      end
+    end
+
+    it 'is accessible as BDD#eval' do
+      (x & y).eval([1, 1]).should eq(one)
+      (x & y).eval([1, 0]).should eq(zero)
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_exist.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'exist' do
+
+    subject{ (x & y).exist(g) }
+
+    context 'when g is a Hash' do
+      let(:g){ {x => true} }
+
+      it_behaves_like "a BDD"
+
+      it{ should eq(y) }
+    end
+
+    context 'when g is a cube bdd' do
+      let(:g){ x }
+
+      it_behaves_like "a BDD"
+
+      it { should eq(y) }
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_forall.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'forall' do
+
+    subject{ (x | y).forall(g) }
+
+    context 'when g is a Hash' do
+      let(:g){ {x => true} }
+
+      it_behaves_like "a BDD"
+
+      it{ should eq(y) }
+    end
+
+    context 'when g is a cube bdd' do
+      let(:g){ x }
+
+      it_behaves_like "a BDD"
+
+      it { should eq(y) }
+    end
+
+  end
+end