def parse_int(symbol_str, value_str, to_add = 1): as_list = to_add.__class__ == ListType assignments_str = None value = None range_value = None if (len(value_str) > 0): (signed, number) = parse_literal(value_str) if (number != None): value = LiteralIntValue(number, signed) int_value = value.value range_value = (RangeList([RangeNode(int_value, int_value, \ to_add)], \ as_list)) else: assignments_str = value_str value = AssignmentsIntValue(value_str) right = value.main_value.right if (right == None): range_value = None else: right_ranges = right.ranges new_ranges = [] for rr in right_ranges: new_ranges.append(RangeNode(rr[0], \ rr[1], \ to_add)) if (len(new_ranges) == 0): range_value = None else: range_value = RangeList(new_ranges, \ as_list) return ParsedInt(symbol_str, value, range_value, to_add)
def vote(self): choices = self._vote() if (choices is None): return None elif (self.rangify): combined_range = RangeList(choices, self.as_list) return [combined_range] else: return choices
def typed_update(self, parsed_value): int_value = parsed_value.value to_add = parsed_value.to_add updated_counts = [] if (int_value == None): parsed_range_value = parsed_value.range_value if (parsed_range_value is None): self.range_list.increment(to_add) else: self.add_range_list(parsed_range_value) elif (int_value.__class__ == LiteralIntValue): value = int_value.value self.add_range_list(RangeList([RangeNode(value, value, \ to_add)], \ self.as_list)) elif (int_value.__class__ == AssignmentsIntValue): right = int_value.main_value.right if (right == None): self.range_list.increment(to_add) else: right_ranges = right.ranges new_ranges = [] for rr in right_ranges: new_ranges.append(RangeNode(rr[0], \ rr[1], \ to_add)) range_list = RangeList(new_ranges, \ self.as_list) if (len(new_ranges) == 0): range_list.increment(to_add) self.add_range_list(range_list) else: throw_error(str(int_value) + \ " is of unknown integer type, " + \ str(int_value.__class__)) if (len(self.range_list.ranges) == 0): rest_count = None if (self.range_list.as_list): rest_count = len(self.range_list.rest) else: rest_count = self.range_list.rest if (rest_count == 0): throw_error("No ranges added") return updated_counts
def parse_int_spec_value_part(range_string): opposite = False if (len(range_string) > 1 and range_string[0] == NOT_MARKER): opposite = True range_string = range_string[1:] ranges = [] range_strings = range_string.split(OUT_RANGES_DELIM) for range_string in range_strings: (least_str, most_str) = range_string.split(OUT_RANGE_DELIM) least = int(least_str) most = int(most_str) ranges.append(RangeNode(least, most)) range_spec = RangeList(ranges) return IntSpecValuePart(opposite, range_spec)
def reparse_int(value_string, to_add = 1): range_value = None if (len(value_string) > 0 and value_string != UNKNOWN_STR): ranges = [] range_strings = value_string.split(OUT_RANGES_DELIM) for range_string in range_strings: (least_str, most_str) = \ range_string.split(OUT_RANGE_DELIM) least = int(least_str) most = int(most_str) ranges.append(RangeNode(least, most)) range_value = RangeList(ranges, to_add) return ParsedInt(None, None, range_value, to_add)
def _cast_vote(self, vote_holder, votes, infallible=None): if (infallible is None): infallible = votes is None total_count = self.branch_stat.get_total_count() if (infallible or votes is None): # Vote that the function is infallible. vote_holder.record_vote(None, 1.0, total_count) else: # Vote for the specific constraints. key_votes = [] for index in votes: key_votes.append(self.vote_points[index][0]) if (self.rangify): error_range = RangeList(key_votes, False) vote_holder.record_vote(error_range, 1.0, \ total_count) else: vote_holder.record_votes(key_votes, \ total_count)
from ranges import RangeNode, RangeList BIG_SINGLE = RangeList([RangeNode(-1024, 1024)]) SMALL_SINGLE = RangeList([RangeNode(0, 32)]) ABOVE_SMALL_SINGLE = RangeList([RangeNode(33, 34), RangeNode(36, 38)]) ABOVE_RESULT = RangeList([RangeNode(0, 32), RangeNode(33, 34), \ RangeNode(36, 38)]) BELOW_SMALL_SINGLE = RangeList([RangeNode(-5, -3), RangeNode(-2, -1)]) BELOW_RESULT = RangeList([RangeNode(-5, -3), RangeNode(-2, -1), \ RangeNode(0, 32)]) WITHIN_BIG = RangeList([RangeNode(-25, -5), RangeNode(-4, -2), \ RangeNode(2, 4), RangeNode(5, 25)]) WITHIN_BIG_RESULT = RangeList([RangeNode(-1024, -26), RangeNode(-25, -5, 2), \ RangeNode(-4, -2, 2), RangeNode(-1, 1), \ RangeNode(2, 4, 2), RangeNode(5, 25, 2), \ RangeNode(26, 1024)]) AROUND_SMALL_SINGLE = RangeList([RangeNode(-5, -3), RangeNode(35, 50)]) AROUND_RESULT = RangeList([RangeNode(-5, -3), RangeNode(0, 32), \ RangeNode(35, 50)]) TOUCH_SMALL_SINGLE_BELOW = RangeList([RangeNode(-5, 3), RangeNode(35, 50)]) TOUCH_BELOW_RESULT = RangeList([RangeNode(-5, -1), RangeNode(0, 3, 2), \ RangeNode(4, 32), RangeNode(35, 50)]) TOUCH_SMALL_SINGLE_ABOVE = RangeList([RangeNode(-5, -3), RangeNode(30, 50)]) TOUCH_ABOVE_RESULT = RangeList([RangeNode(-5, -3), RangeNode(0, 29), \ RangeNode(30, 32, 2), RangeNode(33, 50)])
def __init__(self, threshold_ratio, as_list=False): VoteResult.__init__(self, threshold_ratio, as_list) self.range_votes = RangeList([], as_list)
def __init__(self, as_list=False): ValueStat.__init__(self, INT_TYPE_START, as_list) self.range_list = RangeList([], as_list) self.bound_ranges = RangeList([], False, rest=RangeBinder())
class IntegerStat(ValueStat): def __init__(self, as_list=False): ValueStat.__init__(self, INT_TYPE_START, as_list) self.range_list = RangeList([], as_list) self.bound_ranges = RangeList([], False, rest=RangeBinder()) def add_range_list(self, new_range_list): self.bound_ranges.add(new_range_list.clone_binder()) self.range_list.add(new_range_list) def typed_update(self, parsed_value): int_value = parsed_value.value to_add = parsed_value.to_add updated_counts = [] if (int_value == None): parsed_range_value = parsed_value.range_value if (parsed_range_value is None): self.range_list.increment(to_add) else: self.add_range_list(parsed_range_value) elif (int_value.__class__ == LiteralIntValue): value = int_value.value self.add_range_list(RangeList([RangeNode(value, value, \ to_add)], \ self.as_list)) elif (int_value.__class__ == AssignmentsIntValue): right = int_value.main_value.right if (right == None): self.range_list.increment(to_add) else: right_ranges = right.ranges new_ranges = [] for rr in right_ranges: new_ranges.append(RangeNode(rr[0], \ rr[1], \ to_add)) range_list = RangeList(new_ranges, \ self.as_list) if (len(new_ranges) == 0): range_list.increment(to_add) self.add_range_list(range_list) else: throw_error(str(int_value) + \ " is of unknown integer type, " + \ str(int_value.__class__)) if (len(self.range_list.ranges) == 0): rest_count = None if (self.range_list.as_list): rest_count = len(self.range_list.rest) else: rest_count = self.range_list.rest if (rest_count == 0): throw_error("No ranges added") return updated_counts def show_data(self): return "%s; %s"%(str(self.total_count), \ str(self.range_list)) def _gen_unnormalized(self): unnormalized = IntegerStat() base = None if (self.as_list): base = [1] else: base = 1 unnormalized.range_list = \ self.range_list.gen_normalized(base) return unnormalized def _gen_normalized(self): normalized = IntegerStat() normalized.range_list = \ self.range_list.gen_normalized(self.total_count) return normalized def _add(self, other): total = IntegerStat(self.as_list) total.range_list = self.range_list.clone_flat() total.range_list.add(other.range_list) return total def __iter__(self): return IntegerIter(self) def short_str(self): return range_list.short_str() def is_wanted_key(self, target_key, candidate_key): if (target_key is None): return candidate_key is None elif (candidate_key is None): return False return target_key.contains(candidate_key) def key_is_unknown(self, key): return key == None def has_unknown(self): return self.range_list.has_rest() def covers(self, key): if (self.range_list.has_rest()): if (key is None): return (COVER_EXACT, None) else: return (COVER_OVER, UNKNOWN_STR) elif (key is None): return (COVER_UNDER, UNKNOWN_STR) coverers = self.bound_ranges.get_coverers(key) if (len(coverers) == 0): return (COVER_UNDER, key.short_str()) least = key.least most = key.most beginning = coverers[0].least if (beginning < least): return (COVER_OVER, coverers[0].short_str()) if (beginning > least): missing = RangeNode(least, beginning - 1) return (COVER_UNDER, missing.short_str()) end = coverers[-1].most if (end > most): return (COVER_OVER, coverers[-1].short_str()) if (end < most): missing = RangeNode(end + 1, most) return (COVER_UNDER, missing.short_str()) last_end = least found_over = False over = None for coverer in coverers: binder = coverer.count for bound in binder: if (bound.least < least or most < bound.most): over = bound found_over = True pre_gap = coverer.least - 1 if (last_end < pre_gap): missing = RangeNode(last_end, pre_gap) return (COVER_UNDER, missing.short_str()) last_end = coverer.most + 1 if (found_over): return (COVER_OVER, over.short_str()) return (COVER_EXACT, None) def contains_parsed(self, parsed_value): if (self.range_list.has_rest): return True else: smooth = smoothen(self.range_list) return smooth.contains_list(parsed_value.range_value) def get_overlaps(self, other): return self.range_list.find_overlaps(other.range_list) def get_parsed_overlaps(self, other): return self.range_list.find_overlaps(other.range_value)