示例#1
0
    def test_benchmark_feedback_arc_set_eades(self):
        # |V| = 4
        pre_time_eades_one = time.time()
        output_solver_one = FinalSolver(self.matrix_input_brute_force_two)
        output_eades_one = output_solver_one.obtain_library_solution(output_solver_one.adj_matrix, force_eades=True)
        post_time_eades_one = time.time()
        solving_time_eades_one = post_time_eades_one - pre_time_eades_one
        self.assertIsNotNone(output_eades_one)
        score_eades_one = scoreSolution(self.matrix_input_brute_force_two, output_eades_one)
        file_string_one = "Eades Approximation, |V| = 4: Score = %.4f, Time = %.4f\n" % (
            score_eades_one,
            solving_time_eades_one,
        )
        self.benchmark_file.write(file_string_one)

        # |V| = 25
        pre_time_eades_two = time.time()
        output_solver_two = FinalSolver(self.matrix_input_brute_force_five)
        output_eades_two = output_solver_two.obtain_library_solution(output_solver_two.adj_matrix)
        post_time_eades_two = time.time()
        solving_time_eades_two = post_time_eades_two - pre_time_eades_two
        self.assertIsNotNone(output_eades_two)
        score_eades_two = scoreSolution(self.matrix_input_brute_force_five, output_eades_two)
        file_string_two = "Eades Approximation, |V| = 25: Score = %.4f, Time = %.4f\n" % (
            score_eades_two,
            solving_time_eades_two,
        )
        self.benchmark_file.write(file_string_two)

        # |V| = 100
        pre_time_eades_three = time.time()
        output_solver_three = FinalSolver(self.matrix_input_size_100)
        output_eades_three = output_solver_three.obtain_library_solution(output_solver_three.adj_matrix)
        post_time_eades_three = time.time()
        solving_time_eades_three = post_time_eades_three - pre_time_eades_three
        self.assertIsNotNone(output_eades_three)
        score_eades_three = scoreSolution(self.matrix_input_size_100, output_eades_three)
        file_string_three = "Eades Approximation, |V| = 100: Score = %.4f, Time = %.4f\n" % (
            score_eades_three,
            solving_time_eades_three,
        )
        self.benchmark_file.write(file_string_three)

        # |V| = 1000
        pre_time_eades_four = time.time()
        output_solver_four = FinalSolver(self.matrix_input_size_1000)
        output_eades_four = output_solver_four.obtain_library_solution(output_solver_four.adj_matrix)
        post_time_eades_four = time.time()
        solving_time_eades_four = post_time_eades_four - pre_time_eades_four
        self.assertIsNotNone(output_eades_four)
        score_eades_four = scoreSolution(self.matrix_input_size_1000, output_eades_four)
        file_string_four = "Eades Approximation, |V| = 1000: Score = %.4f, Time = %.4f\n" % (
            score_eades_four,
            solving_time_eades_four,
        )
        self.benchmark_file.write(file_string_four)
示例#2
0
    def test_benchmark_feedback_arc_set_ip(self):
        # |V| = 2
        pre_time_ip_one = time.time()
        output_solver_one = FinalSolver(self.matrix_input_brute_force_one)
        output_ip_one = output_solver_one.obtain_library_solution(output_solver_one.adj_matrix, force_ip=True)
        post_time_ip_one = time.time()
        solving_time_ip_one = post_time_ip_one - pre_time_ip_one
        self.assertIsNotNone(output_ip_one)
        score_ip_one = scoreSolution(self.matrix_input_brute_force_one, output_ip_one)
        file_string_one = "Ip Approximation, |V| = 2: Score = %.4f, Time = %.4f\n" % (score_ip_one, solving_time_ip_one)
        self.benchmark_file.write(file_string_one)

        # |V| = 4
        pre_time_ip_two = time.time()
        output_solver_two = FinalSolver(self.matrix_input_brute_force_two)
        output_ip_two = output_solver_two.obtain_library_solution(output_solver_two.adj_matrix, force_ip=True)
        post_time_ip_two = time.time()
        solving_time_ip_two = post_time_ip_two - pre_time_ip_two
        self.assertIsNotNone(output_ip_two)
        score_ip_two = scoreSolution(self.matrix_input_brute_force_two, output_ip_two)
        file_string_two = "Ip Approximation, |V| = 4: Score = %.4f, Time = %.4f\n" % (score_ip_two, solving_time_ip_two)
        self.benchmark_file.write(file_string_two)

        # |V| = 8
        pre_time_ip_three = time.time()
        output_solver_three = FinalSolver(self.matrix_input_brute_force_three)
        output_ip_three = output_solver_three.obtain_library_solution(output_solver_three.adj_matrix, force_ip=True)
        post_time_ip_three = time.time()
        solving_time_ip_three = post_time_ip_three - pre_time_ip_three
        self.assertIsNotNone(output_ip_three)
        score_ip_three = scoreSolution(self.matrix_input_brute_force_three, output_ip_three)
        file_string_three = "Ip Approximation, |V| = 8: Score = %.4f, Time = %.4f\n" % (
            score_ip_three,
            solving_time_ip_three,
        )
        self.benchmark_file.write(file_string_three)