rwdeliza 0.03

data/lib/linkparser.rb

@@ -0,0 +1,461 @@
+#!/usr/bin/ruby
+#
+#	Ruby-LinkParser - a english grammar parser based on the link-grammar idea
+#
+# == Synopsis
+#
+#   require "linkparser"
+#
+#   dict_opts = Hash.new('')
+#   dict_opts[dict] = 'tiny.dict'
+#   dict_opts[datadir] = nil
+#   parse_opts = Hash.new
+#   parser = LinkParser::new(dict_opts, parse_opts)
+#   
+#   sentence = parser.parse($stdin.getline)
+#   puts sentence.diagram
+#
+# == Rcsid
+# 
+# $Id: linkparser.rb,v 1.22 2003/08/28 04:49:33 stillflame Exp $
+# 
+# == Authors
+# 
+#   Martin Chase <stillflame@FaerieMUD.org>
+# 
+#:include: COPYRIGHT
+#
+#---
+#
+# Please see the file COPYRIGHT for licensing details.
+#
+
+
+require "linkparser/dictionary"
+require "linkparser/definition"
+require "linkparser/sentence"
+require "linkparser/linkage"
+require "linkparser/utils"
+require "linkparser/word"
+# require "linkparser/log"
+
+
+### The main class for the link parser system.  An object of this class contains
+### the dictionaries being used and has all the functional methods to parse
+### sentences.
+class LinkParser
+
+	### The errors thrown during the parse of a sentence.
+    class ParseError < Exception; end
+
+	### Struct to contain the elements of the parse.
+	ParseState = Struct::new("ParseState", *(
+					%w{sentence results right inner left right_set inner_set
+						left_set right_conn inner_conn left_conn right_word
+						inner_word left_word connection mode all_connectors}
+					))
+	LEFT_MODE = 1
+	RIGHT_MODE = 2
+	INNER_MODE = 4
+	OUTER_MODE = 8
+	FORCE_MODE = 16
+	UNSATISFIED = nil
+
+
+    # Initializes a new parser, using the option hashes given
+    def initialize( dict_opts, parse_opts )
+		@dictionary = LinkParser::Dictionary::new(dict_opts)
+		@parseOptions = parse_opts
+    end
+
+    # Takes a string and tries to parse it into a Sentence object
+	def parse( string )
+		raise ParseError.new("Unable to parse nothing.") unless
+			string && !string.empty?
+		words = string.split
+		
+		words = @dictionary.affix(words)
+		
+		# Create LinkParser::Word objects out of the words and their definitions
+		sentence = Sentence::new
+# 		if @dictionary.has_key?('LEFT-WALL')
+# 			sentence.definitions << @dictionary['LEFT-WALL']
+# 			sentence.names << 'LEFT-WALL'
+# 		end
+		words.each {|word|
+			# :!: This should be doing something to incorporate all the different "word.*"'s :!:
+ 			#if(found = @dictionary.dict.find {|w,d| %r$#{word}(\.\w)?$.match(w)})
+			#	sentence.definitions << found[1]
+			if @dictionary.has_key?(word)
+				sentence.definitions << @dictionary[word]
+				sentence.names << word
+			else
+#				raise ParseError::new("The word '#{word}' is not in the dictionary.")
+			sentence.definitions << @dictionary["UNKNOWN"]
+				sentence.names << "UNKNOWN"
+    end
+		}
+# 		if @dictionary.has_key?('RIGHT-WALL')
+# 			sentence.definitions << @dictionary['RIGHT-WALL']
+# 			sentence.names << 'RIGHT-WALL'
+# 		end
+		
+		# Find the linkages
+		sentence.linkages = find_linkages(sentence)
+		
+		return sentence
+    end
+
+	### Finds all valid linkages in the sentence
+	def find_linkages(sentence)
+		# Log.debug( "find_linkages start" )
+		ps = ParseState::new
+		ps.sentence = sentence
+		# :MC: To be used for pruning, but not until profiling/benchmarking is
+		# done.  The idea will be to check each <side>_conn to see if it has any
+		# chance of connecting, and if not, skipping the entire set.
+		ps.all_connectors = make_connector_hash(ps.sentence)
+		# Log.debug( "Connector hash created => #{ps.all_connectors.inspect}" )
+		ps.results = []
+		ps.left = 0
+		ps.right = sentence.definitions.length - 1
+		satisfied = false
+		for ps.right_set in ps.sentence.definitions[ps.right].connector_sets do
+			next unless ps.right_set.right.all_pass?(:optional?)
+			# :MC: For pruning.
+			next if ps.right_set.find {|c| (! c.optional?) and (ps.all_connectors[c].empty? or c.cost > 0)}
+			for ps.left_set in ps.sentence.definitions[ps.left].connector_sets do
+				next unless ps.left_set.left.all_pass?(:optional?)
+				# :MC: For pruning.
+				next if ps.left_set.find {|c| (! c.optional?) and (ps.all_connectors[c].empty? or c.cost > 0)}
+				matched = false
+				for ps.right_conn in ps.right_set.left do
+					for ps.left_conn in ps.left_set.right do
+						if ps.left_conn.match(ps.right_conn)
+							matched = true
+							ps.mode = OUTER_MODE
+							flag = add_connection(ps)
+							satisfaction = true unless flag == UNSATISFIED
+						end
+					end
+				end
+				unless matched
+					ps.right_conn = ps.left_conn = nil
+					ps.mode = OUTER_MODE | FORCE_MODE
+					flag = add_connection(ps)
+					satisfaction = true unless flag == UNSATISFIED
+				end
+			end
+		end
+		ps.results = ps.results.find_all {|linkage|
+			linkage.valid? && linkage.connected?
+		}
+		ps.results.uniq!
+		if satisfaction
+			# Log.debug( "find_linkages finished - %d results" % ps.results.length )
+		else
+			# Log.debug( "find_linkages finished - unsatisfied" )
+		end
+		return ps.results
+	end
+
+
+	### Recursive body of the find_linkages method.  See presentation for a
+	### general algorithm explaination.
+	def re_find_linkages(ps)
+		# Log.debug("re_find_linkages(%d, %d) start - (%s, %s)" % [
+		#			  ps.left, ps.right, ps.left_set.right, ps.right_set.left])
+		# test for stopping recursion.
+		if(ps.left == (ps.right - 1))
+			if( ! (ps.left_set.right.all_pass?(:optional?) and
+				   ps.right_set.left.all_pass?(:optional?)) )
+				return UNSATISFIED
+			else
+				return []
+			end
+		end
+		results = []
+		ps.right_conn = ps.left_conn = ps.inner_conn = nil
+		satisfied = false
+		for ps.inner in (ps.left+1)..(ps.right-1) do
+			for ps.inner_set in ps.sentence.definitions[ps.inner].connector_sets do
+				# :MC: For pruning.
+				next if ps.inner_set.find {|c| (! c.optional?) and (ps.all_connectors[c].empty? or c.cost > 0)}
+				for ps.inner_conn in ps.inner_set.left do
+					for ps.left_conn in ps.left_set.right do
+						if ps.inner_conn.match(ps.left_conn)
+							# Log.debug( "(left)Connecting %s and %s" % [ps.left_conn, ps.inner_conn])
+							ps.mode = LEFT_MODE | INNER_MODE
+							# in the following call to add_connection, ps is
+							# modified to include all the valid partial linkages
+							# on this particular connection made using one of
+							# the inner word's connectors on the left side.
+							satisfied = true unless add_connection(ps) == UNSATISFIED
+						end
+					end
+				end
+				lefties = ps.results
+				# check for needed recursion.
+				if( lefties.empty? and (ps.inner != ps.left + 1) and
+				   ( ! (ps.left_set.right.all_pass?(:optional?) and
+						ps.inner_set.left.all_pass?(:optional?) ) ) )
+					ps.mode = LEFT_MODE | INNER_MODE | FORCE_MODE
+					lefties = add_connection(ps)
+				end
+				ps.results = []
+				ps.left_conn = nil
+				for ps.inner_conn in ps.inner_set.right do
+					for ps.right_conn in ps.right_set.left do
+						if ps.inner_conn.match(ps.right_conn)
+							# Log.debug( "(right)Connecting %s and %s" % [ps.inner_conn, ps.right_conn] )
+							ps.mode = RIGHT_MODE | INNER_MODE
+							# add_conneciton here makes ps.results include all
+							# valid partial linkages between the inner word and
+							# the right side word.
+							satisfied = true unless add_connection(ps) == UNSATISFIED
+						end
+					end
+				end
+				righties = ps.results
+				# check for needed recursion.
+				if( righties.empty? and (ps.inner != ps.right - 1) and
+				   ( ! (ps.inner_set.right.all_pass?(:optional?) and
+						ps.right_set.left.all_pass?(:optional?)) ) )
+					ps.mode = RIGHT_MODE | INNER_MODE | FORCE_MODE
+					righties = add_connection(ps)
+				end
+				ps.results = []
+				unless( (lefties == UNSATISFIED) or (righties == UNSATISFIED) )
+					results += lefties.set_combine(righties)
+				end
+			end
+		end
+		return UNSATISFIED unless satisfied
+		return ps.results = results
+	end
+
+	### With a connection having been found between two words, or assumed to be
+	### so, create it if possible, recurse where needed, and combine it all into
+	### the results.  The "force" modes are where no actual connection has been
+	### made, but recursion is still needed to connect the words inbetween the
+	### inner word under consideration and both edge words.
+	def add_connection(ps)
+		if (ps.mode & INNER_MODE).nonzero?
+			if (ps.mode & FORCE_MODE).nonzero?
+				r = inner_force_recursion(ps)
+				# Log.debug( "inner_force_recursion finished" )
+				r
+			else
+				r = inner_add_connection(ps)
+				# Log.debug( "inner_add_connection finished" )
+				r
+			end
+		elsif (ps.mode & FORCE_MODE).nonzero?
+			r = outer_force_recursion(ps)
+			# Log.debug( "outer_force_recursion finished" )
+			r
+		else
+			r = outer_add_connection(ps)
+			# Log.debug( "outer_add_connection finished" )
+			r
+		end
+	end
+
+	### In the outer call of find_linkages, a connection has been found, so
+	### create it and recurse into the inner words.
+	def outer_add_connection(ps)
+		ps.left_word, ps.right_word, ps.connection =
+			create_connection( ps.sentence, ps.left, ps.right, ps.left_conn,
+							   ps.right_conn )
+		# Log.debug( "outer_add_connection with %s." % ps.connection )
+		new_ps = ParseState::new(*ps.to_a)
+		new_ps.update( {:results =>		[]} )
+		new_ps.update( {:left_set =>	ps.left_set - [ps.left_conn]} ) unless
+			ps.left_conn.multiple?
+		new_ps.update( {:right_set =>	ps.right_set - [ps.right_conn]} ) unless
+			ps.right_conn.multiple?
+		results = re_find_linkages(new_ps)
+		if results == UNSATISFIED
+			# Log.debug("re_find_linkages(%d, %d) end - unsatisfied" %
+			#		  [new_ps.left, new_ps.right])
+			return results
+		end
+		# Log.debug("re_find_linkages(%d, %d) end - %d results" %
+		#				[new_ps.left, new_ps.right, results.length])
+		results << Linkage::new(ps.sentence.names.map{nil}) if results.empty?
+		ps.results += results.collect {|linkage|
+			linkage.insert(ps.connection, ps.left, ps.right,
+						   ps.left_word, ps.right_word)
+		}
+	end
+
+	### In the outer call of find_linkages, no connection was found between a
+	### pair of sets, but recurse anyway into the inner words.
+	def outer_force_recursion(ps)
+		# Log.debug( "outer_force_recursion on '%s' and '%s'" %
+		#				[ps.left_set, ps.right_set] )
+		new_ps = ParseState::new(*ps.to_a)
+		new_ps.results = []
+		results = re_find_linkages(new_ps)
+		if results == UNSATISFIED
+			# Log.debug( "re_find_linkages(%d, %d) end - unsatisfied" %
+			#		   [new_ps.left, new_ps.right])
+			return results
+		end
+		# Log.debug( "re_find_linkages(%d, %d) end - %d results" %
+		#		   [new_ps.left, new_ps.right, new_ps.results.length] )
+		ps.results += results
+	end
+
+	### Inside of a recurse, pretend there is a connection between two words to
+	### find any connections that may exist to the words in between, and if
+	### those connections are enough to satisfy the conditions of connectivity
+	### and satisfaction.
+	def inner_force_recursion(ps)
+		# Log.debug( "inner_force_recursion start" )
+		new_ps = ParseState::new(*ps.to_a)
+		if (ps.mode & RIGHT_MODE).nonzero?
+			left, right = ps.inner, ps.right
+			new_ps.update({	:results =>		[],
+							:left =>		ps.inner,
+						  })
+		else # LEFT_MODE
+			left, right = ps.left, ps.inner
+			new_ps.update({	:results =>		[],
+							:right =>		ps.inner,
+						  })
+		end
+		results = re_find_linkages(new_ps)
+		if results == UNSATISFIED
+			# Log.debug( "re_find_linkages(%d, %d) end - unsatisfied" %
+			#		  [new_ps.left, new_ps.right])
+		else
+			# Log.debug("re_find_linkages(%d, %d) end - %d results" %
+			#		  [new_ps.left, new_ps.right, results.length])
+		end
+		return results
+	end
+
+	### Inside of recursion, create the connection, recurse on either side,
+	### combine the results of each.  This mostly just rearranges the parse
+	### state for the recursions to follow.
+	def inner_add_connection(ps)
+		new_ps = ParseState::new(*ps.to_a)
+		new_ps.inner_set = new_ps.inner = new_ps.inner_conn = nil
+		if (ps.mode & RIGHT_MODE).nonzero?
+			left, right, ps.left_word, ps.right_word, ps.connection =
+				ps.inner, ps.right,
+				*create_connection(ps.sentence, ps.inner, ps.right,
+								   ps.inner_conn, ps.right_conn)
+			new_ps.update({	:results =>		[],
+							:left =>		ps.inner,
+						  })
+			if ps.inner_conn.multiple?
+				new_ps.update({:left_set =>	ps.inner_set})
+			else
+				new_ps.update({:left_set =>	ps.inner_set - [ps.inner_conn]})
+			end
+			new_ps.update({:right_set =>	ps.right_set - [ps.right_conn]}) unless
+				ps.right_conn.multiple?
+		else # LEFT_MODE
+			left, right, ps.left_word, ps.right_word, ps.connection =
+				ps.left, ps.inner,
+				*create_connection(ps.sentence, ps.left, ps.inner,
+								   ps.left_conn, ps.inner_conn)
+			new_ps.update({	:results =>		[],
+							  :right =>		ps.inner,
+						  })
+			new_ps.update({:left_set =>	ps.left_set - [ps.left_conn]}) unless
+				ps.left_conn.multiple?
+			if ps.inner_conn.multiple?
+				new_ps.update({:right_set =>	ps.inner_set})
+			else
+				new_ps.update({:right_set =>	ps.inner_set - [ps.inner_conn]})
+			end
+		end
+		# Log.debug( "inner_add_connection start with %s" % ps.connection )
+		results = re_find_linkages(new_ps)
+		if results == UNSATISFIED
+			# Log.debug( "re_find_linkages(%d, %d) end - unsatisfied" %
+#					  [new_ps.left, new_ps.right])
+			return results
+		end
+		# Log.debug("re_find_linkages(%d, %d) end - %d results" %
+#				  [new_ps.left, new_ps.right, results.length])
+		results << Linkage::new(ps.sentence.names.map{nil}) if results.empty?
+		ps.results += results.collect {|linkage|
+			linkage.insert(ps.connection, left, right,
+						   ps.left_word, ps.right_word)
+		}
+	end
+
+	### Makes the Word and Connection objects out of the Sentence, indicies and
+	### Connectors.
+	def create_connection(sentence, left, right, left_conn, right_conn)
+		left_word = Word::new(sentence, left)
+		right_word = Word::new(sentence, right)
+		connection = Connection::new(left_conn, right_conn, left_word, right_word)
+		left_word.right << connection
+		right_word.left << connection
+		return [left_word, right_word, connection]
+	end
+
+	# Creates a hash of connectors to the words that have matching connectors.
+	def make_connector_hash( sentence )
+		connectors = {}
+		sentence.definitions.each {|word|
+			word.connector_sets.each {|set|
+				set.each {|connector|
+					# :TODO: add in pruning somewhere around here
+					connectors[connector] = nil
+				}
+			}
+		}
+		connectors.each {|connector,val|
+			connectors[connector] = connectors.keys.find_all {|conn| conn.match(connector)}
+		}
+		return connectors
+	end
+
+    # does post-processing of a sentence
+    def postProcess( sentence )
+		sentence #:TODO:
+    end
+
+    # the dictionary
+    attr_reader :dictionary
+
+    # the options for parsing
+    attr_reader :parseOptions
+
+
+end # class LinkParser
+
+
+if $0 == __FILE__
+	d_o = Hash::new('')
+	d_o['datadir'] = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "data")
+	d_o['dict'] = 'tiny.dict'
+	d_o['affix'] = nil
+	lp = LinkParser::new(d_o,{})
+	sent = LinkParser::Sentence.new
+	sent.names = %w{1 2 3 4}
+	first  = LinkParser::Definition.new( "A+" )
+#	second = LinkParser::Definition.new( "E+" )
+	third  = LinkParser::Definition.new( "A- & D+" )
+	forth  = LinkParser::Definition.new( "D-" )
+	sent.definitions = [first, third, forth]
+
+	sent.linkages = lp.find_linkages(sent)
+	
+	puts
+	sent.linkages.each {|link| puts link.inspect}
+  	s = lp.parse("he is a dog")
+  	s.definitions.each {|w|
+  		w.defs.compact.each {|d|
+  			puts d.to_connectors
+  		}
+  	} if false
+  	puts
+  	puts s.linkages.inspect
+end