Beispiel #1
0
 def report_state(self, data):
     state = State.from_json(data)
     if self.state_keeper.challenge_state(state):
         print "Energy of current state:", self.state_evaluator.evaluate(state)
         return 'Accepted'
     else:
         return 'Discarded'
Beispiel #2
0
 def report_state(self, data):
     state = State.from_json(data)
     if self.state_keeper.challenge_state(state):
         print "Energy of current state:", self.state_evaluator.evaluate(state)
         return "Accepted"
     else:
         return "Discarded"
Beispiel #3
0
 def run(self):
     evaluator = TablePositionAgnosticClosnessEvaluator()
     searcher = SingleThreadedSearcher(
         ClosenessStepper(evaluator),
         SquareStateEvaluator(evaluator),
         PrintLogger()
     )
     while True:
         response = requests.get('http://%s:%s/get_best_state' % (self.addr, self.port))
         state = State.from_json(response.content)
         state, _ = searcher.search(state, n=1000)
         requests.post('http://%s:%s/report_state' % (self.addr, self.port), data=state.to_json())
Beispiel #4
0
 def run(self):
     evaluator = TablePositionAgnosticClosnessEvaluator()
     searcher = SingleThreadedSearcher(ClosenessStepper(evaluator),
                                       SquareStateEvaluator(evaluator),
                                       PrintLogger())
     while True:
         response = requests.get('http://%s:%s/get_best_state' %
                                 (self.addr, self.port))
         state = State.from_json(response.content)
         state, _ = searcher.search(state, n=1000)
         requests.post('http://%s:%s/report_state' % (self.addr, self.port),
                       data=state.to_json())
Beispiel #5
0
def _to_state(excel_data):
    """
    @type excel_data: ExcelData
    """
    group_names = []
    group_weights = []
    group_indexes = []

    # Check that placements still respect dimensions constraint
    reset_placement = False
    if excel_data.dimensions is not None:
        for (dimensions_name, sizes), (placement_name, positions) in zip(
                excel_data.dimensions, excel_data.placements):
            if dimensions_name != placement_name:
                reset_placement = True
                break
            for size, position in zip(sizes, positions):
                if size != len(position):
                    reset_placement = True

    if not reset_placement:
        # Allocate room given placement
        cnt = 0
        for placement_name, positions in excel_data.placements:
            group_names.append(placement_name)
            group_indexes.append([cnt, cnt + len(positions)])
            group_weights.append(1)
            cnt += len(positions)
    else:
        # Allocate room given dimensions
        cnt = 0
        for dimension_name, sizes in excel_data.dimensions:
            group_names.append(dimension_name)
            group_indexes.append([cnt, cnt + len(sizes)])
            group_weights.append(1)
            cnt += len(sizes)

    # Allocate room for groups
    placement_names = set(group_names)
    for group_name, group in excel_data.groups:
        group_name, weight_str = re.match(r"\s*([^(]*)\s*(?:\((\d+)\))?",
                                          group_name).groups()
        if weight_str:
            weight = int(weight_str)
        else:
            weight = 1
        if group_name in placement_names:
            continue
        group_names.append(group_name.strip())
        group_indexes.append([cnt, cnt + 1])
        group_weights.append(weight)
        cnt += 1

    names = excel_data.names
    matrix = numpy.zeros((len(names), cnt), dtype=int)
    fixed = numpy.zeros((len(names), cnt), dtype=bool)

    person_index_by_name = {name: i for i, name in enumerate(names)}

    if not reset_placement:
        # Fill in positions from placement
        matrix_col = 0
        for _, positions in excel_data.placements:
            for position in positions:
                for person, is_fixed in position:
                    matrix_row = person_index_by_name[person]
                    matrix[matrix_row, matrix_col] = 1
                    fixed[matrix_row, matrix_col] = is_fixed
                matrix_col += 1
    else:
        # Fill in positions in name order
        groups_by_group_name = {
            group_name: group
            for group_name, group in excel_data.groups
        }
        for (i, j), (dimension_name, sizes) in zip(group_indexes,
                                                   excel_data.dimensions):
            # Traverse names in group with same name (or all persons if there is no such group)
            persons = groups_by_group_name.get(dimension_name, names)
            person_iter = iter(persons)
            try:
                for matrix_col, size in zip(range(i, j), sizes):
                    for _ in range(size):
                        person = next(person_iter)
                        matrix_row = person_index_by_name[person]
                        matrix[matrix_row, matrix_col] = 1
                        fixed[matrix_row, matrix_col] = False
                next(person_iter)
                msg = "Not enough places for all %d persons in '%s' to fit in the given tables." % (
                    len(persons), dimension_name)
                raise Exception(msg)
            except StopIteration:
                pass
        matrix_col = j

    for group_name, group in excel_data.groups:
        if group_name in placement_names:
            continue
        for name in group:
            matrix_row = person_index_by_name[name]
            matrix[matrix_row, matrix_col] = 1
        matrix_col += 1

    geometry = matrix.copy().transpose()

    return State(names=names,
                 group_names=group_names,
                 group_indexes=group_indexes,
                 group_weights=group_weights,
                 seating=matrix,
                 fixed=fixed,
                 geometry=geometry)
Beispiel #6
0
def test_json(initial):
    json = initial.to_json()
    actual = State.from_json(json)
    _assert_same_state(initial, actual)
Beispiel #7
0
def read_text(content):
    """
    @type content: str
    """

    group_names = []
    group_weights = []
    groups = []

    group = []
    position = []

    for line in BytesIO(content):
        if line.startswith('#'):
            name, weight_str = re.match(r"#\s*([^(]*)\s*(?:\((\d+)\))?",
                                        line.strip()).groups()
            group_names.append(name.strip())
            weight = int(weight_str) if weight_str else 1
            group_weights.append(weight)

            if position:
                group.append(position)
                position = []
            if group:
                groups.append(group)
                group = []
        elif line.strip() == '':
            if position:
                group.append(position)
                position = []
        else:
            fixed = line.startswith('*')
            if fixed:
                line = line[1:]
            position.append([line.strip(), fixed])

    if position:
        group.append(position)
    if group:
        groups.append(group)

    matrix_col = 0
    group_indexes = []
    for group in groups:
        group_indexes.append([matrix_col, matrix_col + len(group)])
        matrix_col += len(group)

    names = list({
        name
        for group in groups for position in group for (name, _) in position
    })
    names.sort()

    matrix = numpy.zeros((len(names), group_indexes[-1][1]), dtype=int)
    fixed = numpy.zeros((len(names), group_indexes[-1][1]), dtype=bool)

    persons_by_name = {name: idx for idx, name in enumerate(names)}
    matrix_col = 0
    for group in groups:
        for position in group:
            for name, is_fixed in position:
                matrix_rox = persons_by_name[name]
                matrix[matrix_rox, matrix_col] = 1
                fixed[matrix_rox, matrix_col] = is_fixed
            matrix_col += 1

    geometry = matrix.copy().transpose()

    return State(names=names,
                 group_names=group_names,
                 group_indexes=group_indexes,
                 group_weights=group_weights,
                 seating=matrix,
                 fixed=fixed,
                 geometry=geometry)