def insert(self , item , index): if self.head is None and index > 0: raise IndexError("OUT OF RANGE") elif index == 0 and self.head is None: self.add_First(item) return elif index == 0 and self.head.next is not None: prev_node = self.tail_node().next self.head = Node(item, self.head) prev_node.next = self.head self.length += 1 return elif index == self.length: self.add_last(item) return counter = 0 curr_node = self.head while counter < index and curr_node.next != self.head: prev_node = curr_node curr_node = curr_node.next counter += 1 curr_node = Node(item , curr_node) prev_node.next = curr_node self.length += 1
def insert_after_node(self, prev_node, data): new_node = Node(data) if not prev_node: print("Previous mode doesn't exist") return new_node.next = prev_node.next prev_node.next = new_node
def test_connect(): node_1 = Node.Node("zomg") node_2 = Node.Node("omg") node_1.connectWith("energy", node_2) assert len(node_1.getAllOutgoingConnectionsByType("energy")) == 1 assert len(node_2.getAllIncomingConnectionsByType("energy")) == 1
def push(self, data): node = Node(data) if self.top: node.next = self.top self.top = node else: self.top = node self.size += 1
def add_first(self, item): if self.head is None: self.head = Node(item) self.tail= self.head self.length +=1 return curr_node = self.head self.head =Node(item, curr_node) self.length +=1
def add_first(self, item): if self.head is None: self.head = Node(item, next=None, prev=None) self.length += 1 return new_node = Node(item, self.head, None) self.head.prev = new_node self.head = new_node self.length += 1 return
def add_First(self, item): if self.head is None: self.head = Node(item) self.head.next = self.head self.length += 1 return prev_node = self.tail_node().next new_node = Node(item, self.head) self.head = new_node prev_node.next = self.head self.length += 1
def append(self, value): newNode = Node(value) if not self.head: self.head = newNode self.head.next = newNode else: curr = self.head while curr.next != self.head: curr = curr.next curr.next = newNode newNode.next = self.head
def test_connectNodes(): node = Node.Node("SuchNode!") node_2 = Node.Node("anotherNode") node.connectWith("energy", node_2) assert len(node.getAllOutgoingConnections()) == 1 assert len(node.getAllIncomingConnections()) == 0 assert len(node_2.getAllOutgoingConnections()) == 0 assert len(node_2.getAllIncomingConnections()) == 1
def prepend(self, data): cur = self.head new_node = Node(data) new_node.next = self.head if not self.head: new_node.next = new_node else: while cur.next != self.head: cur = cur.next cur.next = new_node self.head = new_node
def add_last(self , item): if self.head is None: self.head = Node(item) self.head.next = self.head self.length += 1 return curr_node = self.head while curr_node.next != self.head: curr_node = curr_node.next curr_node.next = Node(item , self.head) self.length += 1
def append(self, data): new_node = Node(data) cur_node = self.head if not self.head: self.head = new_node new_node.next = self.head # Idk, I can also set this to new_node abi? return while cur_node.next != self.head: cur_node = cur_node.next cur_node.next = new_node new_node.next = self.head
def sort_number(self): curr = self.head arr = [] if self.get_length() == 0 or self.get_length() == 1: return while curr: arr.append(curr.value) curr = curr.next arr.sort() self.head = Node(arr[0]) arr.pop(0) for x in arr: self.append(Node(x))
def test_repair(): node = Node.Node("zomg") node._health = 20 node.repair(100) assert node.health == 100
def test_update(): node = Node.Node("") node.updateCalled.emit = MagicMock() node.update() node.updateCalled.emit.assert_called_once_with(node)
def test_serialize(): node = Node.Node("zomg") serialized = node.serialize() assert serialized["node_id"] == node.getId() assert serialized["temperature"] == node.temperature
def test__getReservedResourceByType(): node = Node.Node("") connection = MagicMock() connection.getReservedResource = MagicMock(return_value=209) node.getAllIncomingConnectionsByType = MagicMock(return_value=[connection]) assert node._getReservedResourceByType("zomg") == 209
def test_requiresReplanningOneConnectionStatisifiedButDisabled(): node = Node.Node("") node.enabled = False node.addConnection(MagicMock(isReservationStatisfied=MagicMock(return_value=True))) node.addConnection(MagicMock(isReservationStatisfied=MagicMock(return_value=False))) assert not node.requiresReplanning() # Disabled nods should never need to be replanned!
def test_deserialize(): node = Node.Node("BLOOORPP") node.deserialize({"node_id": "omgzomg", "temperature": 200, "resources_received_this_tick": {}, "resources_produced_this_tick": {}, "resources_left_over": {}}) assert node.getId() == "omgzomg" assert node.temperature == 200
def insert(self, item, index): counter = 0 new_node = Node(item) curr_node = self.head prev_node = None while counter < index: counter += 1 prev_node = curr_node curr_node = curr_node.next new_node.next =curr_node if curr_node == self.head: self.head = new_node if prev_node is not None: prev_node.next = new_node self.length += 1
def test_massiveHeatDamage(): node = Node.Node("SuchNode!") node._temperature = 900000000000000 node._dealDamageFromHeat() assert node.health == 0 # No amount of damage should ever let the health go below 0
def test_unmodifiableNodeWithModifier(): node = Node.Node("ModifiedNode", can_be_modified=False) assert node.can_be_modified == False modifier = MagicMock(spec=Modifier.Modifier) node.addModifier(modifier) assert modifier not in node.getModifiers()
def test_simpleGetters(resource_type): # It's not really a test, but the results should remain the same, as other child nodes depend on this # implementation. Call them with all resources types known to us. node = Node.Node("") assert node.preGetResource(resource_type, 200) == 0 assert node.preGiveResource(resource_type, 200) == 0 assert node.getResource(resource_type, 200) == 0 assert node.giveResource(resource_type, 200) == 0
def test_provideResourceToOutogingConnections(connections, amount_to_provide, resources_left): node = Node.Node("") node.getAllOutgoingConnectionsByType = MagicMock(return_value=connections) assert node._provideResourceToOutgoingConnections( "fuel", amount_to_provide) == resources_left
def test_requiresReplanningOneConnectionStatisified(): node = Node.Node("") node.addConnection( MagicMock(isReservationStatisfied=MagicMock(return_value=True))) node.addConnection( MagicMock(isReservationStatisfied=MagicMock(return_value=False))) assert node.requiresReplanning()
def append(self, data): new_node = Node(data, None, None) if self.head is None: self.head = new_node self.tail = self.head else: new_node.prev = self.tail self.tail.next = new_node self.tail = new_node
def append(self, data): new_node = Node(data) if self.head is None: self.head = new_node return last_node = self.head while last_node.next: last_node = last_node.next last_node.next = new_node
def test__convectiveHeatTransfer(starting_temperature, outside_temperature, heat_emitted): node = Node.Node("") node.addHeat = MagicMock() node.outside_temp = outside_temperature # Force the starting temperature node._temperature = starting_temperature node._convectiveHeatTransfer() node.addHeat.assert_called_with(heat_emitted)
def dfs(self): # holds list of visited sucessors visitedSuccessors = [] # the fringe of this algorithm fringe = [] visitedSuccessors.append(self.startState.getIndex()) #print(visitedSuccessors) fringe.append(self.agnt.getIndex()) while self.agnt.getIndex() != self.goalState.getIndex(): successors = self.agnt.getSuccessors() #print("----------") #print("currentState", self.agnt.getIndex()) #print("visited", visitedSuccessors) #print("fringe", self.fringe) #print("successors", successors) for s in successors: #print(s) if (s not in visitedSuccessors): #print("PUSHING TO FRINGE", s) fringe.append(s) visitedSuccessors.append(s) self.agnt.setCurrentState(Node(s)) if len(self.agnt.getSuccessors()) == 0: #print("running IF") if (self.agnt.getIndex() == self.goalState.getIndex()): break else: self.agnt.setCurrentState( Node(fringe[len(fringe) - 2])) fringe.pop() break elif s == successors[len(successors) - 1]: if (len(fringe)): self.agnt.setCurrentState(Node(fringe[len(fringe) - 2])) fringe.pop() break return fringe
def append(self, data): node = Node(data) if self.tail: self.tail.next = node self.tail = node else: self.head = node self.tail = node self.tail.next = self.head self.size += 1
def get_node(self, hostname): node = Node(self) if hasattr(self, 'nodes') and hostname in self.nodes.keys(): node.update(self.nodes[hostname]) node.__init_logfile__() return node
def predictSolnCard(self, cardAName, cardBName, cardCName, cardDName): pp = pprint.PrettyPrinter(indent=4) D = Card(cardDName) #Predict number of nodes in D nodesInA = len(self.cards[cardAName].nodes) nodesInB = len(self.cards[cardBName].nodes) nodesInC = len(self.cards[cardCName].nodes) nodesInD = nodesInC - (nodesInA - nodesInB) #################### got 1 que #return ansName # apply triangular properties and relations # A--B # | # C # # - Regus #for i in range(1, nodesInOption): i=-1 # deducting for 2x2 ABRel = self.correspondenceList[cardAName+','+cardBName] ACRel = self.correspondenceList[cardAName+','+cardCName] # from ACRel.related, remove the sets which contain elements from AB.deleted validNodesInC = [] for (x,y,w) in ACRel['related']: if x not in ABRel['deleted']: # find the related pair of x in ABRel[related] and match it with x for (p, q,r) in ABRel['related']: if p == x: #got it. form CBRel validNodesInC.append((y, p, q, 0)) print "CABRelation nodes in C:" pp.pprint(validNodesInC) #also add newly added nodes #for x in ABRel['added']: # validNodesInC.append(x) i=-1 for (c, a, b, w) in validNodesInC: i+=1 c = self.nodes[c] a = self.nodes[a] b = self.nodes[b] dNode = Node(D.name+"_"+str(i), {}, {}, {}) print "Initialized dNode"+dNode.name dNode.printNode() D.addNode(dNode) print "Creating nodes in "+dNode.name +"("+c.name+","+a.name+","+b.name+")" # predict properties: for property in b.properties: print "Recreating property: "+b.name+"."+ property+"="+b.properties[property]+ " in "+dNode.name # predict value of d.property based on the property type valA = a.properties[property] valB = b.properties[property] valC = c.properties[property] if valA.isdigit() and valB.isdigit() and valC.isdigit(): valD = self.predictNumericProperty(property, int(valA), int(valB), int(valC)) print "Predicting number: "+valC+"+("+valB+"-"+valA+")="+str(valD) print "int D."+property+" = "+str(valD) dNode.addProperties(property, str(valD) ) # Predict Boolean property elif self.isBool(valA): if valA == valB: dNode.addProperties(property, valC) else: dNode.addProperties(property, self.invertBoolProperty(valC)) else: dNode.addProperties(property, self.predictFromChain(valA, valB, valC)) #predict relations: for relation in b.relations: dNode.addRelation(relation, b.relations[relation]) dNode.addProperties('inCard', D.name) dNode.printNode() self.addNode(dNode.name, dNode.properties, {}) self.addCard(D) return D.name