lib/magic_logic.rb in magic_logic-0.0.1 vs lib/magic_logic.rb in magic_logic-0.0.2

@@ -1,37 +1,37 @@
 require "magic_logic/version"
 
 module MagicLogic
   module Operator
-    def ~@
-      if    is_neg?  then p
-      elsif is_form? then vars.map(&:~).inject(reope)
-      else                NEG.new(self)
-      end
+    def _ ope, l, r
+      ope == :+ ? l : r
     end
 
-    def *(q)
-      case q
-      when Taut  then self
-      when UTaut then $utout
-      when self  then self
-      else
-        if neg?(q) then $utout
-        else            FORM.new([self, q], :*)
+    [:+, :*].each do |ope|
+      define_method(ope) do |q|
+        case q
+        when Taut  then _ ope, $tout, self
+        when UTaut then _ ope, self, $utout
+        when self  then self
+        else
+          if neg?(q)
+            (_ ope, $tout, $utout)
+          elsif is_form?(ope.to_sym) && include?(q)
+            self
+          elsif q.is_form?(ope) && q.include?(self)
+            q
+          else
+            FORM.new([self, q], ope)
+          end
         end
       end
     end
 
-    def +(q)
-      case q
-      when Taut  then $tout
-      when UTaut then self
-      when self  then self
-      else
-        if neg?(q) then $tout
-        else            FORM.new([self, q], :+)
-        end
+    def ~@
+      if    is_neg?  then p
+      elsif is_form? then vars.map(&:~).inject(_ ope, :*, :+)
+      else                NEG.new(self)
       end
     end
 
     def >=(q)
       (~self + q)
@@ -50,11 +50,11 @@
     def is_neg?
       is_a?(NEG)
     end
 
     def is_form?(ope=nil)
-      return is_a?(FORM) && @ope == ope if ope
+      return is_a?(FORM) && self.ope == ope if ope
       is_a?(FORM)
     end
 
     def is_or?
       is_form?(:+)
@@ -66,12 +66,12 @@
 
     def include?(p)
       false
     end
 
-    def dpll!
-      !!!!!!!!!!!!self
+    def dpll
+      !!!!!!!!!!!!!!!!!!self
     end
   end
 
   module Base; include Operator; include Utils end
 
@@ -97,31 +97,35 @@
   end
   $utout = UTaut.new
 
   class Atom < Struct.new(:p)
     include Base
-    def to_s;          p.to_s      end
-    def !@;            self        end
-    def depth;         1           end
+    def to_s;  p.to_s end
+    def !@;    self   end
+    def depth; 1      end
+
+    class << self
+      alias [] new
+    end
   end
+  P = Atom
 
   class NEG < Struct.new(:p)
     include Base
-    def to_s;          "~#{p}"      end
-    def !@;             ~(!p)       end
-    def depth;          p.depth+1   end
+    def to_s;  "~#{p}"    end
+    def !@;     ~(!p)     end
+    def depth;  p.depth+1 end
   end
 
-  class FORM
+  class FORM < Struct.new(:vars, :ope)
     include Base
-    attr_reader :vars, :ope
     def initialize(vars, ope)
-      @vars = vars.map { |var| var.is_form?(ope) ? var.vars : var }.flatten
-      @ope = ope
+      self.vars = vars.map { |var| var.is_form?(ope) ? var.vars : var }.flatten
+      self.ope = ope
     end
 
-    def to_s; "(#{vars.map(&:to_s).join(loope)})" end
+    def to_s; "(#{vars.map(&:to_s).join(_ ope, '|', '&')})" end
 
     def !@
       if is_or? && (and_form = vars.find { |var| var.is_and? })
         and_form.vars.map { |a| a + FORM.new((vars - [and_form]), :+) }.inject(:*)
       elsif are_there_neg?
@@ -135,23 +139,21 @@
 
     def include?(p)
       vars.include?(p)
     end
 
-    def loope
-      ope == :* ? '&' : '|'
-    end
-
-    def reope
-      is_and? ? :+ : :*
-    end
-
     private
       def are_there_neg?
         pvars = vars.reject { |var| var.is_neg? }
         nvars = vars.select { |var| var.is_neg? }
         pvars.any? { |pvar|
           nvars.any? { |nvar| nvar.neg?(pvar) }
         }
       end
+  end
+
+  class ::Array
+    def >>(con)
+      inject($tout) { |s, p| s * p } >= con
+    end
   end
 end