wongi-engine 0.0.1

data/examples/graphviz.rb

@@ -0,0 +1,15 @@
+require 'wongi-engine'
+
+include Wongi::Engine
+
+ds = Network.new
+ds << rule('demo') {
+  forall {
+    has 1, 2, 3
+    maybe 4, 5, 6
+  }
+}
+
+File.open "rete.dot", "w" do |io|
+  Graph.new( ds ).dot( io )
+end

data/examples/timeline.rb

@@ -0,0 +1,48 @@
+require 'wongi-engine'
+
+def sep
+  puts "---------------------------"
+end
+
+engine = Wongi::Engine.create
+
+engine.debug!
+
+engine.compile_alpha Wongi::Engine::Template.new( :_, :_, :_,  0 )
+engine.compile_alpha Wongi::Engine::Template.new( :_, :_, :_, -1 )
+engine.compile_alpha Wongi::Engine::Template.new( :_, :_, :_, -2 )
+engine.compile_alpha Wongi::Engine::Template.new( :_, :_, :_, -3 )
+engine.compile_alpha Wongi::Engine::Template.new( :_, :_, :_, -4 )
+engine.compile_alpha Wongi::Engine::Template.new( :_, :_, :_, -5 )
+
+engine.full_wme_dump
+
+sep
+
+engine << [1, 1, 1]
+engine.full_wme_dump
+engine.snapshot!
+
+sep
+
+engine << [2, 2, 2]
+engine.full_wme_dump
+engine.snapshot!
+
+sep
+
+engine << [3, 3, 3]
+engine.full_wme_dump
+engine.snapshot!
+
+sep
+
+engine << [4, 4, 4]
+engine.full_wme_dump
+engine.snapshot!
+
+sep
+
+engine << [5, 5, 5]
+engine.full_wme_dump
+engine.snapshot!

data/lib/wongi-engine.rb

@@ -0,0 +1,22 @@
+module Wongi
+  module Engine
+    
+    def self.create
+      Network.new
+    end
+
+  end
+end
+
+require 'wongi-engine/version'
+require 'wongi-engine/core_ext'
+require 'wongi-engine/template'
+require 'wongi-engine/wme'
+require 'wongi-engine/wme_match_data'
+require 'wongi-engine/token'
+require 'wongi-engine/alpha_memory'
+require 'wongi-engine/beta'
+require 'wongi-engine/dsl'
+require 'wongi-engine/ruleset'
+require 'wongi-engine/network'
+require 'wongi-engine/graph'

data/lib/wongi-engine/alpha_memory.rb

@@ -0,0 +1,46 @@
+module Wongi::Engine
+
+  class AlphaMemory
+
+    attr_reader :betas, :template, :rete, :wmes
+
+    def initialize template, rete = nil
+      @template = template
+      @rete = rete
+      @betas = []
+      @wmes = []
+      @frozen = false
+    end
+
+    def activate wme
+      betas.each do |beta|
+        beta.right_activate wme
+      end
+      @wmes << wme
+      wme.alphas << self
+    end
+
+    def remove wme
+      @wmes.delete wme
+      # we don't need to unlink ourselves from the wme
+      # because this is only called from WME#destroy
+      # so the wme will take care of it itself
+    end
+
+    def snapshot! alpha
+      alpha.wmes.map( &:dup ).each do |wme|
+        activate wme
+      end
+    end
+
+    def inspect
+      "<Alpha #{__id__} template=#{template} wmes=#{wmes}>"
+    end
+
+    def to_s
+      inspect
+    end
+
+  end
+
+end

data/lib/wongi-engine/beta.rb

@@ -0,0 +1,10 @@
+require 'wongi-engine/beta/beta_node'
+require 'wongi-engine/beta/beta_memory'
+require 'wongi-engine/beta/filter_node'
+require 'wongi-engine/beta/join_node'
+require 'wongi-engine/beta/ncc_partner'
+require 'wongi-engine/beta/ncc_node'
+require 'wongi-engine/beta/neg_node'
+require 'wongi-engine/beta/optional_node'
+require 'wongi-engine/beta/or_node'
+require 'wongi-engine/beta/production_node'

data/lib/wongi-engine/beta/beta_memory.rb

@@ -0,0 +1,48 @@
+module Wongi::Engine
+
+  class BetaMemory < BetaNode
+    attr_reader :tokens, :last_token
+
+    def initialize parent
+      super
+      @tokens = []
+    end
+
+    def seed assignments = {}
+      t = Token.new( nil, nil, assignments )
+      t.node = self
+      @tokens << t
+    end
+
+    def subst valuations
+      token = @tokens.first
+      token.delete true
+      valuations.each { |variable, value| token.subst variable, value }
+      self.children.each do |child|
+        child.left_activate token
+      end
+    end
+
+    def left_activate token, wme, assignments
+      # puts "MEMORY #{@id} left-activated with #{wme}"
+      t = Token.new( token, wme, assignments)
+      t.node = self
+      @last_token = t
+      @tokens << t
+      self.children.each do |child|
+        if child.kind_of? BetaMemory
+          child.left_activate t, nil, {}
+        else
+          child.left_activate t
+        end
+      end
+    end
+
+    # => TODO: investigate if we really need this
+    #def beta_memory
+    #  self
+    #end
+
+  end
+
+end

data/lib/wongi-engine/beta/beta_node.rb

@@ -0,0 +1,164 @@
+module Wongi::Engine
+
+  class BetaNode
+
+    include CoreExt
+
+    attr_writer :rete
+    attr_reader :parent
+    attr_accessor :children
+    attr_predicate :debug
+
+    def initialize parent = nil
+      @parent = parent
+      @children = []
+      if parent
+        parent.children << self
+      end
+    end
+
+    def depth
+      @depth ||= if parent.nil?
+        0
+      else
+        parent.depth + 1
+      end
+    end
+
+
+    def rete
+      if parent
+        parent.rete
+      else
+        @rete
+      end
+    end
+
+    def beta_memory
+      return self if BetaMemory === self # the easiest way to do this at the top
+      beta = children.find { |node| BetaMemory === node }
+      if beta.nil?
+        beta = BetaMemory.new self
+        beta.update_above
+      end
+      beta
+    end
+
+    def join_node alpha, tests, assignment, alpha_deaf
+      existing = children.find{ |node| JoinNode === node && node.equivalent?( alpha, tests, assignment ) }
+      return existing if existing
+
+      node = JoinNode.new self, tests, assignment
+      node.alpha = alpha
+      alpha.betas << node unless alpha_deaf
+
+      node
+    end
+
+    def optional_node alpha, tests, assignment, alpha_deaf
+      node = OptionalNode.new self, tests, assignment
+      node.alpha = alpha
+      alpha.betas << node unless alpha_deaf
+      node
+    end
+
+    def filter_node test
+      existing = children.find{ |node| FilterNode === node && node.equivalent?( test ) }
+      return existing if existing
+
+      node = FilterNode.new self, test
+      node.update_above
+      node
+    end
+
+    def neg_node alpha, tests, alpha_deaf
+      node = NegNode.new self, tests, alpha
+      alpha.betas << node unless alpha_deaf
+      node.update_above
+      node
+    end
+
+    def ncc_node condition, earlier, parameters, alpha_deaf
+      bottom = network condition.children, earlier, parameters, alpha_deaf
+      self.children.each do |node|
+        if node.kind_of?( NccNode ) and node.partner.parent == bottom
+          return node
+        end
+      end
+      ncc = NccNode.new self
+      partner = NccPartner.new bottom.beta_memory
+      ncc.partner = partner
+      partner.ncc = ncc
+      partner.divergent = self
+      #    partner.conjuncts = condition.children.size
+      ncc.update_above
+      partner.update_above
+      ncc
+    end
+
+    CompilationContext = Struct.new :node, :rete, :earlier, :parameters, :alpha_deaf
+    def network conditions, earlier, parameters, alpha_deaf
+      # puts "Getting beta subnetwork"
+      conditions.inject(CompilationContext.new self, self.rete, earlier, parameters, alpha_deaf) do |context, condition|
+        condition.compile context
+      end.node
+    end
+
+    def update_above
+      update_from self.parent
+    end
+
+    private
+
+    def propagate_activation token, wme, assignments
+      self.children.each do |child|
+        child.left_activate token, wme, assignments
+      end
+    end
+
+    def update_from parent
+      case parent
+
+      when BetaMemory
+        parent.tokens.each do |token|
+          self.left_activate token, nil, {}
+        end
+
+      when JoinNode, OptionalNode
+        tmp = parent.children
+        parent.children = [ self ]
+        parent.alpha.wmes.each do |wme|
+          parent.right_activate wme
+        end
+        parent.children = tmp
+
+      when FilterNode
+        tmp = parent.children
+        parent.children = [ self ]
+        parent.parent.tokens.each do |token|
+          parent.left_activate token
+        end
+        parent.children = tmp
+
+      when NegNode
+        parent.tokens.each do |token|
+          if token.neg_join_results.empty?
+            left_activate token, nil, {}
+          end
+        end
+        parent.alpha.wmes.each do |wme|
+          parent.right_activate wme
+        end
+
+      when NccNode
+        parent.tokens.each do |token|
+          if token.ncc_results.empty?
+            left_activate token, nil, {}
+          end
+        end
+
+      end # => case
+    end
+  end
+
+end

data/lib/wongi-engine/beta/filter_node.rb

@@ -0,0 +1,109 @@
+module Wongi
+  module Engine
+
+
+    class FilterTest
+
+      def passes? token
+        true
+      end
+
+      def compile context
+        context.node = context.node.beta_memory.filter_node( self )
+        context.earlier << self
+        context
+      end
+
+      def == other
+        self.class == other.class
+      end
+
+    end
+
+    class EqualityTest < FilterTest
+
+      attr_reader :x, :y
+
+      def initialize x, y
+        @x, @y = x, y
+      end
+
+      def passes? token
+
+        x = if Template.variable? @x
+          token[@x]
+        else
+          @x
+        end
+
+        y = if Template.variable? @y
+          token[@y]
+        else
+          @y
+        end
+
+        return false if x == :_ || y == :_
+        return x == y
+
+      end
+
+      def == other
+        super && x == other.x && y == other.y
+      end
+      
+    end
+
+    class InequalityTest < FilterTest
+
+      attr_reader :x, :y
+
+      def initialize x, y
+        @x, @y = x, y
+      end
+
+      def passes? token
+
+        x = if Template.variable? @x
+          token[@x]
+        else
+          @x
+        end
+
+        y = if Template.variable? @y
+          token[@y]
+        else
+          @y
+        end
+
+        return false if x == :_ || y == :_
+        return x != y
+
+      end
+
+      def == other
+        super && x == other.x && y == other.y
+      end
+
+    end
+
+    class FilterNode < BetaNode
+
+      attr_accessor :test
+
+      def initialize parent, test
+        super parent
+        self.test = test
+      end
+
+      def left_activate token
+        if test.passes? token
+          propagate_activation token, nil, {}
+        end
+      end
+
+      def equivalent? test
+        test == self.test
+      end
+    end
+  end
+end