def getFrameTrace(self):
		if not self.traceLine:
			return None
		t = np.copy(self.traceLine.getData()[1])
		x1, y1, x2, y2 = self.getFrameRect()
		x1 = max(0, round(x1))
		x2 = min(round(x2), len(t))
		t = t[x1:x2 + 1]
		return (np.arange(0, x2+1 - x1), t)
Пример #2
0
    def getRecording(self):

        recordingArray = np.array(self.recordingList)

        # Time elapsed
        seconds = self.endRecordingTime - self.startRecordingTime
        # Estimate frames per second
        fps = len(self.recordingList) / seconds
        # Add recording to new window
        message = 'Recording (duration: ' + str(round(
            seconds, 2)) + ' s, fps: ' + str(round(fps, 2)) + ')'
        Window(recordingArray, message)
        self.recordingList = []
        return
def import_mat(mat):
    if len(mat) == 0:
        return
    g.mat = mat
    main, reject, r = create_main_data_struct(mat, g.m.MSLDMinSpin.value(), g.m.MSLDMaxSpin.value())
    g.m.trackPlot.waitForUpdate = True
    g.m.minLengthSpin.setValue(4)
    g.m.maxLengthSpin.setValue(20)
    g.m.MSLDMinSpin.setValue(0)
    g.m.MSLDMaxSpin.setValue(round(max([tr['mean_dis_pixel_lag'] for tr in main])))
    g.m.neighborDistanceSpin.setValue(round(max([max(track['dis_pixel_lag']) for track in main])))
    g.m.trackPlot.waitForUpdate = False

    g.m.trackPlot.setTracks(main)
Пример #4
0
def test_prior_mean_valid(binomp):
    """
    * binomial: test_prior_mean_valid -- get prior mean for valid
    parameter.
    """
    # almost equal
    assert round(binomp.prior_mean('p') - 1/2) == 0
Пример #5
0
def scale_values(numbers, num_lines=1, minimum=None, maximum=None):
    "Scale input numbers to appropriate range."

    # find min/max values, ignoring Nones
    filtered = [n for n in numbers if n is not None]
    min_ = min(filtered) if minimum is None else minimum
    max_ = max(filtered) if maximum is None else maximum
    dv = max_ - min_

    # clamp
    numbers = [max(min(n, max_), min_) if n is not None else None for n in numbers]

    if dv == 0:
        values = [4 * num_lines if x is not None else None for x in numbers]
    elif dv > 0:
        num_blocks = len(blocks) - 1

        min_index = 1.
        max_index = num_lines * num_blocks

        values = [
            ((max_index - min_index) * (x - min_)) / dv + min_index
            if not x is None else None for x in numbers
        ]

        values = [round(v) or 1 if not v is None else None for v in values]
    return values
Пример #6
0
def scale_values(numbers, num_lines=1, minimum=None, maximum=None):
    "Scale input numbers to appropriate range."

    # find min/max values, ignoring Nones
    filtered = [n for n in numbers if n is not None]
    min_ = min(filtered) if minimum is None else minimum
    max_ = max(filtered) if maximum is None else maximum
    dv = max_ - min_

    # clamp
    numbers = [
        max(min(n, max_), min_) if n is not None else None for n in numbers
    ]

    if dv == 0:
        values = [4 * num_lines if x is not None else None for x in numbers]
    elif dv > 0:
        num_blocks = len(blocks) - 1

        min_index = 1.
        max_index = num_lines * num_blocks

        values = [((max_index - min_index) * (x - min_)) / dv +
                  min_index if not x is None else None for x in numbers]

        values = [round(v) or 1 if not v is None else None for v in values]
    return values
Пример #7
0
def scale_values(numbers, num_lines=1):
    "Scale input numbers to appropriate range."

    # find min/max values, ignoring Nones
    filtered = [n for n in numbers if n is not None]
    min_ = min(filtered)
    max_ = max(filtered)
    dv = max_ - min_

    if dv == 0:
        values = [4 * num_lines for x in numbers]
    elif dv > 0:
        num_blocks = len(blocks) - 1

        values = [
            (num_blocks - 1.) / dv * x +
            (max_ * 1. - min_ * num_blocks) / dv if not x is None else None
            for x in numbers
        ]

        if num_lines > 1:
            m = min([n for n in values if n is not None])
            values = [
                _rescale(m, m, max_, num_lines *
                         max_, v) if not v is None else None for v in values
            ]
        values = [round(v) or 1 if not v is None else None for v in values]
    return values
def import_mat(mat):
    if len(mat) == 0:
        return
    g.mat = mat
    main, reject, r = create_main_data_struct(mat, g.m.MSLDMinSpin.value(),
                                              g.m.MSLDMaxSpin.value())
    g.m.trackPlot.waitForUpdate = True
    g.m.minLengthSpin.setValue(4)
    g.m.maxLengthSpin.setValue(20)
    g.m.MSLDMinSpin.setValue(0)
    g.m.MSLDMaxSpin.setValue(
        round(max([tr['mean_dis_pixel_lag'] for tr in main])))
    g.m.neighborDistanceSpin.setValue(
        round(max([max(track['dis_pixel_lag']) for track in main])))
    g.m.trackPlot.waitForUpdate = False

    g.m.trackPlot.setTracks(main)
Пример #9
0
def my_round(x):
    """
    The built-in round function behaves differently in Python 2.7 and Python 3.6. We hence use this little
    (useless) function as the code we want the CI to test on the two major python versions
    and make sure our code behaves the same (thanks to the future import).
    :param x: a numerical value
    :return: the rounded value
    """
    return round(x)
Пример #10
0
 def RefreshConnectors(self):
     scaling = self.Parent.GetScaling()
     position = self.Size[1] // 2 + 1
     if scaling is not None:
         position = round(
             (self.Pos.y + position) / scaling[1]) * scaling[1] - self.Pos.y
     self.Input.SetPosition(wx.Point(0, position))
     self.Output.SetPosition(wx.Point(self.Size[0], position))
     self.RefreshConnected()
Пример #11
0
def obs_count(year):
    """ Returns the number of observations in a given year. """
    start_time = time.time()
    obs = sc.textFile("/user/schiefjm/weather/gsod/" + str(year))
    obs = obs.filter(lambda line: "STN" not in line)
    the_count = obs.count()
    end_time = time.time() - start_time

    return year, the_count, round(end_time, 3)
Пример #12
0
 def RefreshConnectors(self):
     scaling = self.Parent.GetScaling()
     height = self.Size[1] - self.Extensions[0] - self.Extensions[1]
     interval = height / max(len(self.Connectors) - 1, 1)
     for i, connector in enumerate(self.Connectors):
         if self.RealConnectors:
             position = self.Extensions[0] + int(
                 round(self.RealConnectors[i] * height))
         else:
             position = self.Extensions[0] + int(round(i * interval))
         if scaling is not None:
             position = round((self.Pos.y + position) /
                              scaling[1]) * scaling[1] - self.Pos.y
         if self.Type == LEFTRAIL:
             connector.SetPosition(wx.Point(self.Size[0], position))
         elif self.Type == RIGHTRAIL:
             connector.SetPosition(wx.Point(0, position))
     self.RefreshConnected()
Пример #13
0
def test_posterior_mean_valid(binomp):
    """
    * binomial: test_posterior_mean_valid -- get posterior mean for valid
    parameter.
    """
    binomp.add_data({'n': 5, 'k': 2})

    # almost equal
    assert round(binomp.posterior_mean('p') - (1+2)/(2+5)) == 0
Пример #14
0
def test_posterior_hdcr_valid(binomp):
    """
    * binomial: test_posterior_hdcr_valid -- get hdcr for posterior.
    """
    binomp.add_data({'n': 5, 'k': 2})

    hdcr = binomp.posterior_high_density_credible_region('p')
    hdcr_true = [0.10482705290430133, 0.76128981963103848]
    
    assert all(round(x-y) == 0 for x, y in zip(hdcr, hdcr_true))
Пример #15
0
def test_posterior_ccr_valid(binomp):
    """
    * binomial: test_posterior_ccr_valid -- get ccr for posterior.
    """
    binomp.add_data({'n': 5, 'k': 2})

    ccr = binomp.posterior_central_credible_region('p')
    ccr_true = [0.11811724875702526, 0.77722190449648787]

    assert all(round(x-y) == 0 for x, y in zip(ccr, ccr_true))
Пример #16
0
def failIfAlmostEqual(self, first, second, places=7, msg=None):
    """Fail if the two objects are equal as determined by their
       difference rounded to the given number of decimal places
       (default 7) and comparing to zero.

       Note that decimal places (from zero) are usually not the same
       as significant digits (measured from the most signficant digit).
    """
    if round(second-first, places) == 0:
        raise AssertionError(msg or '%r == %r within %r places' % (first, second, places))
Пример #17
0
def _try_to_round_number(parameter_string):
    value_as_number = None
    try:
        value_as_number = int(parameter_string)
    except ValueError:
        pass

    if value_as_number is None:
        try:
            value_as_number = round(float(parameter_string), 2)
        except ValueError:
            pass

    return value_as_number
Пример #18
0
 def ProcessDragging(self, movex, movey, event, scaling):
     handle_type, handle = self.Handle
     # A connector has been handled
     if handle_type == HANDLE_CONNECTOR:
         movey = max(-self.BoundingBox.y, movey)
         if scaling is not None:
             position = handle.GetRelPosition()
             movey = round(
                 (self.Pos.y + position.y + movey) /
                 scaling[1]) * scaling[1] - self.Pos.y - position.y
         self.MoveConnector(handle, movey)
         return 0, movey
     elif self.Parent.GetDrawingMode() == FREEDRAWING_MODE:
         return Graphic_Element.ProcessDragging(self, movex, movey, event,
                                                scaling)
     return 0, 0
Пример #19
0
def smooth_func(f, t, window_len=None, window='flat'):
    """Smooth a function f at time samples t"""
    if window_len is None:
        f_ = f(t)
    else:
        dt = t[1] - t[0]
        if np.sum(np.abs(np.diff(t)-dt)) > 1e-5:
            msg = 'samples have to be evenly spaced'
            raise ValueError(msg)
        samples = int(round(window_len / dt))
        N1 = (samples - 1) // 2
        N2 = samples // 2
        t_ = np.hstack((t[0] - N1 * dt + np.arange(N1) * dt, t,
                        t[-1] + dt + np.arange(N2) * dt))
        f_ = f(t_)
        f_ = smooth(f_, samples, method=None, window=window)
    return f_
Пример #20
0
def smooth_func(f, t, window_len=None, window='flat'):
    """Smooth a function f at time samples t"""
    if window_len is None:
        f_ = f(t)
    else:
        dt = t[1] - t[0]
        if np.sum(np.abs(np.diff(t) - dt)) > 1e-5:
            msg = 'samples have to be evenly spaced'
            raise ValueError(msg)
        samples = int(round(window_len / dt))
        N1 = (samples - 1) // 2
        N2 = samples // 2
        t_ = np.hstack((t[0] - N1 * dt + np.arange(N1) * dt, t,
                        t[-1] + dt + np.arange(N2) * dt))
        f_ = f(t_)
        f_ = smooth(f_, samples, method=None, window=window)
    return f_
Пример #21
0
 def DrawHighlightment(self, dc):
     scalex, scaley = dc.GetUserScale()
     dc.SetUserScale(1, 1)
     dc.SetPen(MiterPen(HIGHLIGHTCOLOR, (3 * scalex + 5), wx.SOLID))
     dc.SetBrush(wx.TRANSPARENT_BRUSH)
     dc.SetLogicalFunction(wx.AND)
     # Draw a two circle arcs for representing the coil
     dc.DrawEllipticArc(
         round(self.Pos.x * scalex),
         round((self.Pos.y - int(self.Size[1] * (sqrt(2) - 1.) / 2.) + 1) *
               scaley), round(self.Size[0] * scalex),
         round((int(self.Size[1] * sqrt(2)) - 1) * scaley), 135, 225)
     dc.DrawEllipticArc(
         round(self.Pos.x * scalex),
         round((self.Pos.y - int(self.Size[1] * (sqrt(2) - 1.) / 2.) + 1) *
               scaley), round(self.Size[0] * scalex),
         round((int(self.Size[1] * sqrt(2)) - 1) * scaley), -45, 45)
     dc.SetLogicalFunction(wx.COPY)
     dc.SetUserScale(scalex, scaley)
def keywords_for(*args):
    """
    Return a list of ``Keyword`` objects for the given model instance
    or a model class. In the case of a model class, retrieve all
    keywords for all instances of the model and apply a ``weight``
    attribute that can be used to create a tag cloud.
    """

    # Handle a model instance.
    if isinstance(args[0], Model):
        obj = args[0]
        if hasattr(obj, "get_content_model"):
            obj = obj.get_content_model() or obj
        keywords_name = obj.get_keywordsfield_name()
        keywords_queryset = getattr(obj, keywords_name).all()
        # Keywords may have been prefetched already. If not, we
        # need select_related for the actual keywords.
        prefetched = getattr(obj, "_prefetched_objects_cache", {})
        if keywords_name not in prefetched:
            keywords_queryset = keywords_queryset.select_related("keyword")
        return [assigned.keyword for assigned in keywords_queryset]

    # Handle a model class.
    try:
        app_label, model = args[0].split(".", 1)
    except ValueError:
        return []

    content_type = ContentType.objects.get(app_label=app_label, model=model)
    assigned = AssignedKeyword.objects.filter(content_type=content_type)
    keywords = Keyword.objects.filter(assignments__in=assigned)
    keywords = keywords.annotate(item_count=Count("assignments"))
    if not keywords:
        return []
    settings.use_editable()
    counts = [keyword.item_count for keyword in keywords]
    min_count, max_count = min(counts), max(counts)
    factor = (settings.TAG_CLOUD_SIZES - 1.)
    if min_count != max_count:
        factor /= (max_count - min_count)
    for kywd in keywords:
        kywd.weight = int(round((kywd.item_count - min_count) * factor)) + 1
    return keywords
Пример #23
0
def keywords_for(*args):
    """
    Return a list of ``Keyword`` objects for the given model instance
    or a model class. In the case of a model class, retrieve all
    keywords for all instances of the model and apply a ``weight``
    attribute that can be used to create a tag cloud.
    """

    # Handle a model instance.
    if isinstance(args[0], Model):
        obj = args[0]
        if hasattr(obj, "get_content_model"):
            obj = obj.get_content_model() or obj
        keywords_name = obj.get_keywordsfield_name()
        keywords_queryset = getattr(obj, keywords_name).all()
        # Keywords may have been prefetched already. If not, we
        # need select_related for the actual keywords.
        prefetched = getattr(obj, "_prefetched_objects_cache", {})
        if keywords_name not in prefetched:
            keywords_queryset = keywords_queryset.select_related("keyword")
        return [assigned.keyword for assigned in keywords_queryset]

    # Handle a model class.
    try:
        app_label, model = args[0].split(".", 1)
    except ValueError:
        return []

    content_type = ContentType.objects.get(app_label=app_label, model=model)
    assigned = AssignedKeyword.objects.filter(content_type=content_type)
    keywords = Keyword.objects.filter(assignments__in=assigned)
    keywords = keywords.annotate(item_count=Count("assignments"))
    if not keywords:
        return []
    settings.use_editable()
    counts = [keyword.item_count for keyword in keywords]
    min_count, max_count = min(counts), max(counts)
    factor = (settings.TAG_CLOUD_SIZES - 1.)
    if min_count != max_count:
        factor /= (max_count - min_count)
    for kywd in keywords:
        kywd.weight = int(round((kywd.item_count - min_count) * factor)) + 1
    return keywords
def main():
    """ Runs the script as a stand alone application. """
    global sc
    sc = get_sc()
    print(header.create_header(sc))
    
    power = 5.6
    attempts = 1
    str_1 = string.digits * int(10**power)
    str_2 = str_1[::-1]
    print(len(str_1))
    print("{:>10}{:>8}{:>13}{:>11}"\
          .format("Attempt", "Result", "Size", "Run Time"))
    print("   " + "=" * 39)

    for i in range(attempts):
        start = time.time()
        result, size = is_anagram(str_1, str_2)
        print("{:>9}{:>9}{:>13}{:>11}"\
              .format("{:02}".format(i + 1), 
                      "True" if result else "False",
                      "{:,}".format(size),
                      (str(round(time.time() - start, 2))) + "s"))
Пример #25
0
def assert_almost_equal(lval, rval, digits, message=None):
    """Assert that lval and rval, when rounded to the specified number of digits, are the same."""
    real_message = message or "%r !~= %r" % (lval, rval)
    assert round(lval, digits) == round(rval, digits), real_message
Пример #26
0
 def progbar(self, i, elapsed):
     bar = self.bar(self.percentage(i))
     return "[%s] %i of %i complete in %.1f sec" % (bar, i, self.iterations, round(elapsed, 1))