Beispiel #1
0
    def __init__(self, filepath: str = None, text: str = None) -> None:
        if not filepath and text is None:
            raise BufferInitializeException('Buffer must be instantiated with a filepath'
                                            'or a text')
        if filepath:
            with open(filepath, 'r') as f:
                self.textl = blist(f.read())
        else:
            self.textl = blist(text)

        # Fixme: there three must be properties and update toghether on write
        self._pos        = 0
        self._line       = 1
        self._column     = 1

        self.selections = [] # type: List[Selection]

        self.moveselect_method = {
            Subject.Char      : self.ms_char,
            Subject.Word      : self.ms_word,
            Subject.Line      : self.ms_line,
            Subject.Sentence  : self.ms_sentence,
            Subject.Paragraph : self.ms_paragraph,
            Subject.Function  : self.ms_function,
            Subject.Class     : self.ms_class,
            Subject.FullFile  : self.ms_fullfile
        }
Beispiel #2
0
 def __init__(self):
     if USE_BLIST:
         self._scores = blist([])
         self._members = blist([])
     else:
         self._scores = []
         self._members = []
Beispiel #3
0
	def clearCache(self):
		"""
		Removes all events from the cache, be recreating the events set, the
		delay list and the cache list.
		"""
		self.logger.logNotice("EventCache: clearing event cache.")
		self.events = set()
		self.delay_list = blist()
		self.cache_list = blist()
Beispiel #4
0
    def sort_index(self):
        """
        Sort the Series by the index. The sort modifies the Series inplace

        :return: nothing
        """
        sort = sorted_list_indexes(self._index)
        # sort index
        self._index = blist([self._index[x] for x in sort]) if self._blist else [self._index[x] for x in sort]
        # sort data
        self._data = blist([self._data[x] for x in sort]) if self._blist else [self._data[x] for x in sort]
Beispiel #5
0
	def __init__(self, config, logger, ticker):
		self.config = config
		self.logger = logger
		self.ticker = ticker
		self.events = set()        #: a set of all events in the cache
		self.delay_list = blist()  #: sorted list with event delay times -> tuple (delay time, event)
		self.cache_list = blist()  #: sorted list with event cache times -> tuple (cache time, event)
		self.dropped_events = 0    #: count of dropped events
		self.compressed_events = 0 #: number of events removed from cache because of compression
		self.new_compressed = 0    #: number of new compressed events
		self.nextcachewarning = 0  #: next time for warning about cache size exceeded
 def __init__(self, display, pos, size):
     self.display = display
     self.pos = pos
     self.size = size
     self.left = pos[0]
     self.top = pos[1]
     self.right = pos[0] + size[0]
     self.bottom = pos[1] + size[1]
     self.particles = blist([])
     self.sources = blist([])
     self.gravities = blist([])
     self.obstacles = blist([])
Beispiel #7
0
    def __init__(self, impl):
        self.impl = impl
        # reasonable defaults
        self.calc_ping = 0.1
        self.calc_bandwidth = 100 * KB
        self.calc_quality = 1
        self._last_bandwidth_scale = time.time()

        # use 64-bit integer to never run out of packet_nums
        self.packet_num = 0
        self.last_packet_num = 0
        self.stat_num = 0
        self.last_packets = blist()
        self._used_bandwidth = 0
        self._stats = blist()
        self._last_req = 0
Beispiel #8
0
 def test_iterlen_empty(self):
     it = iter(blist.blist())
     if hasattr(it, '__next__'): # pragma: no cover
         self.assertRaises(StopIteration, it.__next__)
     else: # pragma: no cover
         self.assertRaises(StopIteration, it.next)
     self.assertEqual(it.__length_hint__(), 0)
Beispiel #9
0
     def __init__(self, mm, start, stop):
         self.mm = mm
         self.start = start
         self.stop = stop
 
         self.muts = blist([0])
         self.muts *= self.stop - self.start
Beispiel #10
0
    def __init__(self, eps=1e-6):

        # [remaining, jobid] queue for the *virtual* scheduler
        self.queue = blist()

        # Jobs that should have finished in the virtual time,
        # but didn't in the real (happens only in case of estimation
        # errors)
        self.late = set()

        # last time we run the schedule function
        self.last_t = 0

        # Jobs that are running in the real time
        self.running = set()

        # Jobs that have less than eps work to do are considered done
        # (deals with floating point imprecision)
        self.eps = eps

        # queue for late jobs, sorted by attained service
        self.late_queue = sorteddict()

        # {jobid: att} where att is jobid's attained service
        self.attained = {}

        # last result of calling the schedule function
        self.scheduled = {}
Beispiel #11
0
 def getTitleSet(self):
     dbs = Movie.query.all()
     from blist import blist
     result = blist([])
     for db in dbs:
         striped_string = getTitle(db.titles)
         result.append(striped_string)
     return result
Beispiel #12
0
def restore_index(text_han, non_han):

    idx_list = blist(range(len(text_han) + 1))

    for j, char in sorted(non_han, key=lambda x: x[0]):
        idx_list.insert(j, char)

    return idx_list
 def filterNullValueForPrimaryKey(self, valList):
     valList = self.word_strip_lower(valList)
     newList = blist([])
     for v in valList:
         if v != '\\n' and v != '\\na' and v != '\n' and v != '\na' and v != 'nan' and v != '\nan' and v != '\\nan' and v != '' and v != '' and v != ' ' and v != '-' and v != '_':
             #print (v)
             newList.append(v)
     return newList
Beispiel #14
0
    def __init__(self, data=None, index=None, data_name='value', index_name='index', use_blist=False, sort=None):
        """
        :param data: (optional) list of values.
        :param index: (optional) list of index values. If None then the index will be integers starting with zero
        :param data_name: (optional) name of the data column, or will default to 'value'
        :param index_name: (optional) name for the index. Default is "index"
        :param use_blist: if True then use blist() as the underlying data structure, if False use standard list()
        :param sort: if True then Series will keep the index sort. If True all index values must be of same type
        """
        super(SeriesBase, self).__init__()

        # standard variable setup
        self._index = None
        self._index_name = index_name
        self._data = None
        self._data_name = data_name
        self._blist = use_blist

        # setup data list
        if data is None:
            self._data = blist() if self._blist else list()
            if index:
                # pad out to the number of rows
                self._pad_data(len(index))
                self.index = index
            else:
                self.index = list()
        elif isinstance(data, (list, blist)):
            self._data = blist([x for x in data]) if self._blist else [x for x in data]
            # setup index
            if index:
                self.index = index
            else:
                self.index = list(range(len(self._data)))
        else:
            raise TypeError('Not valid data type.')

        # setup sort
        self._sort = None
        if sort is not None:
            self.sort = sort
        else:
            if index:
                self.sort = False
            else:
                self.sort = True
Beispiel #15
0
 def __init__(self, L, el_type=set, overwrite=False):
     self.logger = logging.getLogger("SparseMap")
     self.L = L
     self.overwrite = overwrite
     self.logger.info("initializing empty blist with {0} entries".format(L))
     if L:
         self.data = blist([el_type()]) * L
     self.el_type = el_type
Beispiel #16
0
	def getListaIDsFavsByUserID(self, user_id):
		queryNeo4j = "MATCH (u:user {id_twitter : {ID}})-[r:FAV]->(a:tweet) return a"
		nodos = self.graph.cypher.execute(queryNeo4j, {"ID":user_id})
		identificadores = blist([])
		for nodo in nodos:
			identificadores.append(long(nodo[0].properties["id_twitter"]))

		return identificadores
Beispiel #17
0
    def submapping(self, start, stop):
        bounds, values, nothing = self._bounds, self._values, self.nothing
        
        lindex = bisect_right(bounds, start) if start is not None else 0
        rindex = (bisect_left(bounds, stop)
                  if stop is not None else len(bounds))

        res = type(self)()
        res._bounds = blist(bounds[lindex:rindex])
        res._values = blist(values[lindex:rindex + 1])
        
        if start is not None:
            res[:start] = nothing
        if stop is not None:
            res[stop:] = nothing

        return res
Beispiel #18
0
 def __init__(self,L, el_type = set, overwrite=False):
     self.logger = logging.getLogger("SparseMap")
     self.L = L
     self.overwrite = overwrite
     self.logger.info("initializing empty blist with {0} entries".format(L))
     if L:
         self.data = blist([el_type()]) * L
     self.el_type = el_type
Beispiel #19
0
	def getUsersFavTweetByID(self, tweet_id):
		queryNeo4j = "MATCH (u:user)-[r:FAV]->(a:tweet  {id_twitter : {ID}}) return u"
		nodos = self.graph.cypher.execute(queryNeo4j, {"ID":tweet_id})
		identificadores = blist([])
		for nodo in nodos:
			identificadores.append(long(nodo[0].properties["id_twitter"]))

		return identificadores
Beispiel #20
0
def main():
    rule = ""
    players = 0
    marbles = 0
    game = blist()
    player_scores = dict()
    current_player = 2
    game_idx = 2
    current_marble_idx = 1
    high_score = 0

    with open('input.txt') as f:
        for line in f:
            rule = line

    rule = rule.split()

    players = int(rule[0])
    marbles = int(rule[len(rule) - 2])

    game.append(0)
    game.append(1)

    while game_idx != marbles:
        play_index = current_marble_idx

        if (play_index + 2) >= (len(game) + 1):
            play_index = 1
        else:
            play_index = play_index + 2

        if game_idx % 23 == 0:
            if current_marble_idx < 7:
                current_marble_idx = len(game) - (7 - current_marble_idx)
            else:
                current_marble_idx = current_marble_idx - 7

            score = game_idx + game.pop(current_marble_idx)

            if current_player not in player_scores.keys():
                player_scores[current_player] = score
            else:
                player_scores[
                    current_player] = player_scores[current_player] + score

            if player_scores[current_player] > high_score:
                high_score = player_scores[current_player]
        else:
            game.insert(play_index, game_idx)
            current_marble_idx = play_index

        game_idx = game_idx + 1
        current_player = current_player + 1

        if current_player > players:
            current_player = 1

    print(high_score)
Beispiel #21
0
    def test_encodeBlist(self):
        b = blist(list(range(10)))
        c = ujson.dumps(b)
        d = ujson.loads(c)

        self.assertEqual(10, len(d))

        for x in range(10):
            self.assertEqual(x, d[x])
Beispiel #22
0
    def set(self, adValues):
        """
        Set all the values given as a list in the same order given.
		"""

        self.m_adValues = blist.blist([0]) * len(adValues)
        for i, d in enumerate(adValues):
            if d:
                self.m_adValues[i] = d
Beispiel #23
0
def get_graph_degrees_sym(sym_mat):
    """computes the degrees of nodes in a network (non oriented)
        - input: sym_matrix = ajacency symetric matrix (class Sym_mat)
        - output: vector of nodes degrees (ordered as in sym_mat.matrix)"""
    deg=blist([])
    for i, _ in enumerate(sym_mat.matrix):
        deg.append(0)
        deg[i] = sym_mat.sum_line(i)
    return deg
Beispiel #24
0
    def _sort_columns(self, columns_list):
        """
        Given a list of column names will sort the DataFrame columns to match the given order

        :param columns_list: list of column names. Must include all column names
        :return: nothing
        """
        if not (all([x in columns_list for x in self._columns])
                and all([x in self._columns for x in columns_list])):
            raise ValueError(
                'columns_list must be all in current columns, and all current columns must be in columns_list'
            )
        new_sort = [self._columns.index(x) for x in columns_list]
        self._data = blist([
            self._data[x] for x in new_sort
        ]) if self._blist else [self._data[x] for x in new_sort]
        self._columns = blist([self._columns[x] for x in new_sort]) if self._blist \
            else [self._columns[x] for x in new_sort]
Beispiel #25
0
def part1():
    jmp = 337

    pos = 0
    buff = blist.blist([0])
    for i in range(1, 2018):
        pos = ((pos + jmp) % len(buff)) + 1
        buff.insert(pos, i)
    return buff[pos + 1]
Beispiel #26
0
    def test_encodeBlist(self):
        b = blist(list(range(10)))
        c = ujson.dumps(b)
        d = ujson.loads(c)

        self.assertEqual(10, len(d))

        for x in range(10):
            self.assertEqual(x, d[x])
Beispiel #27
0
    def set(self, adValues):
        """
        Set all the values given as a list in the same order given.
		"""

        self.m_adValues = blist.blist([0]) * len(adValues)
        for i, d in enumerate(adValues):
            if d:
                self.m_adValues[i] = d
Beispiel #28
0
    def groupfunc(self, key, pkey, func):
        """Return the output of a function to the values grouped by key
        """
        rst = DataItem()
        if self.sortedkey != key:
            self.sort(key)

        temp = blist.blist()
        idx_val = type(self[key][0]).__init__()
        for idx in self.sortedindex:
            if idx_val != self[key][idx]:
                if len(temp)>0:
                    rst[idx_val] = func(temp)
                temp = blist.blist()
                idx_val = self[key][idx]
            temp.append(self[pkey][idx])
        rst[idx_val] = func(temp)
        return rst
Beispiel #29
0
 def append(self, item):
     """Add a new data item into the dataset
     This is just for mocking list().append()
     """
     for key in item.iterkeys():
         if key not in self:
             self[key] = blist.blist(genzero(self._size))
         self[key].append(item[key])
     self._size += 1
Beispiel #30
0
def solve(spins, result_is_after, step=354):
    """ Solve the spinlock puzzle. """
    nums = blist([0])
    pos = 0
    for i in range(1, spins):
        pos = (pos + step) % i + 1
        nums.insert(pos, i)

    return nums[nums.index(result_is_after) + 1]
Beispiel #31
0
    def __init__(self, in_bytes=b""):
        self.header = None
        self.set_bytes(in_bytes)

        self.lines = []
        try:  # Faster insertion
            from blist import blist
            self.lines = blist([])
        except ImportError:
            pass
Beispiel #32
0
def part2():
    # this is a dumb brute-force solution, there are better solutions.
    jmp = 337

    pos = 0
    buff = blist.blist([0])
    for i in range(1, 50000001):
        pos = ((pos + jmp) % len(buff)) + 1
        buff.insert(pos, i)
    return buff[buff.index(0) + 1]
Beispiel #33
0
 def __init__(self, number_of_players, last_marble):
     self.position = 0
     self.number_of_players = number_of_players
     # switch implementation to a BLIST for better performance
     self.sequence = blist([0])
     self.players = [0] * number_of_players
     self.player = 0
     self.last_marble = last_marble
     self.current_marble = 1
     self.counter = 0
Beispiel #34
0
 def __init__(self, n_players, last_marble):
     self.n_players = n_players
     self.last_marble = last_marble
     self.marbles = blist([0])
     self.cur_marble = 0
     self.cur_pos = 0
     self.cur_player = 1
     self.highscores = defaultdict(int)
     self.df = pd.DataFrame(columns=['marble', 'player', 'highscore'])
     self.data = []
Beispiel #35
0
 def __eq__(self, sequence):
     "Flexible equality that implicitly converts 'str' and 'blist' types"
     if isinstance(sequence, DNA):
         return self.blist == sequence.blist
     if isinstance(sequence, blist.blist):
         return self.blist == sequence
     elif isinstance(sequence, str):
         return self.blist == blist.blist(sequence)
     else:
         raise TypeError
Beispiel #36
0
    def __init__(self, t0, w0: torch.Tensor, window_size=8):
        """Initialize brownian path.

        Args:
            t0: float or torch.Tensor for initial time.
            w0: torch.Tensor for initial state.
        """
        super(BrownianPath, self).__init__()
        if not utils.is_scalar(t0):
            raise ValueError('Initial time t0 should be a float or 0-d torch.Tensor.')

        t0 = float(t0)
        self._ts = blist.blist()
        self._ws = blist.blist()
        self._ts.append(t0)
        self._ws.append(w0)

        self._last_idx = 0
        self._window_size = window_size
Beispiel #37
0
def spinlock(steps):
    list_ = blist([0])
    position = 0
    length = 1
    while True:
        position = (position + steps) % length
        list_.insert(position + 1, length)
        position = position + 1
        length += 1
        yield list_
def solve_eqn_sets(solve_sets, modified_vars, solve_func=solve_eqn_set):
    """
    Solve a group of equation sets in which only certain variables
    have been modified.
    """

    # track modified and solved vars
    modified_vars = set(modified_vars)  # don't really need to copy here...
    solved_vars = set()

    # `q` represents the equation sets that are ready to be solved now
    # TODO: threading

    # start queue with all sets that don't require any vars to be solved
    q = [eqs for eqs in solve_sets if not eqs.requires]
    q = blist(q)  # use blist instead of list

    while q:
        # get the next set that is ready to solve
        eqn_set = q.pop(0)

        # solve the eqn_set *if necessary*
        if any(var in eqn_set.requires
               for var in modified_vars) or (any(var in eqn_set.solves
                                                 for var in modified_vars)
                                             and not eqn_set.is_satisfied()):

            if not solve_func(eqn_set):
                print("FAIL")
                return eqn_set  # return the eqn set that failed for reporting

            modified_vars |= eqn_set.solves

        # add all vars solved by this set to the set of solved vars
        solved_vars |= eqn_set.solves

        # create the frontier to add to the queue
        # TODO: much more efficient way to get the frontier
        #  1) don't look at eqn set if it has already been looked at
        #  2) keep track of linked list b/n eqn sets directly
        frontier = set()
        [
            frontier.update(  # add to the frontier
                eqs for eqs in
                var.required_by  # all eqn sets required by by the var
                if all(v in solved_vars for v in eqs.requires
                       )  # if all other required vars have been solved for
            ) for var in eqn_set.solves
        ]  # for each var solved by this eqn set

        q += frontier

    # at this point, modified_vars contains all vars that were updated
    # also, eqn_set should be the final underconstrained set?
    pass
Beispiel #39
0
def unwrap_qg(phase, quality_map):
    """
    Quality Guided Path Following unwrapping algoritm
    This algoritm uses the correlation array as quality map to guide the
    unwrapping path avoiding the tricky zones.

    Note: Correlation as also know as module image.

    Returns the unwrapped phase.
    """

    assert phase.shape == quality_map.shape
    phase = phase.copy()
    shape = phase.shape
    rows, cols = shape

    phase /= tau

    def get_neighbors(pos):
        row = pos / cols
        col = pos % cols
        if row > 0:
            yield pos - cols
        if row < (rows - 1):
            yield pos + cols
        if col > 0:
            yield pos - 1
        if col < (cols - 1):
            yield pos + 1

    phase = phase.ravel()
    adder = {}
    quality_map = quality_map.ravel()
    first_pixel = quality_map.argmax()
    border = blist()

    for pos in get_neighbors(first_pixel):
        adder[pos] = phase[first_pixel]
        insort(border, (quality_map[pos], pos))

    while border:
        quality, pixel = border.pop()
        phase[pixel] -= round(phase[pixel] - adder[pixel])

        for pos in get_neighbors(pixel):
            if pos not in adder:
                adder[pos] = phase[pixel]
                try:
                    insort(border, (quality_map[pos], pos))
                except IndexError:
                    print(quality_map.shape, pos)
                    raise

    phase = phase.reshape(shape) * tau
    return phase
Beispiel #40
0
 def getAllFieldValuesbyColumnsTsvToLst(inputFile):
     df = pd.read_csv(inputFile, sep = '\t', header = 0, index_col = None, quoting=csv.QUOTE_NONE)
     fields = df.columns;
     #print ('field xxx: ', len(fields))
     fieldValLsts = []
     preproc = preprocess() 
     for tbfd in fields:
         valst = preproc.filterNullValue(df[tbfd])
         newLst = blist([tbfd]) + valst
         fieldValLsts.append(newLst)
     return fieldValLsts
 def __init__(self, iterable):
     self.q = q = deque(iterable)
     self.l = l = blist(q)
     l.sort()
     if len(q) % 2 == 1:
         self.odd = True
         self.mididx = (len(q) - 1) // 2
     else:
         self.odd = False
         self.mididx1 = len(q) // 2
         self.mididx2 = len(q) // 2 - 1
Beispiel #42
0
 def __init__(self, sym_mat = None):
     """ input: sym_mat = ajacency matrix of the graph, symetric, 
         of the class Sym_mat """        
     if sym_mat is None:
         self.graph = Sym_mat() 
         self.node_degrees = blist([])
         self.tot_num_edges = 0
     else:
         self.graph = sym_mat
         self.node_degrees = get_graph_degrees_sym(sym_mat)
         self.tot_num_edges = tot_num_edges(sym_mat.matrix)
Beispiel #43
0
def part2(): #using more efficient implementation of lists that allows for O(log n) insert times 
    inp = 329
    cur_pos = 0
    lst = blist([0])
    for i in range(1, 50000000+1):
        cur_pos = (cur_pos+inp) % len(lst)
        lst.insert(cur_pos+1, i)
        cur_pos += 1
    for idx, item in enumerate(lst):
        if item==0:
            pprint(lst[idx+1])
Beispiel #44
0
def question(marbles, num_players):
    scores = blist([0] * num_players)
    current_player = 1
    board = blist([0, 1])
    current_marble_index = 1
    for i in range(2, marbles):
        print(round(i * 100 / marbles, 2))
        board_length = len(board)
        if i % 23 != 0:
            after_index = (current_marble_index + 2) % board_length
            board.insert(after_index, i)
            current_marble_index = after_index
        else:
            scores[current_player - 1] += i
            other_marble_index = (current_marble_index - 7) % board_length
            scores[current_player - 1] += board[other_marble_index]
            del board[other_marble_index]
            current_marble_index = other_marble_index % (board_length - 1)
        current_player = (current_player + 1) % num_players
    return max(scores)
Beispiel #45
0
def steal_next(elfcount=3_014_603):
    circle = blist([elf_id for elf_id in range(1, elfcount+1)])

    target = 0
    elfcount = len(circle)
    while elfcount > 1:
        target = (target+1) % elfcount
        del circle[target]
        elfcount -= 1

    return circle[0]
Beispiel #46
0
    def _add_column(self, column):
        """
        Add a new column to the DataFrame

        :param column: column name
        :return: nothing
        """
        self._columns.append(column)
        if self._blist:
            self._data.append(blist([None] * len(self._index)))
        else:
            self._data.append([None] * len(self._index))
Beispiel #47
0
    def to_array(self):
        if self.sentences is None:
            self.sentences = blist()
            for source, prefix in self.sources.items():
                with utils.smart_open(source) as fin:
                    for item_no, line in enumerate(fin):
                        line = line.replace("\n", "")
                        self.sentences.append(
                            TaggedDocument(utils.to_unicode(line).split(), [prefix + "_%s" % item_no])
                        )

        return self.sentences
Beispiel #48
0
 def test_first_last(self):
     x = EulerTour(None, blist([1, 2, 3, 7, 3, 4, 5, 4, 3, 2, 1]))
     self.assertEqual(x.first_occurrence(1), 0)
     self.assertEqual(x.last_occurrence(1), 10)
     self.assertEqual(x.first_occurrence(7), 3)
     self.assertEqual(x.last_occurrence(7), 3)
     self.assertEqual(x.first_occurrence(5), 6)
     self.assertEqual(x.last_occurrence(5), 6)
     self.assertEqual(x.first_occurrence(3), 2)
     self.assertEqual(x.last_occurrence(3), 8)
     self.assertEqual(x.first_occurrence(8), None)
     self.assertEqual(x.last_occurrence(8), None)
Beispiel #49
0
def day17(iterations=3):
    """Day 17."""
    lst = blist([0])
    indx = 0
    lst_insert = 0
    for i in range(1, 2018):
        indx += 1
        indx %= len(lst)
        lst.insert(indx + 1, i)
        lst_insert = indx + 1
        indx += iterations
    return lst[lst_insert + 1]
Beispiel #50
0
 def ZRANGE(self, zset, start, stop, *flags):
     # TODO: better flags checking
     if len(flags) == 1 and flags[0].upper() == 'WITHSCORES':
         result = blist()
         for key, value in zset.items()[redis_slice(start, stop)]:
             result.append(key)
             astext = '%.17f' % value
             astext = astext.rstrip('0').rstrip('.')
             result.append(astext)
         return result
     else:
         print 'keys'
         return zset.viewkeys()[redis_slice(start, stop)]
Beispiel #51
0
    def test_encodeBlist(self):
        try:
            from blist import blist
        except ImportError:
            return

        b = blist(range(10))
        c = ujson.dumps(b)
        d = ujson.loads(c)

        self.assertEqual(10, len(d))

        for x in xrange(10):
            self.assertEqual(x, d[x])
Beispiel #52
0
def solve(cap,mod = 10**18):
 s = 0
 t_arr = blist([])
 inversions = [0]
 nofd = nofd_fill(cap+2)
 for i in xrange(1,cap+1):
   if i % (5*10**5) == 0:
     print "ON %d" % i
   t = T(i,nofd)
   pos = bisect_right(t_arr,t)
   inversions.append(len(t_arr)-pos)
   t_arr.insert(pos,t)
 print "On Second Stage."
 del t_arr 
 t_arr = blist([])
 for j in xrange(cap,0,-1):
   t = T(j,nofd)
   pos = bisect_left(t_arr,t)
   s = (s + inversions[j]*pos) % mod
   t_arr.insert(pos,t)
   if j % (5*10**5) == 0:
     print "ON %d, sum = %d" % (j,s)    
 return s
Beispiel #53
0
 def ZADD(self, zset, *args):
     assert args, 'syntax error, arguments required'
     assert len(args) % 2 == 0
     pairs = blist()
     # check for errors before doing anything
     for index in xrange(0, len(args), 2):
         score = float(args[index])
         assert not math.isnan(score), "ERR not a valid floating point value"
         member = args[index+1]
         pairs.append((score, member))
     added = 0
     for score, member in pairs:
         if member not in zset:
             added += 1
         zset[member] = score
     return added
Beispiel #54
0
    def pickle_tests(self, pickler):
        self.pickle_test(pickler, blist.blist())
        self.pickle_test(pickler, blist.blist(list(range(limit))))
        self.pickle_test(pickler, blist.blist(list(range(limit+1))))
        self.pickle_test(pickler, blist.blist(list(range(n))))

        x = blist.blist([0])
        x *= n
        self.pickle_test(pickler, x)
        y = blist.blist(x)
        y[5] = 'x'
        self.pickle_test(pickler, x)
        self.pickle_test(pickler, y)
Beispiel #55
0
def bitsort_blist(filename = TDATA, maxn = MAXN):
    """ Sort a file named 'filename' which
    consists of maxn integers where each
    integer is less than maxn.

    Profile result:

      bitsort_blist: 4.84400010109
      memory consuming: 70 MB
    """
    # Initialize bitmap
    a = blist([0])*maxn

    # Read from file and fill bitmap
    for line in file(filename):
        n = int(line.strip())
        # Turn bits on for numbers
        if n<maxn: 
            a[n] = 1
 def to_array(self):
     if self.sentences is None:
         self.sentences = blist()
         for source, prefix in self.sources.items():
             with utils.smart_open(source) as fin:
                 for item_no, line in enumerate(fin):
                     # print [prefix + '_%s' % item_no]
                     line = line.replace("\n", "")
                     # exit()
                     self.sentences.append(
                         TaggedDocument(utils.to_unicode(line).split(), [prefix + "_%s" % item_no])
                     )
                     # self.sentences.append(LabeledSentence(utils.to_unicode(line).split(), [prefix + '_%s' % item_no]))
                     # self.sentences.append(LabeledSentenceMio(utils.to_unicode(line).split(), [prefix + '_%s' % item_no]))
                     # print labe.tags
                     # self.sentences.append(labe)
                     # self.sentences)
                     # perm = np.random.permutation(self.sentences.shape[0])
                     # model_dm.train(all_train_reviews[perm])
     return self.sentences
Beispiel #57
0
def solveCodeJam(algo, inFilePath, outFilePath):
    print('Input : \'{}\'\nOutput : \'{}\''.format(inFilePath, outFilePath))

    inFile = open(inFilePath, 'r')
    d = inFile.read().splitlines()
    inFile.close()
    n, *d = d

    l = len(d)
    b = l//int(n)
    splitTask = (d[i:i+b] for i in range(0, l, b))

    modules = __import__(algo)
    solutions = blist([])
    for i, block in enumerate(splitTask):
        print(i+1, block)
        n, solution = modules.solve(i+1, block)
        solutions.append('Case #{}: {}'.format(n, solution))
    with open(outFilePath, 'w') as outFile:
        outFile.write('\n'.join(solutions))
    print('Done - {} cases'.format(n))