khammurabi 0.2

data/khammurabi-0.2/lib/nist/khammurabi/ArrayAddon.rb

@@ -0,0 +1,201 @@
+require 'nist/khammurabi/FixnumAddon' 
+require 'nist/khammurabi/HashAddon'
+require 'nist/khammurabi/ObjectAddon'
+
+# This defines a few convenience methods for the Array class
+class Array 
+
+  # Used for token processing in the GraphNode tree
+  def includeID?( object )
+    self.each { |o| 
+			#print "matching #{o.object_id} with #{object.object_id}\n"
+			return true if o.equal?( object ) }
+    return false
+  end
+
+	def deleteID( object )
+		self.reject! { |o| o.equal?( object ) }
+	end
+	
+	# This tests == but irrespective of object order.. much slower than ==
+	def ===( other )
+		# test if it's a bijection
+		return false if self.size != other.size
+		retval = true
+		self.each do |element|
+			if !other.include?( element )
+				retval = false
+				break
+			end
+		end
+		retval
+	end
+	
+	def lossyConcat( other )
+		self.error( "Can only lossyConcat to an Array. This is a #{other.class}" ) if other.class != Array
+		other.each do |element|
+			if !self.includeID?( element )
+				self.push( element )
+			end
+		end
+	end
+
+	# If there was ever a slow algorithm, this is a prime candidate for king of them all.. time converges to infinity
+	# when the array size is > 7
+	def permutations
+		permsRecord = Array.new # Array( Hash( Fixnum => Fixnum ) )  (which are indices)
+		( self.size.factorial ).times do |i|
+			h = Hash.new
+			self.size.times do |i2|
+				h[ i2 ] = i2
+			end
+			permsRecord.push( h )
+		end
+		
+		perms = permutation_helper( Array.new, self, 0, permsRecord, self )
+		#print "permsRecord now: #{permsRecord[ perms.size - 1 ].join( " => ", ", " )}\n"
+		[ perms, permsRecord ]
+	end
+
+	def permutation_helper( perms, array, leftMarker, permsRecord, original )
+		# Base condition
+		return if leftMarker >= self.size
+
+		swappeds = Array.new
+		for rightMarker in leftMarker..self.size - 1
+			########### Try to perform the swap ##################################
+			swapped = array.swap( leftMarker, rightMarker )
+			swappeds.push( swapped )
+			if perms.pushUnique( swapped )
+				########### Record the swap by comparing original to swapped #######
+				original.each_index do |originalIndex|
+					originalElement = original[ originalIndex ]
+					swapped.each_index do |swappedIndex|
+						swappedElement = swapped[ swappedIndex ]
+						if swappedElement.equal?( originalElement )
+							# got a match!
+							permsRecord[ perms.size - 1 ][ originalIndex ] = swappedIndex
+							#print "permsRecord: "
+							#permsRecord.each do |permRecord|
+							#	print "#{permRecord.join( " => ", ", " )}\n"
+							#end
+						end # if swappedElement.equal? ...
+					end # swapped.each_index do |swappedIndex| ..
+				end # original.each_index do |originalIndex| ..
+			end # if perms.pushUnique( swapped ) == true
+		end # for rightMarker in leftMarker..self.size - 1
+
+		# Recurse, thanks!
+		swappeds.each { |swapped|	permutation_helper( perms, swapped, leftMarker + 1, permsRecord, original ) }
+		perms
+	end
+
+	def swap( index1, index2 )
+		other = self.clone
+		other.swap!( index1, index2 )
+	end
+
+	def swap!( index1, index2 )
+		return self if index1 >= self.size or index2 >= self.size 
+		tempIndex = self[ index2 ]
+		self[ index2 ] = self[ index1 ]
+		self[ index1 ] = tempIndex
+		self
+	end
+
+	def pushUnique( element )
+		if !self.include?( element )
+			self.push( element )
+			return true
+		end
+		return false
+	end
+	
+	def pushUniqueID( element )
+		if !self.includeID?( element )
+			self.push( element )
+			return true
+		end
+		return false
+	end
+	
+	def rejectID!( object ); self.reject! { |o| o.equal?( object ) }; end
+	def rejectID( object )
+		cologne = self.clone
+		cologne.rejectID!( object )
+		cologne
+	end
+	
+	# Should only be used for enumerable types
+	def minimum
+		stop = false
+		min = self.first
+		self.each do |object|
+			if !object.kind_of?( Fixnum )
+				stop = true
+				break
+			end
+			min = object if object < min
+		end
+		
+		return nil if stop == true
+		min
+	end
+	
+	def printList( methodName )
+		str = ""
+		self.each_index do |i|
+			object = self[ i ]
+			str = "#{str}#{object.send( methodName )}, " if i < self.size - 1
+			str = "#{str}#{object.send( methodName )}"   if i == self.size - 1
+			self.error( "Don't know what to do!" ) if i == self.size
+		end
+		str
+	end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def second; self[ 1 ]; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def third; self[ 2 ]; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def fourth; self[ 3 ]; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def fifth; self[ 4 ]; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def sixth; self[ 5 ]; end
+
+	# Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def first=(val); self[ 0 ] = val; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def second=(val); self[ 1 ] = val; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def third=(val); self[ 2 ] = val; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def fourth=(val); self[ 3 ] = val; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def fifth=(val); self[ 4 ] = val; end
+
+  # Second, third, fourth, fifth, and sixth return
+  # the second, third, fourth, fifth, and sixth elements of the array
+  def sixth=(val); self[ 5 ] = val; end
+  
+end
+

data/khammurabi-0.2/lib/nist/khammurabi/BooleanAddon.rb

@@ -0,0 +1,3 @@
+class TrueClass;  def clone; true;  end; end
+class FalseClass; def clone; false; end; end
+		

data/khammurabi-0.2/lib/nist/khammurabi/Cluster.rb

@@ -0,0 +1,128 @@
+module MK
+
+require 'nist/khammurabi/ObjectGraphWrapper'
+require 'nist/khammurabi/ObjectAddon'
+require 'nist/khammurabi/ArrayAddon'
+
+	# A group of elements (usually Tokens) that provides various group functionality
+	# including matching
+	class Cluster
+		
+		attr :elements, true # Array of Objects, most likely Token's
+		attr :clusterID, true
+		attr :name, true
+
+		def Cluster.init( elements = Array.new )
+			cluster = Cluster.new
+			cluster.elements = elements
+			cluster
+		end
+
+		def initialize
+			self.elements = Array.new
+			self
+		end
+
+		def size; elements.size; end
+		def add( elements )
+			elements = [ elements ] if elements.class != Array
+			elements.each do |element|
+				if !self.elements.includeID?( element ) and !self.isHostileTo?( element )
+					self.elements.push( element )
+					element.cluster = self
+				end
+			end
+		end
+
+		######################## Hostilities #######################################
+		def isHostileTo?( element )
+			answer = false
+			self.elements.each do |e|
+				#print "e has class: #{e.class} and responds: #{e.respond_to?(:isHostileTo)}\n"
+				if e.isHostileTo?( element )
+					answer = true
+					break
+				end
+			end
+			answer
+		end
+		def becomeHostileTo( element )
+			self.elements.each do |e|
+				e.becomeHostileTo( element ) if e.respond_to?( :becomeHostileTo )
+			end
+			if self.includeID?( element )
+				element.cluster = nil 
+				self.deleteID( element )
+			end
+		end
+		def becomeFriendlyTo( element )
+			self.elements.each do |e|
+				e.becomeFriendlyTo( element )
+			end
+		end
+		############################################################################
+
+		def delete( element )
+			if self.contain?( element ) 
+				self.elements.delete( element )
+				element.cluster = nil if element.cluster != nil
+			end			
+		end
+		
+		def deleteID( element )
+			if self.includeID?( element )
+				self.elements.rejectID!( element )
+				element.cluster = nil if element.cluster != nil
+			end
+		end
+		
+		def deleteAll
+			self.elements.clear
+		end
+		
+		def include?( element ); elements.include?( element ); end
+		
+		def contain?( element )
+			retval = false
+			self.elements.each do |e|
+				if e.equal?( element )
+					retval = true
+					break
+				end
+			end
+			retval
+		end
+		def includeID?( element ); contain?( element ); end
+		
+		def matchesWith?( element, container = nil ); self.error( "Subclass responsibility" ); end
+		def complete?; self.error( "Subclass responsibility" ); end
+		
+		def ==( otherCluster )
+			return false if !otherCluster.kind_of?( MK::Cluster )
+			equal = true
+			# make sure they are one to one
+			if self.size != otherCluster.size
+				equal = false
+			else 
+				self.elements.each do |element|
+					if !otherCluster.includeID?( element )
+						equal = false
+						break
+					end
+				end
+			end
+			equal
+		end
+		
+		def printTo( stream ); stream << "MK::Cluster with id: #{self.clusterID} and elements: #{self.elements.join( " " )}"; end # #{self.size}"; end
+		def printTo2( stream )
+			ids = Array.new
+			self.elements.each { |element| ids.push( element.tokenID ) }
+			stream << "MK::Cluster with id: #{self.clusterID} and elements: #{ids.join( " " )}"
+		end
+		def to_s; printTo( StringIO.new ).string; end
+		def to_s2; printTo2( StringIO.new ).string; end
+		def hostilities_to_s; self.error( "Subclass responsibility" ); end
+
+	end
+end

data/khammurabi-0.2/lib/nist/khammurabi/ClusterManager.rb

@@ -0,0 +1,96 @@
+module MK
+
+require 'nist/khammurabi/Cluster'
+
+  class ClusterManager
+    
+    attr :clusters, true # Array 
+    attr :name, true # String
+		attr :clusterName, true # Fixnum		
+    def initialize
+      self.clusters = Array.new
+			self.name = "ClusterManager"
+			self.clusterName = 0
+    end
+    
+    def ClusterManager.init( clusters = Array.new )
+      clusterManager = ClusterManager.new
+      clusterManager.clusters = clusters
+      clusterManager
+    end
+    
+		# call this instead of initialize
+		def createCluster( elements = Array.new, klass = Cluster )
+			# Useful in 'lossyConcat', below
+			return if klass == nil
+			elements = [ elements ] if elements.class != Array
+			cluster = klass.new
+			cluster.clusterID = cluster.name = "Cluster #{self.clusterName}"
+			self.clusterName = self.clusterName + 1
+			cluster.elements = elements
+			cluster.elements.each do |element|
+				element.cluster = cluster
+			end
+			self.clusters.push( cluster )
+			cluster
+		end
+
+		def disbandCluster( cluster, klass )
+			return if !cluster.kind_of?( MK::Cluster )
+			cluster.elements.each do |element|
+				self.createCluster( element, klass )
+			end
+			cluster.deleteAll
+			self.deleteCluster( cluster )
+		end
+
+		def deleteFromCluster( element, cluster )
+			return if !cluster.kind_of?( MK::Cluster )
+			cluster.deleteID( element )
+			cluster.size == 0 and self.deleteCluster( cluster )
+			self.createCluster( element )
+		end
+		
+		def deleteCluster( cluster );	self.clusters.delete( cluster );	end
+
+		def formClusterWithHostilities( elements ); self.error( "Subclass responsibility" ); end
+		
+		def lossyConcat( toCluster, fromCluster )
+			elements = Array.new
+			elements.concat( fromCluster.elements )
+			self.disbandCluster( fromCluster, nil )
+			toCluster.add( elements )
+		end
+		
+		def releaseClusters
+			self.clusters.each do |cluster|
+				self.disbandCluster( cluster, nil )
+				self.deleteCluster( cluster )
+			end
+		end
+		
+		def cleanManagedClusters
+			self.cleanClusters( self.clusters )
+		end
+
+		def cleanClusters( clusters, manager = false )
+			toDelete = Array.new
+			clusters.each_index do |cidx|
+				clusters.each_index do |ocidx|
+					next if ocidx == cidx
+					if clusters[ cidx ] == clusters[ ocidx ]
+						if !toDelete.include?( cidx ) and !toDelete.include?( ocidx )
+							toDelete.push( ocidx )
+							# else one is in and one isn't or both are in, so don't push anymore
+						end
+					end
+				end
+			end
+			toDelete.sort! { |x,y| y <=> x }
+			toDelete.each { |index| clusters.delete_at( index ) }
+			clusters
+		end
+		
+  end
+end
+

data/khammurabi-0.2/lib/nist/khammurabi/ClusterManager2.rb

@@ -0,0 +1,103 @@
+module MK
+
+require 'nist/khammurabi/Cluster'
+
+  class ClusterManager
+    
+    attr :clusters, true # Hash( Cluster )
+    
+    def initialize
+      self.clusters = Hash.new { nil }
+      # the nil cluster... all elements match this
+      self.clusters[ -1 ] = Cluster.init( -1, Array.new )
+    end
+    
+    def ClusterManager.init( clusters )
+      clusterManager = ClusterManager.new
+      clusterManager.clusters = clusters
+      clusterManager
+    end
+    
+    def createClusterWithID( clusterID )
+      clusters[ clusterID ] = Cluster.init( clusterID, Array.new )
+    end
+    
+    def createCluster
+      max = clusters.keys.max
+      newmax = max + 1
+			cluster = Cluster.init( newmax, Array.new )
+      clusters[ newmax ] = cluster
+      cluster
+    end
+    
+    def getCluster( clusterID ); clusters[ clusterID ]; end
+                              
+    def deleteCluster( clusterID )
+      if ( clusters[ clusterID ] ) 
+        clusters[ clusterID ].disband
+        clusters.delete( clusterID )
+      end
+    end
+    
+		def disbandCluster( clusterID )
+			if clusters[ clusterID ]     
+				cluster = clusters[ clusterID ]
+				cluster.elements.each do |element|
+					element.cluster = createCluster
+				end
+			end
+		end
+		
+		def addObjectToCluster( object, cluster ); cluster.add( object ); end
+		def deleteObjectFromCluster( object, cluster ); cluster.delete( object ); end
+
+		def objectsShareCluster?( object1, object2 )
+      yesno = false
+      if ( object1.clusterIDs.size == 0 && object2.clusterIDs.size == 0 )
+				yesno = true
+			else 
+				object1.clusterIDs.each do |clusterID|
+					cluster = getCluster( clusterID )
+					if cluster.contains?( object2 )
+						yesno = true
+						break
+					end
+				end
+			end
+			yesno
+    end
+    
+		def nilCluster; clusters[ -1 ];	end
+		
+		def cleanManagedClusters
+			self.cleanClusters( self.clusters )
+		end
+		
+		def cleanClusters( clusters, manager = false )
+			toDelete = Array.new
+			clusters.each do |cluster|
+				clusters.each do |ocluster|
+					next if ocluster.equal?( cluster )
+					equal = true
+					ocluster.elements.each do |ocelement|
+						if !cluster.elements.includeID?( ocelement )
+							equal = false
+							break
+						end
+					end
+					toDelete.push( ocluster ) if equal == true and !toDelete.include?( ocluster )
+				end # clusters.each do |ocluster|
+			end # clusters.each do |cluster|
+			toDelete.each do |cluster|
+				break if clusters.size == 1
+				r = clusters.rindex( cluster )
+				while r != nil and clusters.size > 1
+					clusters.delete_at( r )
+					r = clusters.rindex( cluster )
+				end
+			end
+		end # def cleanClusters
+		
+  end
+end
+