def first_fit(list_items, max_size): """ Returns list of bins with input items inside. """ list_bins = [] list_bins.append(Bin()) # Add first empty bin to list for item in list_items: # Go through bins and try to allocate alloc_flag = False for bin in list_bins: if bin.sum() + item <= max_size: bin.addItem(item) alloc_flag = True break # If item not allocated in bins in list, create new bin # and allocate it to it. if alloc_flag == False: newBin = Bin() newBin.addItem(item) list_bins.append(newBin) # Turn bins into list of items and return list_items = [] for bin in list_bins: list_items.append(bin.show()) return(list_items)
def __init__(self): #bin for objects and tiles self._object_bin = Bin(0, 0, 150, 450) self._tile_bin = Bin(600, 225, 150, 225) #2d list of tiles that are on the map self._tiles = [] #list of GameObjects on the map self._objects = [] #offsets for the map having been dragged self._x_offset = 0 self._y_offset = 0 #currently selected Placeable item self._selected = None #whether or not the map is scrolling currently self._scrolling = False #list to store any buttons self._buttons = [] self.init_bins()
def setUp(self): self.bin = Bin([]) self.bin.addOutcome(TestOutcome.oc1) self.bin.addOutcome(TestOutcome.oc2) self.outcome1 = TestOutcome.oc1 self.outcome2 = TestOutcome.oc2 self.outcome3 = TestOutcome.oc3
def setUp(self): self.first = Outcome('one', 17) self.second = Outcome('one', 17) self.third = Outcome('two', 32) self.fbin = Bin(self.first) self.sbin = Bin(self.second)
def first_fit(list_items, max_size): """ Returns list of bins with input items inside. """ list_bins = [] list_bins.append(Bin()) # Add first empty bin to list for item in list_items: # Go through bins and try to allocate alloc_flag = False for bin in list_bins: if bin.sum() + item <= max_size: bin.addItem(item) alloc_flag = True break # If item not allocated in bins in list, create new bin # and allocate it to it. if alloc_flag == False: newBin = Bin() newBin.addItem(item) list_bins.append(newBin) # Turn bins into list of items and return list_items = [] for bin in list_bins: list_items.append(bin.show()) return (list_items)
def map_point_to_extBins(self, point): mapped_bin = self.map_point_to_bin(point) mapped_extBins = Bin(mapped_bin[0], mapped_bin[1]).extBins_contain_bin() for b in mapped_extBins: if b not in self.extBins_dict.keys() and self._is_valid_bin(b): self.extBins_dict[b] = Bin(b[0], b[1]).extBin_centerd_at_bin() return mapped_extBins
def apply(item, bins): """ Adds the item to the very first bin that it can fit it. """ b = next((b for b in bins if b.can_add_item(item)), None) if not b: b = Bin(bins[0].capacity) bins.append(b) b.add_item(item) return bins
def apply(item, bins): """ Adds the item to the next available bin after the last insertion. """ b = bins[-1] if not b.add_item(item): b = Bin(bins[0].capacity) bins.append(b) b.add_item(item) return bins
def test_bin_add(): outcome = Outcome("00", 35) bin = Bin( outcome) assert len(bin.outcomes) == 1 #Sets are unique by hash and eq bin.add( Outcome("00", 35) ) assert len(bin.outcomes) == 1 bin.add( Outcome("0", 35) ) assert len(bin.outcomes) == 2
def test_bin_has_outcomes(): outcome_0 = Outcome("0", 35) outcome_5 = Outcome("Five", 6) outcome_00 = Outcome("00", 35) bin_0 = Bin(0) bin_0.add(outcome_0) bin_0.add(outcome_5) bin_00 = Bin(37) bin_00.add(outcome_00) bin_00.add(outcome_5) assert bin_0.outcomes == frozenset([outcome_0, outcome_5]) assert bin_00.outcomes == frozenset([outcome_00, outcome_5])
def faseConstrutiva(itens, alpha): global BINS global ALPHA solucao = [] tam_pacote = TAM_MAX_PACOTE lista_conflitos = [] pacoteAtual = [] resultado = 1 while itens != []: candidatos = geraRCL(lista_conflitos, tam_pacote, pacoteAtual, itens, alpha) if candidatos == []: #cria o bin com os itens do pacote atual BINS.append( Bin( len(BINS) + 1, pacoteAtual, tam_pacote, set(lista_conflitos), TAM_MAX_PACOTE, ALPHA)) ALPHA = ALPHA * 0.95 #limpaInformações atuais tam_pacote = TAM_MAX_PACOTE lista_conflitos = [] pacoteAtual = [] if itens != []: resultado += 1 else: escolhido = random.choice(candidatos) solucao.append(escolhido) itens.remove(escolhido) tam_pacote = tam_pacote - escolhido.get_peso() lista_conflitos += escolhido.get_conflitos() pacoteAtual.append(escolhido) if pacoteAtual != []: #cria o bin com os itens do pacote atual BINS.append( Bin( len(BINS) + 1, pacoteAtual, tam_pacote, set(lista_conflitos), TAM_MAX_PACOTE, ALPHA)) #limpaInformações atuais tam_pacote = TAM_MAX_PACOTE lista_conflitos = [] pacoteAtual = [] if itens != []: resultado += 1 #print('Pacotes : ' + str(resultado)) return solucao
def findBin(self, item, capacity): current = self.bst.root _bin = self.findWorst(item) if _bin is None: _bin = Bin(capacity) else: self.bst.remove(_bin) _bin.addItem(item) self.bst.insert(_bin) return _bin
def apply(item, bins): """ Adds the item to the bin for which the most amount of open space would be available after insertion. """ valid_bins = (b for b in bins if b.can_add_item(item)) sorted_bins = sorted(valid_bins, key=lambda x: x.filled_space()) if sorted_bins: b = sorted_bins[0] else: b = Bin(bins[0].capacity) bins.append(b) b.add_item(item) return bins
def apply(item, bins): """ Adds the item to the very first bin that it can fit it. :param item: The item to add. :param bins: The bins to choose from. :return: The list of bins after the insertion. """ b = next((b for b in bins if b.can_add_item(item)), None) if not b: b = Bin(bins[0].capacity) bins.append(b) b.add_item(item) return bins
def apply(item, bins): """ Adds the item to the next available bin after the last insertion. :param item: The item to add. :param bins: The bins to choose from. :return: The list of bins after insertion. """ b = bins[-1] if not b.add_item(item): b = Bin(bins[0].capacity) bins.append(b) b.add_item(item) return bins
def findBin(self, item, capacity): if len(self.bins) == 0: self.bins.append(Bin(capacity)) bin_ = self.bins.pop() self.bins.append(bin_) if not item.fitsInto(bin_): bin_ = Bin(capacity) self.bins.append(bin_) bin_.addItem(item) return bin_
def idIsInMyInterval(self,data): """recive data with id hex wanted, return 1 if the id is in my interval, else return 0""" ans = None num = Bin(data[1].decode()) if self.idPredecessor < self.id: ans = self.idPredecessor < num <= self.id else: #el id del predecesor es mayor que mi id ans = self.idPredecessor < num <= self.numElements or Bin("0") <= num <= self.id ans = str(int(ans)) self.listen.send(ans.encode())
def addServerToChord(self): """Add in the middel to two server in the chord TODO send all files in the new successor server and me """ #init the socket listen, that is in the __init__ ipNewSuccessor, portNewSuccessor = self.find() #send to my predecessor my ip, port and id self.next.send_multipart([b'changeTheSuccessorInformation', self.IPListen.encode(), self.portListen.encode(), self.id.getHex().encode()]) print(self.next.recv().decode()) #get id of my predeccessor self.next.send_multipart([b'getServerID']) idp = self.next.recv().decode() self.next.disconnect(tcp + self.IPNext + ":" + self.portNext) print("id new predeccessor:", idp) self.idPredecessor = Bin(idp) #connect to my successor self.IPNext = ipNewSuccessor self.portNext = portNewSuccessor print("my successor is:", tcp + self.IPNext + ":" + self.portNext) self.next.connect(tcp + self.IPNext + ":" + self.portNext) self.next.send_multipart([b'getServerID']) ids = self.next.recv().decode() self.idSuccessor = Bin(ids) #tell to successor the id of his new predecessor self.next.send_multipart([b"updatePredecessor", self.id.getHex().encode()]) print("update successor id",self.next.recv()) #tell to succesor that send me hash of the my files msj = [b"sendAllFiles", self.idPredecessor.getHex().encode(), self.id.getHex().encode()] self.next.send_multipart(msj) filesHash = self.next.recv_multipart() filesHash = filesHash[1:] for fh in filesHash: print("Recovery files from another server") path = self.folder.getpath(fh.decode()) msj = [b'download', fh] self.next.send_multipart(msj) byte = self.next.recv() self.filesManager.insert(fh.decode()) with open(path, 'ab') as f : f.write(byte)
def sort_in_bins(self): for packet in self.packets: if packet.sa is not None: if not self.bins.get(packet.sa): self.bins[packet.sa] = Bin() self.bins[packet.sa].append(packet) return self.bins
def __init__(self, rng=None): self.bins = tuple(Bin(i) for i in range(38)) if rng is None: rng = random.Random() self.rng = rng # A map name -> Outcome self.all_outcomes = dict()
def apply(item, bins): """ Adds the item to the bin for which the least amount of open space would be available after insertion. """ valid_bins = (b for b in bins if b.can_add_item(item)) # Note that this method is exactly the same as for the BestFit heuristic except for the following line. sorted_bins = sorted(valid_bins, key=lambda x: x.filled_space(), reverse=True) if sorted_bins: b = sorted_bins[0] else: b = Bin(bins[0].capacity) bins.append(b) b.add_item(item) return bins
def run(self): key = random.choice(self.BINS_DEFINITION.keys()) outcomes = [] for outcome_name in self.BINS_DEFINITION[key]: outcomes.append(self.outcome_builder.get_outcome(outcome_name)) return Bin(outcomes)
def findBin(self, item, capacity): bin_ = self.bst.select(1) if bin_ is not None and item.fitsInto(bin_): self.bst.remove(bin_) else: bin_ = self.bst.select(0) if bin_ is not None and item.fitsInto(bin_): self.bst.remove(bin_) else: bin_ = Bin(capacity) bin_.addItem(item) self.bst.insert(bin_) return bin_
def __init__(self,alpha,capacity, items,t_init,t_target,iter_nb): self.alpha = alpha self.items = items self.capacity = capacity self.bins = [Bin(capacity)] self.t_init = t_init self.t_target = t_target self.iter_nb = iter_nb
def __init__(self, id, IPListen, portListen, IPNext, portNext, bootstrap, k = 160): self.folder = Folder(id =portListen) self.filesManager = Trie() self.IPListen = IPListen self.portListen = portListen self.IPNext = IPNext self.portNext = portNext self.k = k self.numElements = Bin(hex((2**k)-1)[2:]) self.id = Bin(id)#aca va entrar la mac, debe crear una funcion que cuadre la mac como sha1 print("my id:", self.id.getHex()) self.listen.bind(tcp + self.IPListen + ":" + self.portListen) self.idPredecessor = None self.idSuccessor = None #query of disponible operations in the server's self.operation = {"updatePredecessor": self.updatePredecessor, "idIsInMySuccesor": self.idIsInMySuccesor, "idIsInMyInterval": self.idIsInMyInterval, "getSuccessor": self.getSuccessor, "getServerID": self.getServerID, "changeTheSuccessorInformation": self.changeTheSuccessorInformation, "upload": self.upload, "download": self.download, "existsFileNow": self.existsFileNow, "sendAllFiles": self.sendAllFiles } print("Server IP:", self.IPListen + ":" + self.portListen) if bootstrap: self.bootstrap() self.run() else : #self.find() self.addServerToChord() self.run()
def __init__(self, capacity, items): """ Creates an instance that can run the tabu search algorithm. """ self.bin_capacity = capacity self.items = items self.fitness = 0 self.bins = [Bin(capacity)] self.tabu_list = set()
def __init__(self): # Create collection of empty Bins self.bins = list(Bin([]) for i in range(38)) # Set pseudo-random number generator for selecting a winning Bin. self.rng = random.Random() self.rng.seed() self.all_outcomes = {} # Fill Bins with possible Outcomes. self._fillBins()
def map_point_to_bin(self, point): mapped_bin = (math.floor( abs(point.x - Experiment_Setup.x_min) / self.bin_width), math.floor( abs(point.y - Experiment_Setup.y_min) / self.bin_height)) if mapped_bin not in self.bins_dict.keys() and self._is_valid_bin( mapped_bin): self.bins_dict[mapped_bin] = Bin(mapped_bin[0], mapped_bin[1]) return mapped_bin
def generate_solution(self, items): """ Generates a candidate solution based on the pattern given. """ solution = [Bin(self.bin_capacity)] pattern_length = len(self.pattern) for idx, item in enumerate(items): h = self.pattern[idx % pattern_length] solution = self.heuristic_map[h].apply(item, solution) return solution
def __init__(self, capacity, items): """ Creates an instance that can run the tabu search algorithm. :param capacity: The capacity of a bin. :param items: The items that have to be packed in bins. """ self.bin_capacity = capacity self.items = items self.fitness = 0 self.bins = [Bin(capacity)] self.tabu_list = set()
def idIsInMySuccesor(self, data): """ recive data with id hex wanted, return 1 if the id is in the succesor interval, else return 0 """ ans = None num = Bin(data[1].decode()) #print("id:", self.id) #print("idSuccessor:", self.idSuccessor) #print("numero que busco", num) if self.idSuccessor > self.id : #print("por el if") ans = (self.id < num <= self.idSuccessor) else : #print("por el else") ans = (self.id < num <= self.numElements or Bin("0") <= num <= self.idSuccessor) # convertir esto como un string hexadecimal ans = str(int(ans)) self.listen.send(ans.encode())
def bootstrap(self): self.next.connect(tcp + self.IPNext + ":" + self.portNext) self.next.send_multipart([b"updatePredecessor", self.id.getHex().encode()]) data = self.listen.recv_multipart() self.operation[data[0].decode()](data) self.idSuccessor = Bin(self.idPredecessor.getHex()) self.next.recv()
def testCanAddOutcomeToBin(self): testBin = Bin() self.assertEqual(len(testBin.outcomes), 0) testBin.add(self.output) self.assertEqual(len(testBin.outcomes), 1)
def test_add(self): b1 = Bin() b1.add(o1) self.assertTrue(b1.outcomes == frozenset([o1]))