Пример #1
0
def main_simulate():
    """Function called to perform the simulation.
    """
    tic = time()

    base_name = ("IA_stream_sel_results_{SNR}_{M}-{modulator}_{Nr}x{Nt}_({Ns})"
                 "_MaxIter_{max_iterations}_({initialize_with})")

    runner = IASimulationRunner('greedy_config_file.txt')
    runner.set_results_filename("greedy_{0}".format(base_name))

    simulate_do_what_i_mean(runner, parent_dir)

    toc = time()
    print("Total Elapsed Time: {0}".format(misc.pretty_time(toc - tic)))
Пример #2
0
def main_simulate():
    """Function called to perform the simulation.
    """
    tic = time()

    base_name = (
        "IA_stream_sel_results_{SNR}_{M}-{modulator}_{Nr}x{Nt}_({Ns})" "_MaxIter_{max_iterations}_({initialize_with})"
    )

    runner = IASimulationRunner("greedy_config_file.txt")
    runner.set_results_filename("greedy_{0}".format(base_name))

    simulate_do_what_i_mean(runner, parent_dir)

    toc = time()
    print("Total Elapsed Time: {0}".format(misc.pretty_time(toc - tic)))
Пример #3
0
    # Calculates the number of bit errors
    num_bit_errors += misc.count_bit_errors(input_data, decoded_symbols)
    num_bits += input_data.size * fundamental.level2bits(M)

    pbar.progress(rep + 1)

# Calculate the Symbol Error Rate
print()
print(num_symbol_errors)
print(num_symbols)
print("SER: {0}".format(float(num_symbol_errors) / float(num_symbols)))
print("BER: {0}".format(float(num_bit_errors) / float(num_bits)))

# xxxxxxxxxx Finished xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
toc = time()
print(misc.pretty_time(toc - tic))

# Resultados
#   272356.0
# 15000000.0
# 0.0181570666667 -> Symbol Error (SNR=15)
# 2m:25s

#  264737.0
# 15000000.0
# 0.0176491333333 -> Symbol Error (SNR=15)
# 2m:31s

# 256828.0
# 15000000.0
# 0.0171218666667
Пример #4
0
    # xxxxx Get configuration filename from command line xxxxxxxxxxxxxxxxxx
    comm_line_parser = OptionParser()
    comm_line_parser.add_option("-c",
                                "--config_file",
                                help="Specify the configuration file",
                                default="find_codebook_config.txt")
    (command_line_options, args) = comm_line_parser.parse_args()

    config_file_name = command_line_options.config_file
    # if config_file_name is None:
    #     config_file_name = "config.txt"
    print('Using Config file: "{0}"'.format(config_file_name))
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    # xxxxx Read configuration from config file xxxxxxxxxxxxxxxxxxxxxxxxxxx
    conf_file_parser = ConfigObj(config_file_name)
    Nt = int(conf_file_parser["Precoder"]["Nt"])
    Ns = int(conf_file_parser["Precoder"]["Ns"])
    K = int(conf_file_parser["Precoder"]["K"])
    rep_max = int(conf_file_parser["Simulation"]["rep_max"])
    #results_folder = conf_file_parser["Simulation"]["results_folder"]
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    #find_codebook_single_process(100)
    find_codebook_multiple_processes(Nt, Ns, K, rep_max)

    toc = time()
    print("Elapsed Time: {0}".format(pretty_time(toc - tic)))
    print("---------- End -------------------------------------------\n\n")
Пример #5
0
    # Calculates the number of bit errors
    num_bit_errors += misc.count_bit_errors(input_data, decoded_symbols)
    num_bits += input_data.size * fundamental.level2bits(M)

    pbar.progress(rep + 1)

# Calculate the Symbol Error Rate
print()
print(num_symbol_errors)
print(num_symbols)
print("SER: {0}".format(float(num_symbol_errors) / float(num_symbols)))
print("BER: {0}".format(float(num_bit_errors) / float(num_bits)))

# xxxxxxxxxx Finished xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
toc = time()
print(misc.pretty_time(toc - tic))

# Resultados
#   272356.0
# 15000000.0
# 0.0181570666667 -> Symbol Error (SNR=15)
# 2m:25s

#  264737.0
# 15000000.0
# 0.0176491333333 -> Symbol Error (SNR=15)
# 2m:31s

# 256828.0
# 15000000.0
# 0.0171218666667
Пример #6
0
    def test_progress(self) -> None:
        self.assertEqual(self.pbar.finalcount, 50)
        self.assertEqual(self.pbar2.finalcount, 25)
        self.assertEqual(self.pbar.n, 0)
        self.assertEqual(self.pbar2.n, 0)

        # Before the first time the progress method is called, the
        # _start_time and _stop_time variables used to track the elapsed
        # time are equal to zero.
        self.assertEqual(self.pbar.elapsed_time, '0.00s')
        self.assertAlmostEqual(self.pbar._start_time, self.tic, places=2)
        self.assertEqual(self.pbar._stop_time, 0.0)

        # Progress 20% (10 is equivalent to 20% of 50)
        self.pbar.progress(10)
        self.assertEqual(self.pbar.n, 10)
        self.assertEqual(
            _get_clear_string_from_stringio_object(self.out),
            # self.out.getvalue(),
            "------------ ProgressbarText Unittest -----------1\n"
            "    1    2    3    4    5    6    7    8    9    0\n"
            "----0----0----0----0----0----0----0----0----0----0\n"
            "**********")

        # After calling the "progress" method but before the progress
        # reaches 100% the _start_time is greater than zero while the
        # _stop_time is still zero.
        self.assertTrue(self.pbar._start_time > 0.0)
        self.assertEqual(self.pbar._stop_time, 0.0)

        # Progress to 70%
        self.pbar.progress(35)
        self.assertEqual(self.pbar.n, 35)
        self.assertEqual(
            _get_clear_string_from_stringio_object(self.out),
            "------------ ProgressbarText Unittest -----------1\n"
            "    1    2    3    4    5    6    7    8    9    0\n"
            "----0----0----0----0----0----0----0----0----0----0\n"
            "***********************************")

        sleep(0.01)

        # Progress to 100% -> Note that in the case of 100% a new line is
        # added at the end.
        #
        # Anything greater than or equal the final count will set the
        # progress to 100%
        self.pbar.progress(55)
        self.assertEqual(self.pbar.n, 50)
        self.assertEqual(
            _get_clear_string_from_stringio_object(self.out),
            "------------ ProgressbarText Unittest -----------1\n"
            "    1    2    3    4    5    6    7    8    9    0\n"
            "----0----0----0----0----0----0----0----0----0----0\n"
            "**************************************************\n")

        # After progress reaches 100 both _start_time and _stop_time
        # variables are greater than zero.
        self.assertTrue(self.pbar._start_time > 0.0)
        self.assertTrue(self.pbar._stop_time > 0.0)
        self.assertEqual(
            self.pbar.elapsed_time,
            pretty_time(self.pbar._stop_time - self.pbar._start_time))

        # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
        # Test with pbar2, which uses the default progress message and the
        # character 'x' to indicate progress.
        self.pbar2.progress(20)
        self.assertEqual(
            _get_clear_string_from_stringio_object(self.out2),
            "------------------- % Progress ------------------1\n"
            "    1    2    3    4    5    6    7    8    9    0\n"
            "----0----0----0----0----0----0----0----0----0----0\n"
            "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")

        self.assertEqual(self.pbar.finalcount, 50)
        self.assertEqual(self.pbar2.finalcount, 25)
Пример #7
0
    def test_pretty_time(self):
        self.assertEqual(misc.pretty_time(0), '0.00s')
        self.assertEqual(misc.pretty_time(2.3), '2.30s')
        self.assertEqual(misc.pretty_time(5.15), '5.15s')
        self.assertEqual(misc.pretty_time(23.44), '23.44s')

        # Note that once we passed one minute, we always use two digits for
        # the seconds
        self.assertEqual(misc.pretty_time(60), '1m:00s')
        self.assertEqual(misc.pretty_time(63), '1m:03s')

        # Note that the seconds are now rounded to the closest integer
        # value.
        self.assertEqual(misc.pretty_time(65.7), '1m:06s')

        # Note that once we passed one hour, we always use two digits for
        # the minutes
        self.assertEqual(misc.pretty_time(3745), '1h:02m:25s')

        self.assertEqual(misc.pretty_time(6000), '1h:40m:00s')
        self.assertEqual(misc.pretty_time(6015), '1h:40m:15s')
        # Lets add two minutes (120 seconds)
        self.assertEqual(misc.pretty_time(6135), '1h:42m:15s')

        self.assertEqual(misc.pretty_time(6137), '1h:42m:17s')
Пример #8
0
def main_simulate(algorithms_to_simulate):
    """
    Function called to perform the simulation.

    Parameters
    ----------
    algorithms_to_simulate : list[str]
        List with the names of the algorithms to simulate.
    """
    tic = time()
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    all_simulation_runner_objs = []

    # xxxxxxxxxx Closed Form Runner xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    if "Closed Form" in algorithms_to_simulate:
        print("Simulating Closed Form algorithm")
        closed_form_runner = ClosedFormSimulationRunner('ia_config_file.txt')

        try:
            closed_form_runner.params.remove('max_iterations')
        except KeyError:
            pass

        try:
            closed_form_runner.params.remove('initialize_with')
        except KeyError:
            pass

        pprint(closed_form_runner.params.parameters)
        # print("IA Solver: {0}\n".format(
        #     closed_form_runner.ia_solver.__class__))
        closed_form_runner.set_results_filename(
            'ia_closed_form_results_{M}-{modulator}_{Nr}x{Nt}_({Ns})')
        all_simulation_runner_objs.append(closed_form_runner)
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    # xxxxxxxxxx Alt. Min. Runner xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    if "Alt Min" in algorithms_to_simulate:
        print("Simulating Alternating Minimizations algorithm")
        alt_min_runner = AlternatingSimulationRunner('ia_config_file.txt')

        try:
            alt_min_runner.params.remove('initialize_with')
        except KeyError:
            pass

        pprint(alt_min_runner.params.parameters)
        # print("IA Solver: {0}\n".format(alt_min_runner.ia_solver.__class__))
        name = ("ia_alt_min_results_{M}-{modulator}_{Nr}x{Nt}_({Ns})"
                "_MaxIter_{max_iterations}")
        alt_min_runner.set_results_filename(name)
        all_simulation_runner_objs.append(alt_min_runner)
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    # xxxxxxxxxx Max SINR Runner xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    if "Max SINR" in algorithms_to_simulate:
        print("Simulating Max SINR algorithm")
        max_sinr_runner = MaxSINRSimulationRunner('ia_config_file.txt')
        pprint(max_sinr_runner.params.parameters)
        # print("IA Solver: {0}\n".format(
        #     max_sinr_runner.ia_solver.__class__))
        name = ("ia_max_sinr_results_{M}-{modulator}_{Nr}x{Nt}_({Ns})"
                "_MaxIter_{max_iterations}_{initialize_with}")
        max_sinr_runner.set_results_filename(name)
        all_simulation_runner_objs.append(max_sinr_runner)
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    # xxxxxxxxxx MMSE Runner xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    if "MMSE" in algorithms_to_simulate:
        print("Simulating MMSE algorithm")
        mmse_runner = MMSESimulationRunner('ia_config_file.txt')
        pprint(mmse_runner.params.parameters)
        # print("IA Solver: {0}\n".format(mmse_runner.ia_solver.__class__))
        name = ("ia_mmse_results_{M}-{modulator}_{Nr}x{Nt}_({Ns})"
                "_MaxIter_{max_iterations}_{initialize_with}")
        mmse_runner.set_results_filename(name)
        all_simulation_runner_objs.append(mmse_runner)
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    simulate_do_what_i_mean(all_simulation_runner_objs, parent_dir)

    # xxxxxxxxxx Some finalization message xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    toc = time()
    print("Total Elapsed Time: {0}".format(misc.pretty_time(toc - tic)))
Пример #9
0
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    tic = time()

    # xxxxx Get configuration filename from command line xxxxxxxxxxxxxxxxxx
    comm_line_parser = OptionParser()
    comm_line_parser.add_option("-c", "--config_file", help="Specify the configuration file", default="find_codebook_config.txt")
    (command_line_options, args) = comm_line_parser.parse_args()

    config_file_name = command_line_options.config_file
    # if config_file_name is None:
    #     config_file_name = "config.txt"
    print('Using Config file: "{0}"'.format(config_file_name))
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    # xxxxx Read configuration from config file xxxxxxxxxxxxxxxxxxxxxxxxxxx
    conf_file_parser = ConfigObj(config_file_name)
    Nt = int(conf_file_parser["Precoder"]["Nt"])
    Ns = int(conf_file_parser["Precoder"]["Ns"])
    K = int(conf_file_parser["Precoder"]["K"])
    rep_max = int(conf_file_parser["Simulation"]["rep_max"])
    #results_folder = conf_file_parser["Simulation"]["results_folder"]
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    #find_codebook_single_process(100)
    find_codebook_multiple_processes(Nt, Ns, K, rep_max)

    toc = time()
    print("Elapsed Time: {0}".format(pretty_time(toc - tic)))
    print("---------- End -------------------------------------------\n\n")
Пример #10
0
    def test_pretty_time(self):
        self.assertEqual(misc.pretty_time(0), '0.00s')
        self.assertEqual(misc.pretty_time(2.3), '2.30s')
        self.assertEqual(misc.pretty_time(5.15), '5.15s')
        self.assertEqual(misc.pretty_time(23.44), '23.44s')

        # Note that once we passed one minute, we always use two digits for
        # the seconds
        self.assertEqual(misc.pretty_time(60), '1m:00s')
        self.assertEqual(misc.pretty_time(63), '1m:03s')

        # Note that the seconds are now rounded to the closest integer
        # value.
        self.assertEqual(misc.pretty_time(65.7), '1m:06s')

        # Note that once we passed one hour, we always use two digits for
        # the minutes
        self.assertEqual(misc.pretty_time(3745), '1h:02m:25s')

        self.assertEqual(misc.pretty_time(6000), '1h:40m:00s')
        self.assertEqual(misc.pretty_time(6015), '1h:40m:15s')
        # Lets add two minuts (120 seconds)
        self.assertEqual(misc.pretty_time(6135), '1h:42m:15s')

        self.assertEqual(misc.pretty_time(6137), '1h:42m:17s')