Initial addition of Python scripts

slipnode.py

@@ -0,0 +1,161 @@
+import math
+import utils
+import logging
+
+def full_activation():
+	return 100
+
+def jump_threshold():
+	return 55.0
+
+class Slipnode(object):
+	def __init__(self, name, depth, length=0.0):
+	#		logging.info('depth to %s for %s' % (depth,name))
+		self.conceptual_depth = depth
+		self.usualConceptualDepth = depth
+		self.name = name
+		self.intrinsicLinkLength = length
+		self.shrunkLinkLength = length * 0.4
+
+		self.activation = 0.0
+		self.buffer = 0.0
+		self.clamped = False
+		self.bondFacetFactor = 0.0
+		self.categoryLinks = []
+		self.instanceLinks = []
+		self.propertyLinks = []
+		self.lateralSlipLinks = []
+		self.lateralNonSlipLinks = []
+		self.incomingLinks = []
+		self.outgoingLinks = []
+		self.codelets = []
+		self.clampBondDegreeOfAssociation = False
+
+	def __repr__(self):
+		return '<Slipnode: %s>' % self.name
+
+	def reset(self):
+		self.buffer = 0.0
+		self.activation = 0.0
+
+	def clampHigh(self):
+		self.clamped = True
+		self.activation = 100.0
+
+	def unclamp(self):
+		self.clamped = False
+
+	def setConceptualDepth(self, depth):
+		logging.info('set depth to %s for %s' % (depth, self.name))
+		self.conceptual_depth = depth
+
+	def category(self):
+		if not len(self.categoryLinks):
+			return None
+		link = self.categoryLinks[0]
+		return link.destination
+
+	def fully_active(self):
+		"""Whether this node has full activation"""
+		return self.activation > full_activation() - 0.00001 # allow a little leeway for floats
+
+	def activate_fully(self):
+		"""Make this node fully active"""
+		self.activation = full_activation()
+
+	def bondDegreeOfAssociation(self):
+		linkLength = self.intrinsicLinkLength
+		if (not self.clampBondDegreeOfAssociation) and self.fully_active():
+			linkLength = self.shrunkLinkLength
+		result = math.sqrt(100 - linkLength) * 11.0
+		return min(100.0, result)
+
+	def degreeOfAssociation(self):
+		linkLength = self.intrinsicLinkLength
+		if self.fully_active():
+			linkLength = self.shrunkLinkLength
+		return 100.0 - linkLength
+
+	def update(self):
+		act = self.activation
+		self.oldActivation = act
+		self.buffer -= self.activation * ( 100.0 - self.conceptual_depth) / 100.0
+
+	def linked(self, other):
+		"""Whether the other is among the outgoing links"""
+		return self.points_at(self.outgoingLinks, other)
+
+	def slipLinked(self, other):
+		"""Whether the other is among the lateral links"""
+		return self.points_at(self.lateralSlipLinks, other)
+
+	def points_at(self, links, other):
+		"""Whether any of the links points at the other"""
+		return any([l.points_at(other) for l in links])
+
+	def related(self, other):
+		"""Same or linked"""
+		return self == other or self.linked(other)
+
+	def applySlippages(self, slippages):
+		for slippage in slippages:
+			if self == slippage.initialDescriptor:
+				return slippage.targetDescriptor
+		return self
+
+	def getRelatedNode(self, relation):
+		"""Return the node that is linked to this node via this relation.
+
+		If no linked node is found, return None
+		"""
+		from slipnet import slipnet
+
+		if relation == slipnet.identity:
+			return self
+		destinations = [l.destination for l in self.outgoingLinks if l.label == relation]
+		if destinations:
+			return destinations[0]
+		node = None
+		return node
+
+	def getBondCategory(self, destination):
+		"""Return the label of the link between these nodes if it exists.
+
+		If it does not exist return None
+		"""
+		from slipnet import slipnet
+
+		result = None
+		if self == destination:
+			result = slipnet.identity
+		else:
+			for link in self.outgoingLinks:
+				if link.destination == destination:
+					result = link.label
+					break
+		if result:
+			logging.info('Got bond: %s' % result.name)
+		else:
+			logging.info('Got no bond')
+		return result
+
+	def spread_activation(self):
+		if self.fully_active():
+			[ link.spread_activation() for link in self.outgoingLinks ]
+
+	def addBuffer(self):
+		if not self.clamped:
+			self.activation += self.buffer
+		self.activation = min(self.activation, 100)
+		self.activation = max(self.activation, 0)
+
+	def jump(self):
+		value = (self.activation / 100.0) ** 3
+		#logging.info('jumping for %s at activation %s' % (self.name,self.activation))
+		if self.activation > jump_threshold() and utils.random() < value and not self.clamped:
+			self.activate_fully()
+
+	def get_name(self):
+		if len(self.name) == 1:
+			return self.name.upper()
+		return self.name