Python math.inf() Examples

The following are code examples for showing how to use math.inf(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don't like. You can also save this page to your account.

Example 1
Project: Lyra   Author: caterinaurban   File: runner.py    (Mozilla Public License 2.0) View Source Project 6 votes vote down vote up
def _actual_result(self, result, line):
        actual = None
        distance = inf
        if line == -inf:    # precondition
            actual = result.get_node_result(self.cfg.in_node)[0]
            return actual
        elif line == inf:   # postcondition
            actual = result.get_node_result(self.cfg.out_node)[0]
            return actual
        elif line < 0:
            for edge in self.cfg.edges.values():
                if isinstance(edge, Conditional):
                    current = edge.condition.pp.line + line
                    if current < distance:
                        states = result.get_node_result(edge.source)
                        actual = states[0]
                        distance = current
        for node in self.cfg.nodes.values():
            states = result.get_node_result(node)
            for i, stmt in enumerate(node.stmts):
                current = stmt.pp.line - line
                if abs(current) < distance:
                    actual = states[i+1] if current < 0 else states[i]
                    distance = abs(current)
        return actual 
Example 2
Project: TFCommon   Author: MU94W   File: Attention.py    (MIT License) View Source Project 6 votes vote down vote up
def __init__(self, attention_units, memory, sequence_length=None, time_major=True, mode=0):
        self.attention_units    = attention_units
        self.enc_units          = memory.get_shape()[-1].value

        if time_major:
            memory = tf.transpose(memory, perm=(1,0,2))

        self.enc_length = tf.shape(memory)[1]
        self.batch_size = tf.shape(memory)[0]
        self.mode = mode
        self.mask = array_ops.sequence_mask(sequence_length, self.enc_length) if sequence_length is not None else None
        self.tiny = -math.inf * tf.ones(shape=(self.batch_size, self.enc_length))

        self.memory = tf.reshape(memory, (tf.shape(memory)[0], self.enc_length, 1, self.enc_units))
        ### pre-compute Uahj to minimize the computational cost
        with tf.variable_scope('attention'):
            Ua = tf.get_variable(name='Ua', shape=(1, 1, self.enc_units, self.attention_units))
        self.hidden_feats = tf.nn.conv2d(self.memory, Ua, [1,1,1,1], "SAME") 
Example 3
Project: cpsc415   Author: WheezePuppet   File: atlas.py    (license) View Source Project 6 votes vote down vote up
def gen_adj_mat(longs, lats, prob_edge=.2,
                        additional_length=lambda: np.random.exponential(20,1)):
    '''Get an adjacency matrix for the cities whose longitudes and latitudes
    are passed. Each entry will either be a number somewhat greater than the
    crow-flies distance between the two cities (with probability prob_edge),
    or math.inf. The matrix will consist of floats, and be symmetric. The
    diagonal will be all zeroes. The "somewhat greater" is controlled by the
    additional_length parameter, a function returning a random amount.'''

    # Generate full nxn Bernoulli's, even though we'll only use the upper
    # triangle.
    edges = np.random.binomial(1, prob_edge, size=(len(longs),len(longs)))
    am = np.zeros((len(longs),len(longs)))
    for i in range(len(longs)):
        for j in range(len(longs)):
            if i==j:
                am[i,i] = 0
            elif i < j:
                if edges[i,j] == 1:
                    am[i,j] = (math.hypot(longs[i]-longs[j],lats[i]-lats[j])
                        + additional_length())
                    am[j,i] = am[i,j]
                else:
                    am[i,j] = am[j,i] = math.inf
    return np.around(am,1) 
Example 4
Project: technical-interviews   Author: darvid7   File: bellman_ford.py    (license) View Source Project 6 votes vote down vote up
def run_bellman_ford(test_num, num_nodes, make_graph_fn):
    print("\t\t~~~ Test: %s ~~~" % test_num)
    distance = [math.inf for _ in range(num_nodes)]
    parents = [-1 for _ in range(num_nodes)]
    graph, source, target, expected = make_graph_fn()
    no_neg_cycle = bellman_ford(graph, source, parents, distance)
    nodes = graph.get_vertices()
    distances_labeled = []
    for i in range(len(nodes)):
        distances_labeled.append((nodes[i].rep, distance[i]))
    print("Distances labeled: %s" % distances_labeled)
    print("Parents: %s" % parents)
    if no_neg_cycle:
        path = []
        current = target.index
        while current != -1:
            path.append(nodes[current].rep)
            current = parents[current]
        path = path[::-1]
        print("Shortest path from: %s to %s is \n%s" % (source.rep, target.rep, path))
    else:
      print("Has negative cycle, no solution.")
    print("Passed: %s\n" % (expected == distance if no_neg_cycle else no_neg_cycle == expected))

# -------------------------------------- driver functions ---------------------------------------- 
Example 5
Project: technical-interviews   Author: darvid7   File: dijkstra.py    (license) View Source Project 6 votes vote down vote up
def dijkstra(graph, source):
    pq = []
    nodes = graph.get_all_vertices()
    distances = [math.inf] * len(nodes)
    path = [-1] * len(nodes)
    distances[source.index] = 0
    for node in nodes:
        # Store as (priority, task) tuples, heapq will sort on first element.
        heapq.heappush(pq, (distances[node.index], node))
    while pq:
        # Assumes non negative weights, so when popping a node it is the best way to get there.
        dist, node = heapq.heappop(pq)
        for edge in graph.get_adjacent_edges(node):
            # Note: can't terminate early and do this.
            # Eg: (s) -3-> (c) -12-> (d)
            #      \-20->(d) will be wrong
            # if distances[edge.destination.index] != math.inf:  # We already have the shortest path to this node.
            #     continue
            if relax(node, edge.destination, edge, distances):
                # Found a better way to get to a next node, add that to the pq and set the parent.
                heapq.heappush(pq, (distances[edge.destination.index], edge.destination))
                path[edge.destination.index] = node.index
    return distances, path  # Shortest path from source to any other node in distances. 
Example 6
Project: ReGraph   Author: eugeniashurko   File: attribute_sets.py    (license) View Source Project 6 votes vote down vote up
def __str__(self):
        """String representation of IntegerSet obj."""
        interval_strs = []
        for start, end in self.intervals:
            if start > -math.inf:
                start_str = "%d" % start
            else:
                start_str = "-inf"
            if end < math.inf:
                end_str = "%d" % end
            else:
                end_str = "inf"
            if start_str != end_str:
                interval_strs.append("[" + start_str + ", " + end_str + "]")
            else:
                interval_strs.append("{" + start_str + "}")
        return ", ".join(interval_strs) 
Example 7
Project: HoeffdingTree   Author: vitords   File: gaussianconditionalsufficientstats.py    (license) View Source Project 6 votes vote down vote up
def _get_split_point_candidates(self):
        splits = SortedList()
        min_value = math.inf
        max_value = -math.inf

        for class_val, att_estimator in self._class_lookup.items():
            min_val_observed_for_class_val = self._min_val_observed_per_class.get(class_val, None)
            if min_val_observed_for_class_val is not None:
                if min_val_observed_for_class_val < min_value:
                    min_value = min_val_observed_for_class_val
                max_val_observed_for_class_val = self._max_val_observed_per_class.get(class_val)
                if max_val_observed_for_class_val > max_value:
                    max_value = max_val_observed_for_class_val

        if min_value < math.inf:
            new_bin = max_value - min_value
            new_bin /= (self._num_bins + 1)
            for i in range(self._num_bins):
                split = min_value + (new_bin * (i + 1))
                if split > min_value and split < max_value:
                    splits.add(split)
        return splits 
Example 8
Project: hwtLib   Author: Nic30   File: frameForge_test.py    (license) View Source Project 6 votes vote down vote up
def instantiateFrameForge(self, structT,
                              DATA_WIDTH=64,
                              maxFrameLen=inf,
                              maxPaddingWords=inf,
                              trimPaddingWordsOnStart=False,
                              trimPaddingWordsOnEnd=False,
                              randomized=True):
        tmpl = TransTmpl(structT)
        frames = list(FrameTmpl.framesFromTransTmpl(
                                     tmpl,
                                     DATA_WIDTH,
                                     maxFrameLen=maxFrameLen,
                                     maxPaddingWords=maxPaddingWords,
                                     trimPaddingWordsOnStart=trimPaddingWordsOnStart,
                                     trimPaddingWordsOnEnd=trimPaddingWordsOnEnd))
        u = self.u = AxiS_frameForge(AxiStream, structT,
                                     tmpl, frames)
        self.DATA_WIDTH = DATA_WIDTH
        u.DATA_WIDTH.set(self.DATA_WIDTH)

        self.prepareUnit(self.u)
        if randomized:
            self.randomize(u.dataOut)
            for intf in u.dataIn._fieldsToInterfaces.values():
                self.randomize(intf) 
Example 9
Project: trio   Author: python-trio   File: _mock_clock.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, rate=0.0, autojump_threshold=inf):
        # when the real clock said 'real_base', the virtual time was
        # 'virtual_base', and since then it's advanced at 'rate' virtual
        # seconds per real second.
        self._real_base = 0.0
        self._virtual_base = 0.0
        self._rate = 0.0
        self._autojump_threshold = 0.0
        self._autojump_task = None
        self._autojump_cancel_scope = None
        # kept as an attribute so that our tests can monkeypatch it
        self._real_clock = time.monotonic

        # use the property update logic to set initial values
        self.rate = rate
        self.autojump_threshold = autojump_threshold 
Example 10
Project: trio   Author: python-trio   File: _run.py    (license) View Source Project 6 votes vote down vote up
def _might_change_effective_deadline(self):
        try:
            yield
        finally:
            old = self._effective_deadline
            if self.cancel_called or not self._tasks:
                new = inf
            else:
                new = self._deadline
            if old != new:
                self._effective_deadline = new
                runner = GLOBAL_RUN_CONTEXT.runner
                if old != inf:
                    del runner.deadlines[old, id(self)]
                if new != inf:
                    runner.deadlines[new, id(self)] = self 
Example 11
Project: trio   Author: python-trio   File: _run.py    (license) View Source Project 6 votes vote down vote up
def checkpoint():
    """A pure :ref:`checkpoint <checkpoints>`.

    This checks for cancellation and allows other tasks to be scheduled,
    without otherwise blocking.

    Note that the scheduler has the option of ignoring this and continuing to
    run the current task if it decides this is appropriate (e.g. for increased
    efficiency).

    Equivalent to ``await trio.sleep(0)`` (which is implemented by calling
    :func:`checkpoint`.)

    """
    with open_cancel_scope(deadline=-inf) as scope:
        await _core.wait_task_rescheduled(lambda _: _core.Abort.SUCCEEDED) 
Example 12
Project: trio   Author: python-trio   File: _run.py    (license) View Source Project 6 votes vote down vote up
def checkpoint_if_cancelled():
    """Issue a :ref:`checkpoint <checkpoints>` if the calling context has been
    cancelled.

    Equivalent to (but potentially more efficient than)::

        if trio.current_deadline() == -inf:
            await trio.hazmat.checkpoint()

    This is either a no-op, or else it allow other tasks to be scheduled and
    then raises :exc:`trio.Cancelled`.

    Typically used together with :func:`cancel_shielded_checkpoint`.

    """
    task = current_task()
    if (task._pending_cancel_scope() is not None or
        (task is task._runner.main_task and task._runner.ki_pending)):
        await _core.checkpoint()
        assert False  # pragma: no cover
    task._cancel_points += 1 
Example 13
Project: jvcprojectortools   Author: arvehj   File: jvc_gamma.py    (license) View Source Project 6 votes vote down vote up
def get_effective_bsoftclip(self):
        """Return bsoftclip or compute it from paramters and effective bmax"""
        bsoftclip = self.bsoftclip
        if bsoftclip is None:
            return math.inf
        if isinstance(bsoftclip, dict):
            bmax = self.get_effective_bmax()
            bhardclip = self.get_effective_bhardclip()
            bmin = bsoftclip.get('bmin', 0)
            base = bsoftclip.get('bbase', 0)
            scale = bsoftclip.get('scale', 0)
            hcscale = bsoftclip.get('hcscale', math.inf)
            bsoftclip = max(bmin,
                            base + (bmax - base) * scale,
                            max(0, bmax - (bhardclip - bmax) * hcscale))
        return bsoftclip 
Example 14
Project: omnic   Author: michaelpb   File: graph.py    (license) View Source Project 6 votes vote down vote up
def get_shortest_paths(self):
        '''
        Return a dictionary containing lists of all possible paths within the
        graph, keyed by tuple of start and end
        '''
        shortest_paths = {}
        for start in self.edges:
            paths_from_start = self.get_all_paths_from(start)
            for weight, path in paths_from_start:
                end = path[-1]
                if start == end:
                    continue  # Skip over self paths
                shortest, _ = shortest_paths.get(
                    (start, end), (math.inf, None))
                if weight < shortest:
                    shortest_paths[(start, end)] = (weight, path)

        # Overlay preferred paths
        shortest_paths.update(self.preferred_paths)
        return shortest_paths 
Example 15
Project: 2DGraphSearch   Author: JeremySMorgan   File: Graph.py    (license) View Source Project 6 votes vote down vote up
def shortestPath(self,algo):

        # 1) Assign to each node a tentative distance value (0 for initial, inf for all others)
        # 2) Create a set of visited nodes. Starts with initial node
        # 3) For the current node, consider all of its unvisited neighbors and calulate
        #    (distance to the current node) + (dustance from current node to neighbor)
        #    if this calculated value is less than their tentative value, replace the tentative value with this new value
        # 4) Mark the current node visited
        # 5) if the destination node is marked visited, the search is done
        # 6) set the unvisited node marked with the smallest tentative distance as the next 'current node' and repeat from 3


        if algo == "dijkstra":
            return self.dijkstra_search()

        elif algo == "astar":
            return self.astar_search()

        else:
            print("unknown search algorithm.") 
Example 16
Project: tundra   Author: caiopo   File: path.py    (license) View Source Project 6 votes vote down vote up
def floyd_warshall(g: Graph) -> Dict[Vertex, Dict[Vertex, float]]:
    dist: Dict[Vertex, Dict[Vertex, float]] = {}

    vertices = g.vertices

    for v1 in vertices:
        dist[v1] = {}

        for v2 in vertices:
            if v1 is v2:
                dist[v1][v2] = 0
            elif g.has_edge(v1, v2):
                dist[v1][v2] = g.weight[v1, v2]
            else:
                dist[v1][v2] = inf

    for k in vertices:
        for i in vertices:
            for j in vertices:
                if dist[i][j] > dist[i][k] + dist[k][j]:
                    dist[i][j] = dist[i][k] + dist[k][j]

    return dist 
Example 17
Project: openai_lab   Author: kengz   File: ranked.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, env_spec, **kwargs):
        super(HighLowMemory, self).__init__(env_spec)
        # use the old self.exp as buffer, remember to clear
        self.last_exp = self.exp
        self.epi_memory_high = []
        self.epi_memory_low = []
        self.max_reward = -math.inf
        self.min_reward = math.inf
        # 1st  5 epis goes into bad half, recompute every 5 epis
        self.threshold = math.inf
        self.threshold_history = []
        self.epi_num = 0
        self.prob_high = 0.66
        self.num_epis_to_sample = 3
        self.max_epis_in_mem = 15
        self.recompute_freq = 10
        log_self(self) 
Example 18
Project: ultimate-tic-tac-toe   Author: stoimenoff   File: heuristicsbot.py    (license) View Source Project 6 votes vote down vote up
def choose_move(self, macroboard):
        bestmoves = []
        bestscore = - math.inf
        macroboard = deepcopy(macroboard)
        if not macroboard.available_moves:
            raise GameEndedError
        moves = macroboard.available_moves
        for px, py in moves:
            macroboard.make_move(px, py)
            move_score = - score(macroboard)
            # move_score = - greedy_score(macroboard)
            if move_score > bestscore:
                bestscore = move_score
                bestmoves = [(px, py)]
            if move_score == bestscore:
                bestmoves.append((px, py))
            macroboard.undo_last_move()
        return random.choice(bestmoves) 
Example 19
Project: ultimate-tic-tac-toe   Author: stoimenoff   File: minimax.py    (license) View Source Project 6 votes vote down vote up
def minimax(macroboard, depth, maximizing=True):
    """
    Perform a minimax search on a game moves tree.
    If optional parameter maximizing is True, assume that maximizing player
    is on turn. If is False - assume minimizing player. True, by default.
    """
    if macroboard.state != State.IN_PROGRESS or depth <= 0:
        return score(macroboard) * (maximizing * 2 - 1)

    if maximizing:
        bestscore = - math.inf
    else:
        bestscore = math.inf

    moves = macroboard.available_moves
    depth = balance_depth(depth, len(moves))
    for px, py in moves:
        child = deepcopy(macroboard)
        child.make_move(px, py)
        move_score = minimax(child, depth - 1, not maximizing)
        if maximizing:
            bestscore = max(bestscore, move_score)
        else:
            bestscore = min(bestscore, move_score)
    return bestscore 
Example 20
Project: ultimate-tic-tac-toe   Author: stoimenoff   File: gentlemanbot.py    (license) View Source Project 6 votes vote down vote up
def choose_move(self, macroboard):
        worstmoves = []
        macroboard = deepcopy(macroboard)
        moves = macroboard.available_moves
        if not moves:
            raise GameEndedError
        worstscore = math.inf
        depth = balance_depth(DEPTH, len(moves))
        for px, py in moves:
            macroboard.make_move(px, py)
            move_score = alphaBeta(macroboard, depth)
            if move_score < worstscore:
                worstscore = move_score
                worstmoves = [(px, py)]
            if move_score == worstscore:
                worstmoves.append((px, py))
            macroboard.undo_last_move()
        return random.choice(worstmoves) 
Example 21
Project: ccepy   Author: ranea   File: aritmetica_elemental.py    (license) View Source Project 6 votes vote down vote up
def grado(self):
        """Devuelve el grado del polinomio.

            >>> f = PolinomioZp([1, 0, 0, 1], p=2)
            >>> f
            X^3 + 1
            >>> f.grado()
            3

        El grado puede ser:

            * \- :py:data:`math.inf` : si el polinomio es el polinomio cero.
            * ``n`` : si el término lider tiene exponente n.

        Returns:
            int: el grado del polinomio.
        """
        if self == PolinomioZp([0], self.primo()):
            return -math.inf
        else:
            return len(self.coeficientes) - 1 
Example 22
Project: pygame-rl   Author: ebola777   File: soccer_environment.py    (license) View Source Project 6 votes vote down vote up
def _get_nearest_opponent_index(self, team_name, team_agent_index):
    # Get the opponent team name
    opponent_team_name = self.get_opponent_team_name(team_name)
    # Get the agent position
    agent_index = self.get_agent_index(team_name, team_agent_index)
    agent_pos = self.state.get_agent_pos(agent_index)
    # Find the nearest opponent position
    nearest_opponent_index = None
    nearest_dist = math.inf
    for opponent_team_agent_index in range(self.options.team_size):
      opponent_index = self.get_agent_index(
          opponent_team_name, opponent_team_agent_index)
      opponent_pos = self.state.get_agent_pos(opponent_index)
      # Calculate the distance
      dist = self.get_pos_distance(agent_pos, opponent_pos)
      if dist < nearest_dist:
        nearest_opponent_index = opponent_index
        nearest_dist = dist
    return nearest_opponent_index 
Example 23
Project: pygame-rl   Author: ebola777   File: soccer_environment.py    (license) View Source Project 6 votes vote down vote up
def get_bounds(cls, area):
    """Return the rectangular bounds of the area.

    Args:
      area (list): A list of positions.

    Returns:
      list: [x1, y1, x2, y2] where (x1, y1) is the top-left point and (x2, y2)
      is the bottom-right point.
    """
    x1 = math.inf
    y1 = math.inf
    x2 = (-math.inf)
    y2 = (-math.inf)
    for pos in area:
      if pos[0] < x1:
        x1 = pos[0]
      if pos[1] < y1:
        y1 = pos[1]
      if pos[0] > x2:
        x2 = pos[0]
      if pos[1] > y2:
        y2 = pos[1]
    return [x1, y1, x2, y2] 
Example 24
Project: ouroboros   Author: pybee   File: test_cmath.py    (license) View Source Project 6 votes vote down vote up
def test_infinity_and_nan_constants(self):
        # inf wasn't added to the math module until 3.5.
        try:
            inf = math.inf
        except AttributeError:
            inf = float("inf")

        self.assertEqual(cmath.inf.real, inf)
        self.assertEqual(cmath.inf.imag, 0.0)
        self.assertEqual(cmath.infj.real, 0.0)
        self.assertEqual(cmath.infj.imag, inf)

        self.assertTrue(math.isnan(cmath.nan.real))
        self.assertEqual(cmath.nan.imag, 0.0)
        self.assertEqual(cmath.nanj.real, 0.0)
        self.assertTrue(math.isnan(cmath.nanj.imag))

        # Check consistency with reprs.
        self.assertEqual(repr(cmath.inf), "inf")
        self.assertEqual(repr(cmath.infj), "infj")
        self.assertEqual(repr(cmath.nan), "nan")
        self.assertEqual(repr(cmath.nanj), "nanj") 
Example 25
Project: Python-Translators   Author: zeeguu-ecosystem   File: translation_query.py    (license) View Source Project 6 votes vote down vote up
def __init__(self,
                 query: str,
                 before_context: str = '',
                 after_context: str = '',
                 max_translations: int = 1,
                 budget: TranslationBudget = None):
        self.query = query
        self.before_context = before_context
        self.after_context = after_context
        self.max_translations = max_translations
        self.budget = budget

        if self.budget is None:
            self.budget = TranslationBudget(
                time=math.inf,
                money=math.inf,
            ) 
Example 26
Project: Python-Translators   Author: zeeguu-ecosystem   File: web_service.py    (license) View Source Project 6 votes vote down vote up
def hello():
    data = request.get_json()

    source_language, target_language = data['source_language'], data['target_language']

    if (source_language, target_language) not in translators:
        create_translator(source_language, target_language)

    query = TranslationQuery(
        before_context=data['before_context'] if 'before_context' in data else '',
        query=data['query'] if 'query' in data else '',
        after_context=data['after_context'] if 'after_context' in data else '',
        max_translations=data['max_translations'] if 'max_translations' in data else 10,
        budget=TranslationBudget(
            money=data['budget']['money'] if ('budget' in data and 'money' in data['budget']) else math.inf,
            time=data['budget']['time'] if ('budget' in data and 'time' in data['budget']) else math.inf
        )
    )

    translator = translators[(source_language, target_language)]

    response = translator.translate(query)

    return Response(response.to_json(), mimetype='text/json') 
Example 27
Project: Python   Author: TheAlgorithms   File: LazySegmentTree.py    (license) View Source Project 6 votes vote down vote up
def query(self, idx, l, r, a, b): #query(1, 1, N, a, b) for query max of [a,b]
        if self.flag[idx] == True:
            self.st[idx] = self.lazy[idx]
            self.flag[idx] = False
            if l != r:
                self.lazy[self.left(idx)] = self.lazy[idx]
                self.lazy[self.right(idx)] = self.lazy[idx]
                self.flag[self.left(idx)] = True
                self.flag[self.right(idx)] = True
        if r < a or l > b:
            return -math.inf
        if l >= a and r <= b:
            return self.st[idx]
        mid = (l+r)//2
        q1 = self.query(self.left(idx),l,mid,a,b)
        q2 = self.query(self.right(idx),mid+1,r,a,b)
        return max(q1,q2) 
Example 28
Project: vectorvondoom   Author: bcj   File: geometry.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, a: Point, b: Point, precision: int=PRECISION) -> None:
        x_diff = round(a.x, precision) - round(b.x, precision)
        y_diff = round(a.y, precision) - round(b.y, precision)

        if x_diff < 0 or (x_diff == 0 and a.y < b.y):
            self._start, self._end = a, b
        else:
            self._start, self._end = b, a

        if a == b:
            self._slope = None
            self._offset = None
        elif x_diff == 0:
            self._slope = math.inf
            self._offset = self._start.x
        else:
            self._slope = y_diff / x_diff
            self._offset = self._start.y - (self._start.x * self._slope)

        self._precision = precision 
Example 29
Project: RNNVis   Author: myaooo   File: data_utils.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, data, batch_size, num_steps=None, offset=0, epoch_num=None, transpose=False):
        self.i = 0
        self.data = data
        self.max_length = data.shape[1]
        self.num_steps = self.max_length if num_steps is None else num_steps
        self._sentence_size = self.max_length // self.num_steps
        self.batch_size = batch_size
        self.max_epoch_num = math.inf if epoch_num is None else int(epoch_num)
        self.epoch_num = 0
        self.offset = offset
        self.transpose = transpose
        self._epoch_size = self.data.shape[0] // batch_size * self.sentence_size
        self.embedding = data.ndim == 3
        _shape = [self.num_steps, batch_size] if transpose else [batch_size, self.num_steps]
        if self.embedding:
            _shape.append(data.shape[2])
        self._shape = _shape 
Example 30
Project: hashcode2016   Author: MartaAndres   File: Solution.py    (license) View Source Project 6 votes vote down vote up
def cost(order_num):
        min_coste = math.inf
        ware_optima = 0
        inst = self.instance
        (cx,cy,cprods) = inst.orders[order_num]
    
        # Para cada warehouse
        for wn in range(len(warehouses)):
            (wx,wy,wprods) = warehouses[wn]
            
            # Comprueba que aquí esté todo
            for cosa in cprods:
                if cosa not in wprods: 
                    continue
            
            # Calcula el coste
            coste = dist((self.x,self.y), (wx,wy)) + dist((wx,wy), (cx,cy)) + 2 #+1 por el load y el delivery
            if (coste < min_coste):
                ware_optima = wn
                min_coste = coste
    
        return (coste, wn) 
Example 31
Project: DHV2   Author: DuckHunt-discord   File: scores.py    (license) View Source Project 6 votes vote down vote up
def topScores(channel, stat='exp', reverse=False):
    columns = ['name', 'exp', 'killed_ducks', 'shoots_fired']

    if stat not in columns:
        columns.append(stat)

    table = getChannelPlayers(channel, columns=columns)
    players_list = []

    for player in table:
        if checks.is_player_check(player):
            players_list.append(player)
            # print(str(player["name"]) + " | " + str(player["exp"]) + "|" +  str(player["killed_ducks"]))

    try:
        # Retourne l'ensemble des joueurs dans une liste par stat
        # FIXME : le truc de l'infini est un moyen dégueulasse de ne pas avoir "None" devant 0 pour best_time
        #           éventuellement on pourrait ne pas mettre les gens avec None dans le top (à faire dans exp.py)
        return sorted(players_list, key=lambda k: (k.get(stat, None) or (math.inf if stat == 'best_time' else 0)), reverse=not reverse)
    except:
        return [] 
Example 32
Project: ReGraph   Author: Kappa-Dev   File: attribute_sets.py    (license) View Source Project 6 votes vote down vote up
def __str__(self):
        """String representation of IntegerSet obj."""
        interval_strs = []
        for start, end in self.intervals:
            if start > -math.inf:
                start_str = "%d" % start
            else:
                start_str = "-inf"
            if end < math.inf:
                end_str = "%d" % end
            else:
                end_str = "inf"
            if start_str != end_str:
                interval_strs.append("[" + start_str + ", " + end_str + "]")
            else:
                interval_strs.append("{" + start_str + "}")
        return ", ".join(interval_strs) 
Example 33
Project: take10   Author: fluffymuffin27   File: sizes.py    (license) View Source Project 6 votes vote down vote up
def typical_height(csize: SizeClass, metric: bool=False) -> (float, float):
    """
    Returns the minimum/maximum height range for a creature of the given size.

    Values are given in feet by default.

    """
    size_to_height = {
        SizeClass.Fine: (0.0, 0.5),
        SizeClass.Diminutive: (0.5, 1),
        SizeClass.Tiny: (1, 2),
        SizeClass.Small: (2, 4),
        SizeClass.Medium: (4, 8),
        SizeClass.Large: (8, 16),
        SizeClass.Huge: (16, 32),
        SizeClass.Gargantuan: (32, 64),
        SizeClass.Colossal: (64, inf),
    }
    height = size_to_height[csize]
    return height * 0.3048 if metric else height 
Example 34
Project: take10   Author: fluffymuffin27   File: sizes.py    (license) View Source Project 6 votes vote down vote up
def typical_weight(csize: SizeClass, metric: bool=False) -> (float, float):
    """
    Returns the minimum/maximum weight range for a creature of the given size.

    Values are given in pounds by default.
    """
    size_to_weight = {
        SizeClass.Fine: (0.0, 0.125),
        SizeClass.Diminutive: (0.125, 1),
        SizeClass.Tiny: (1, 8),
        SizeClass.Small: (8, 60),
        SizeClass.Medium: (60, 500),
        SizeClass.Large: (500, 4000),
        SizeClass.Huge: (4000, 32000),
        SizeClass.Gargantuan: (32000, 250000),
        SizeClass.Colossal: (250000, inf),
    }
    weight = size_to_weight[csize]
    return weight * 0.45359237 if metric else weight 
Example 35
Project: Hanabi-AI   Author: MeGotsThis   File: server.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def isGameComplete(self) -> bool:
        if self.strikes == 3 or self.score >= self.maxScore:
            return True
        if self.turnCount > (self.endTurn or math.inf):
            return True
        return False 
Example 36
Project: Lyra   Author: caterinaurban   File: used_liststart.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def __init__(self, s: float = 0, u: float = 0, o: float = 0):
        """Used list start analysis abstract domain representation.
        
        :param s: initial end of S-elements in list: should be a float in ``[0,1,2,..., inf]``
        :param u: initial end of U-elements in list: should be a float in ``[0,1,2,..., inf]``
        :param o: initial end of O-elements in list: should be a float in ``[0,1,2,..., inf]``
        """
        super().__init__()
        self._suo = OrderedDict([
            (S, s),
            (U, u),
            (O, o)
        ]) 
Example 37
Project: Lyra   Author: caterinaurban   File: used_liststart.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def is_top(self) -> bool:
        return all(upper == inf for upper in self.suo.values()) 
Example 38
Project: Lyra   Author: caterinaurban   File: test_usedListStartLattice.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def test_combine(self):
        # we assume that following test lists are 6 element long (implicit, not necessary to specify)

        a = UsedListStartLattice(6, 4, 0)  # UUUUSS
        b = UsedListStartLattice(0, 2, 6)  # UUOOOO
        ab = a.combine(b)
        self.assertEqual(list(ab.suo.values()), [0, 2, 6])  # UUOOOO

        a = UsedListStartLattice(6, 4, 0)  # UUUUSS
        b = UsedListStartLattice(6, 2, 0)  # UUSSSS
        ab = a.combine(b)
        self.assertEqual(list(ab.suo.values()), [6, 4, 0])  # UUUUSS

        a = UsedListStartLattice(4, 2, 0)  # UUSSNN
        b = UsedListStartLattice(0, 2, 5)  # UUOOON
        ab = a.combine(b)
        self.assertEqual(list(ab.suo.values()), [0, 2, 5])  # UUOOON

        a = UsedListStartLattice(0, 5, 0)  # UUUUUN
        b = UsedListStartLattice(0, 2, 5)  # UUOOON
        ab = a.combine(b)
        self.assertEqual(list(ab.suo.values()), [0, 2, 5])  # UUOOON

        # we assume that following test lists are infinite long

        a = UsedListStartLattice(inf, 2, 0)  # UUSSSS...
        b = UsedListStartLattice(0, inf, 0)  # UUUUUU...
        ab = a.combine(b)
        self.assertEqual(list(ab.suo.values()), [0, inf, 0])  # UUUUUU...

        a = UsedListStartLattice(0, inf, 0)  # UUUUUU...
        b = UsedListStartLattice(0, 0, inf)  # OOOOOO...
        ab = a.combine(b)
        self.assertEqual(list(ab.suo.values()), [0, 0, inf])  # OOOOOO... 
Example 39
Project: Lyra   Author: caterinaurban   File: dbm.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def nan2inf(f):
    return inf if isnan(f) else f 
Example 40
Project: Lyra   Author: caterinaurban   File: dbm.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def __init__(self, size):
        assert size % 2 == 0, "The size of a CDBM has to be even!"

        self._size = size
        self._m = []
        for i in range(size):
            row = [inf] * min((i + 2) // 2 * 2, size)
            self._m.append(row) 
Example 41
Project: Lyra   Author: caterinaurban   File: interval_domain.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def is_top(self) -> bool:
        return self.lower == -inf and self.upper == inf 
Example 42
Project: Lyra   Author: caterinaurban   File: interval_domain.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def _widening(self, other: 'IntervalLattice') -> 'IntervalLattice':
        """``[a, b] ? [c, d] = [(c < a? -oo : a), (b < d? +oo : b)]``."""
        lower = self.lower
        upper = self.upper
        if other.lower < self.lower:
            lower = -inf
        if self.upper < other.upper:
            upper = inf
        return self.replace(IntervalLattice(lower, upper))

    # arithmetic operations 
Example 43
Project: Lyra   Author: caterinaurban   File: octagon_domain.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def __repr__(self):
        if self.is_bottom():
            return "?"
        elif self.is_top():
            return "?"
        else:
            res = []
            # represent unary constraints first
            for var in self.variables:
                lower = - self[PLUS, var, MINUS, var] // 2
                upper = self[MINUS, var, PLUS, var] // 2
                if lower < inf and upper < inf:
                    res.append(f"{lower}?{var.name}?{upper}")
                elif lower < inf:
                    res.append(f"{lower}?{var.name}")
                elif upper < inf:
                    res.append(f"{var.name}?{upper}")
            # represent binary constraints second, do not repeat identical inequalities
            for i, var1 in enumerate(self.variables):
                for j, var2 in enumerate(self.variables):
                    if i > j:
                        c = self[MINUS, var1, PLUS, var2]
                        if c < inf:
                            res.append(f"{var1.name}+{var2.name}?{c}")
                        c = self[MINUS, var1, MINUS, var2]
                        if c < inf:
                            res.append(f"{var1.name}-{var2.name}?{c}")
                        c = self[PLUS, var1, PLUS, var2]
                        if c < inf:
                            res.append(f"-{var1.name}+{var2.name}?{c}")
                        c = self[PLUS, var1, MINUS, var2]
                        if c < inf:
                            res.append(f"-{var1.name}-{var2.name}?{c}")
            return ", ".join(res) 
Example 44
Project: Lyra   Author: caterinaurban   File: octagon_domain.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def top(self):
        for key in self.dbm.keys():
            self.dbm[key] = inf
        return self 
Example 45
Project: Lyra   Author: caterinaurban   File: octagon_domain.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def is_top(self) -> bool:
        return all([isinf(b) for k, b in self.dbm.items() if k[0] != k[1]])  # check all inf, ignore diagonal for check 
Example 46
Project: Lyra   Author: caterinaurban   File: octagon_domain.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def forget(self, var: VariableIdentifier):
        # close first to not lose implicit constraints about other variables
        self.close()

        # forget binary constraints
        for index in self.binary_constraints_indices(sign1=None, var1=var):
            self[index] = inf

        # forget unary constraints
        self[PLUS, var, MINUS, var] = inf
        self[MINUS, var, PLUS, var] = inf 
Example 47
Project: Lyra   Author: caterinaurban   File: runner.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def _expected_result(self):
        initial = re.compile('INITIAL:?\s*(?P<state>.*)')
        state = re.compile('STATE:?\s*(?P<state>.*)')
        loop = re.compile('LOOP:?\s*(?P<state>.*)')
        final = re.compile('FINAL:?\s*(?P<state>.*)')
        for token in tokenize.tokenize(io.BytesIO(self.source.encode('utf-8')).readline):
            if token.type == tokenize.COMMENT:
                comment = token.string.strip("# ")
                initial_match = initial.match(comment)
                state_match = state.match(comment)
                loop_match = loop.match(comment)
                final_match = final.match(comment)
                if initial_match:
                    result = initial_match.group('state')
                    line = -inf                 # -inf for a precondition
                    yield line, result
                if state_match:
                    result = state_match.group('state')
                    line = token.start[0]
                    yield line, result
                if loop_match:
                    result = loop_match.group('state')
                    line = -token.start[0]      # negative line number for a loop invariant
                    yield line, result
                if final_match:
                    result = final_match.group('state')
                    line = inf                  # inf for a postcondition
                    yield line, result 
Example 48
Project: Lyra   Author: caterinaurban   File: test_IntervalLattice.py    (Mozilla Public License 2.0) View Source Project 5 votes vote down vote up
def test_init(self):
        self.assertFalse(IntervalLattice().is_bottom())
        self.assertTrue(IntervalLattice().is_top())

        self.assertFalse(IntervalLattice(0, 1).is_bottom())
        self.assertFalse(IntervalLattice(0, 1).is_top())

        self.assertEqual(IntervalLattice(upper=2), IntervalLattice(-inf, 2))
        self.assertEqual(IntervalLattice(lower=3), IntervalLattice(3, inf))

        self.assertTrue(IntervalLattice(1, 0).is_bottom())
        self.assertFalse(IntervalLattice(1, 0).is_top()) 
Example 49
Project: pheweb   Author: statgen   File: qq.py    (MIT License) View Source Project 5 votes vote down vote up
def make_qq_unstratified(variants, include_qq):
    neglog10_pvals = sorted((v.neglog10_pval for v in variants), reverse=True)
    rv = {}
    if include_qq:
        rv['qq'] = compute_qq(neglog10_pvals)
    rv['count'] = len(neglog10_pvals)
    rv['gc_lambda'] = {}
    for perc in ['0.5', '0.1', '0.01', '0.001']:
        gc = gc_value_from_list(neglog10_pvals, float(perc))
        if math.isnan(gc) or abs(gc) == math.inf:
            print('WARNING: got gc_value {!r}'.format(gc))
        else:
            rv['gc_lambda'][perc] = round_sig(gc, 5)
    return rv 
Example 50
Project: pheweb   Author: statgen   File: utils.py    (MIT License) View Source Project 5 votes vote down vote up
def round_sig(x, digits):
    if x == 0:
        return 0
    elif abs(x) == math.inf or math.isnan(x):
        raise ValueError("Cannot round infinity or NaN")
    else:
        log = math.log10(abs(x))
        digits_above_zero = int(math.floor(log))
        return round(x, digits - 1 - digits_above_zero)