diff --git a/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc index 51b6c9843..a03c25a97 100644 --- a/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc @@ -57,7 +57,10 @@ BeidouB1iPcpsAcquisition::BeidouB1iPcpsAcquisition( LOG(INFO) << "role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; fs_in_ = acq_parameters_.fs_in; diff --git a/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.h b/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.h index 54cd5aa7a..b80804a18 100644 --- a/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.h @@ -170,17 +170,12 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; unsigned int channel_; std::weak_ptr channel_fsm_; float threshold_; unsigned int doppler_max_; unsigned int doppler_step_; - unsigned int max_dwells_; int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc index 84cec6a04..2c603abd5 100644 --- a/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc @@ -55,7 +55,10 @@ BeidouB3iPcpsAcquisition::BeidouB3iPcpsAcquisition( LOG(INFO) << "role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; item_type_ = acq_parameters_.item_type; diff --git a/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.h b/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.h index 2ea6b3284..54c26aac9 100644 --- a/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.h @@ -169,17 +169,12 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; unsigned int channel_; std::weak_ptr channel_fsm_; float threshold_; unsigned int doppler_max_; unsigned int doppler_step_; - unsigned int max_dwells_; int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc index acc8373eb..41d3f6b39 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc @@ -54,7 +54,10 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition( DLOG(INFO) << "role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; item_type_ = acq_parameters_.item_type; diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.h b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.h index bdc9d08cf..2870ebe0f 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.h +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.h @@ -173,8 +173,6 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; bool acquire_pilot_; unsigned int channel_; std::weak_ptr channel_fsm_; @@ -183,10 +181,7 @@ private: unsigned int doppler_step_; int doppler_center_; unsigned int sampled_ms_; - unsigned int max_dwells_; int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc index 88ae101c2..01ec6a16a 100644 --- a/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc @@ -53,7 +53,10 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con DLOG(INFO) << "Role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; item_type_ = acq_parameters_.item_type; diff --git a/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.h b/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.h index 94c80b0c1..136720090 100644 --- a/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.h @@ -162,11 +162,7 @@ private: std::string item_type_; std::string dump_filename_; std::string role_; - bool bit_transition_flag_; - bool dump_; bool acq_pilot_; - bool use_CFAR_; - bool blocking_; bool acq_iq_; unsigned int vector_length_; unsigned int code_length_; @@ -176,7 +172,6 @@ private: unsigned int doppler_step_; int doppler_center_; unsigned int sampled_ms_; - unsigned int max_dwells_; unsigned int in_streams_; unsigned int out_streams_; int64_t fs_in_; diff --git a/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc index c62b03d9b..fb632b5d8 100644 --- a/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc @@ -56,7 +56,10 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition( DLOG(INFO) << "role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; item_type_ = acq_parameters_.item_type; diff --git a/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.h b/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.h index e55b5a744..bcd992929 100644 --- a/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.h @@ -165,18 +165,13 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; unsigned int channel_; std::weak_ptr channel_fsm_; float threshold_; unsigned int doppler_max_; unsigned int doppler_step_; unsigned int sampled_ms_; - unsigned int max_dwells_; int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc index 353a26c6d..625d9ab18 100644 --- a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc @@ -55,7 +55,10 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition( DLOG(INFO) << "role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; item_type_ = acq_parameters_.item_type; diff --git a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.h b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.h index bfe35d0cb..c98e47db5 100644 --- a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.h @@ -164,18 +164,13 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; unsigned int channel_; std::weak_ptr channel_fsm_; float threshold_; unsigned int doppler_max_; unsigned int doppler_step_; unsigned int sampled_ms_; - unsigned int max_dwells_; int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc index 4eaf93255..c24a24134 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc @@ -59,7 +59,10 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition( DLOG(INFO) << "role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.h b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.h index b66db4526..0bd8e1c7b 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.h @@ -177,8 +177,6 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; unsigned int channel_; std::weak_ptr channel_fsm_; float threshold_; @@ -186,10 +184,6 @@ private: unsigned int doppler_step_; int doppler_center_; unsigned int sampled_ms_; - unsigned int max_dwells_; - int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc index e9c09de3b..4502cebf6 100644 --- a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc @@ -56,7 +56,10 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition( DLOG(INFO) << "Role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; item_type_ = acq_parameters_.item_type; diff --git a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h index 01d3e80c9..6d8abe994 100644 --- a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h @@ -174,18 +174,13 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; unsigned int channel_; std::weak_ptr channel_fsm_; float threshold_; unsigned int doppler_max_; unsigned int doppler_step_; int doppler_center_; - unsigned int max_dwells_; int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc index 9c05a29be..987fcc71d 100644 --- a/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc @@ -56,7 +56,10 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition( DLOG(INFO) << "role " << role; - if (FLAGS_doppler_max != 0) acq_parameters_.doppler_max = FLAGS_doppler_max; + if (FLAGS_doppler_max != 0) + { + acq_parameters_.doppler_max = FLAGS_doppler_max; + } doppler_max_ = acq_parameters_.doppler_max; doppler_step_ = acq_parameters_.doppler_step; diff --git a/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.h b/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.h index fbc7df3f6..7a44e0e56 100644 --- a/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.h +++ b/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.h @@ -174,18 +174,13 @@ private: std::string item_type_; unsigned int vector_length_; unsigned int code_length_; - bool bit_transition_flag_; - bool use_CFAR_algorithm_flag_; unsigned int channel_; std::weak_ptr channel_fsm_; float threshold_; unsigned int doppler_max_; unsigned int doppler_step_; int doppler_center_; - unsigned int max_dwells_; int64_t fs_in_; - bool dump_; - bool blocking_; std::string dump_filename_; std::vector> code_; Gnss_Synchro* gnss_synchro_; diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc index 48a87673c..42d5ca210 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc @@ -878,7 +878,9 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) bool was_step_two = d_step_two; d_step_two = false; if (was_step_two) - calculate_threshold(); + { + calculate_threshold(); + } send_negative_acquisition(); } } @@ -913,12 +915,15 @@ bool pcps_acquisition::start() return true; } -void pcps_acquisition::calculate_threshold(void) + +void pcps_acquisition::calculate_threshold() { float pfa = (d_step_two ? acq_parameters.pfa2 : acq_parameters.pfa); if (pfa <= 0.0) - return; + { + return; + } int effective_fft_size = (acq_parameters.bit_transition_flag ? (d_fft_size / 2) : d_fft_size); int num_doppler_bins = (d_step_two ? d_num_doppler_bins_step2 : d_num_doppler_bins); @@ -928,6 +933,7 @@ void pcps_acquisition::calculate_threshold(void) d_threshold = 2.0 * boost::math::gamma_p_inv(2 * acq_parameters.max_dwells, std::pow(1.0 - pfa, 1.0 / static_cast(num_bins))); } + int pcps_acquisition::general_work(int noutput_items __attribute__((unused)), gr_vector_int& ninput_items, gr_vector_const_void_star& input_items, diff --git a/src/algorithms/acquisition/libs/acq_conf.cc b/src/algorithms/acquisition/libs/acq_conf.cc index 21fa8a369..8278debe0 100644 --- a/src/algorithms/acquisition/libs/acq_conf.cc +++ b/src/algorithms/acquisition/libs/acq_conf.cc @@ -46,8 +46,8 @@ Acq_Conf::Acq_Conf() doppler_min = -5000; num_doppler_bins_step2 = 4U; doppler_step2 = 125.0; - pfa = 0.0; - pfa2 = 0.0; + pfa = 0.001; + pfa2 = 0.001; fs_in = 4000000; samples_per_ms = 0.0; samples_per_code = 0.0; @@ -114,7 +114,9 @@ void Acq_Conf::SetFromConfiguration(ConfigurationInterface *configuration, pfa = configuration->property(role + ".pfa", pfa); pfa2 = configuration->property(role + ".pfa_second_step", pfa2); if (pfa2 <= 0.0) - pfa2 = pfa; + { + pfa2 = pfa; + } make_2_steps = configuration->property(role + ".make_two_steps", make_2_steps); blocking_on_standby = configuration->property(role + ".blocking_on_standby", blocking_on_standby); diff --git a/src/algorithms/libs/item_type_helpers.cc b/src/algorithms/libs/item_type_helpers.cc index ae1a655a7..8359407b3 100644 --- a/src/algorithms/libs/item_type_helpers.cc +++ b/src/algorithms/libs/item_type_helpers.cc @@ -47,6 +47,7 @@ bool item_type_valid(const std::string &item_type) return true; } + size_t item_type_size(const std::string &item_type) { if (item_type == "byte" or item_type == "ibyte") @@ -57,7 +58,7 @@ size_t item_type_size(const std::string &item_type) { return 2 * sizeof(int8_t); } - else if (item_type == "short" or item_type == "ishort" ) + else if (item_type == "short" or item_type == "ishort") { return sizeof(int16_t); } @@ -79,90 +80,105 @@ size_t item_type_size(const std::string &item_type) } } + bool item_type_is_complex(const std::string &item_type) { return (item_type == "ibyte") or (item_type == "cbyte") or (item_type == "ishort") or (item_type == "cshort") or (item_type == "gr_complex"); } + void copy_converter(void *dest, const void *src, unsigned int num_items, size_t item_size) { std::memcpy(dest, src, num_items * item_size); } + void convert_8i_16i(void *dest, const void *src, unsigned int num_items) { volk_8i_convert_16i(reinterpret_cast(dest), reinterpret_cast(src), num_items); } + void convert_8i_32f(void *dest, const void *src, unsigned int num_items) { volk_8i_s32f_convert_32f(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, num_items); + reinterpret_cast(src), 1.0F, num_items); } + void convert_8ic_16ic(void *dest, const void *src, unsigned int num_items) { volk_8i_convert_16i(reinterpret_cast(dest), reinterpret_cast(src), 2 * num_items); } + void convert_8ic_32fc(void *dest, const void *src, unsigned int num_items) { volk_8i_s32f_convert_32f(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, 2 * num_items); + reinterpret_cast(src), 1.0F, 2 * num_items); } + void convert_16i_8i(void *dest, const void *src, unsigned int num_items) { volk_16i_convert_8i(reinterpret_cast(dest), reinterpret_cast(src), num_items); } + void convert_16i_32f(void *dest, const void *src, unsigned int num_items) { volk_16i_s32f_convert_32f(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, num_items); + reinterpret_cast(src), 1.0F, num_items); } + void convert_16ic_8ic(void *dest, const void *src, unsigned int num_items) { volk_16i_convert_8i(reinterpret_cast(dest), reinterpret_cast(src), 2 * num_items); } + void convert_16ic_32fc(void *dest, const void *src, unsigned int num_items) { volk_16i_s32f_convert_32f(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, 2 * num_items); + reinterpret_cast(src), 1.0F, 2 * num_items); } + void convert_32f_8i(void *dest, const void *src, unsigned int num_items) { volk_32f_s32f_convert_8i(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, num_items); + reinterpret_cast(src), 1.0F, num_items); } + void convert_32f_16i(void *dest, const void *src, unsigned int num_items) { volk_32f_s32f_convert_16i(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, num_items); + reinterpret_cast(src), 1.0F, num_items); } + void convert_32fc_8ic(void *dest, const void *src, unsigned int num_items) { volk_32f_s32f_convert_8i(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, 2 * num_items); + reinterpret_cast(src), 1.0F, 2 * num_items); } + void convert_32fc_16ic(void *dest, const void *src, unsigned int num_items) { volk_32f_s32f_convert_16i(reinterpret_cast(dest), - reinterpret_cast(src), 1.0f, 2 * num_items); + reinterpret_cast(src), 1.0F, 2 * num_items); } -item_type_converter_t make_vector_converter(std::string input_type, - std::string output_type) + +item_type_converter_t make_vector_converter(const std::string &input_type, + const std::string &output_type) { if (not item_type_valid(input_type) or not item_type_valid(output_type)) { @@ -172,136 +188,115 @@ item_type_converter_t make_vector_converter(std::string input_type, if (input_type == output_type) { size_t input_size = item_type_size(input_type); - return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, input_size); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); }; } if (input_type == "byte") { if (output_type == "short") { - return std::bind(convert_8i_16i, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_16i(arg1, arg2, arg3); }; } else if (output_type == "float") { - return std::bind(convert_8i_32f, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_32f(arg1, arg2, arg3); }; } } else if (input_type == "cbyte") { - if (output_type == "ibyte" ) + if (output_type == "ibyte") { size_t input_size = item_type_size(input_type); - return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, input_size); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); }; } - if (output_type == "cshort" or output_type == "ishort" ) + if (output_type == "cshort" or output_type == "ishort") { - return std::bind(convert_8ic_16ic, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8ic_16ic(arg1, arg2, arg3); }; } else if (output_type == "gr_complex") { - return std::bind(convert_8ic_32fc, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8ic_32fc(arg1, arg2, arg3); }; } } else if (input_type == "ibyte") { - if (output_type == "cbyte" ) + if (output_type == "cbyte") { size_t input_size = item_type_size(input_type); - return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, input_size); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); }; } else if (output_type == "cshort" or output_type == "ishort") { - return std::bind(convert_8i_16i, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_16i(arg1, arg2, arg3); }; } else if (output_type == "gr_complex") { - return std::bind(convert_8i_32f, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_8i_32f(arg1, arg2, arg3); }; } } else if (input_type == "short") { if (output_type == "byte") { - return std::bind(convert_16i_8i, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_8i(arg1, arg2, arg3); }; } else if (output_type == "float") { - return std::bind(convert_16i_32f, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_32f(arg1, arg2, arg3); }; } } else if (input_type == "cshort") { - if (output_type == "cbyte" or output_type == "ibyte" ) + if (output_type == "cbyte" or output_type == "ibyte") { - return std::bind(convert_16ic_8ic, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16ic_8ic(arg1, arg2, arg3); }; } if (output_type == "ishort") { size_t input_size = item_type_size(input_type); - return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, input_size); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); }; } else if (output_type == "gr_complex") { - return std::bind(convert_16ic_32fc, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16ic_32fc(arg1, arg2, arg3); }; } } else if (input_type == "ishort") { - if (output_type == "cbyte" or output_type == "ibyte" ) + if (output_type == "cbyte" or output_type == "ibyte") { - return std::bind(convert_16i_8i, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_8i(arg1, arg2, arg3); }; } if (output_type == "cshort") { size_t input_size = item_type_size(input_type); - return std::bind(copy_converter, std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, input_size); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return copy_converter(arg1, arg2, arg3, input_size); }; } else if (output_type == "gr_complex") { - return std::bind(convert_16i_32f, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_16i_32f(arg1, arg2, arg3); }; } } else if (input_type == "float") { if (output_type == "byte") { - return std::bind(convert_32f_8i, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32f_8i(arg1, arg2, arg3); }; } else if (output_type == "short") { - return std::bind(convert_32f_16i, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32f_16i(arg1, arg2, arg3); }; } } else if (input_type == "gr_complex") { if (output_type == "cbyte" or output_type == "ibyte") { - return std::bind(convert_32fc_8ic, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32fc_8ic(arg1, arg2, arg3); }; } - else if (output_type == "cshort" or output_type == "ishort" ) + else if (output_type == "cshort" or output_type == "ishort") { - return std::bind(convert_32fc_16ic, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3); + return [=](auto &&arg1, auto &&arg2, auto &&arg3) { return convert_32fc_16ic(arg1, arg2, arg3); }; } } diff --git a/src/algorithms/libs/item_type_helpers.h b/src/algorithms/libs/item_type_helpers.h index 4dcd30777..421177ae2 100644 --- a/src/algorithms/libs/item_type_helpers.h +++ b/src/algorithms/libs/item_type_helpers.h @@ -58,7 +58,6 @@ size_t item_type_size(const std::string &item_type); */ bool item_type_is_complex(const std::string &item_type); - /*! * \brief Create a function to convert an array of input_type to an array of output_type * @@ -82,9 +81,8 @@ bool item_type_is_complex(const std::string &item_type); * \returns A function object with the following prototype: * void convert_fun( void *dest, void *src, int num_items ); * - * */ -item_type_converter_t make_vector_converter(std::string input_type, - std::string output_type); +item_type_converter_t make_vector_converter(const std::string &input_type, + const std::string &output_type); #endif diff --git a/src/tests/system-tests/position_test.cc b/src/tests/system-tests/position_test.cc index cc289d480..90954caeb 100644 --- a/src/tests/system-tests/position_test.cc +++ b/src/tests/system-tests/position_test.cc @@ -193,7 +193,6 @@ int PositionSystemTest::configure_receiver() const int number_of_channels = 11; const int in_acquisition = 1; - const float threshold = 2.5; const float doppler_max = 5000.0; const float doppler_step = 250.0; const int max_dwells = 10; @@ -278,7 +277,9 @@ int PositionSystemTest::configure_receiver() config->set_property("Acquisition_1C.implementation", "GPS_L1_CA_PCPS_Acquisition"); config->set_property("Acquisition_1C.item_type", "gr_complex"); config->set_property("Acquisition_1C.coherent_integration_time_ms", std::to_string(coherent_integration_time_ms)); - config->set_property("Acquisition_1C.threshold", std::to_string(threshold)); + //config->set_property("Acquisition_1C.use_CFAR_algorithm", "false"); + //config->set_property("Acquisition_1C.pfa", std::to_string(0.001)); + //config->set_property("Acquisition_1C.pfa2", std::to_string(0.001)); config->set_property("Acquisition_1C.doppler_max", std::to_string(doppler_max)); config->set_property("Acquisition_1C.doppler_step", std::to_string(doppler_step)); config->set_property("Acquisition_1C.bit_transition_flag", "false"); diff --git a/src/tests/unit-tests/signal-processing-blocks/libs/item_type_helpers.cc b/src/tests/unit-tests/signal-processing-blocks/libs/item_type_helpers.cc index a290d2934..1cb5e7190 100644 --- a/src/tests/unit-tests/signal-processing-blocks/libs/item_type_helpers.cc +++ b/src/tests/unit-tests/signal-processing-blocks/libs/item_type_helpers.cc @@ -34,48 +34,42 @@ #include #include -class ItemTypeHelpersTest : public ::testing::Test +class ItemTypeHelpersTest : public ::testing::Test { - protected: - static constexpr size_t N = 1000; +protected: + static constexpr size_t N = 1000; - public: - ItemTypeHelpersTest() - { - std::random_device r; - std::default_random_engine e(r()); +public: + ItemTypeHelpersTest() + { + std::random_device r; + std::default_random_engine e(r()); - std::uniform_int_distribution udist_int8(-100,100); - std::uniform_int_distribution udist_int16(-100,100); - std::uniform_real_distribution udist_float(-100,100); + std::uniform_int_distribution udist_int8(-100, 100); + std::uniform_int_distribution udist_int16(-100, 100); + std::uniform_real_distribution udist_float(-100, 100); - std::generate( byte_array_in.begin(), byte_array_in.end(), [&udist_int8, &e](){ - return udist_int8(e); } ); + std::generate(byte_array_in.begin(), byte_array_in.end(), [&udist_int8, &e]() { return udist_int8(e); }); - std::generate( short_array_in.begin(), short_array_in.end(), [&udist_int16, &e](){ - return udist_int16(e); } ); + std::generate(short_array_in.begin(), short_array_in.end(), [&udist_int16, &e]() { return udist_int16(e); }); - std::generate( float_array_in.begin(), float_array_in.end(), [&udist_float, &e](){ - return udist_float(e); } ); + std::generate(float_array_in.begin(), float_array_in.end(), [&udist_float, &e]() { return udist_float(e); }); + } - } + std::vector valid_item_types = {"byte", "ibyte", "cbyte", + "short", "ishort", "cshort", "float", "gr_complex"}; - std::vector valid_item_types = {"byte", "ibyte", "cbyte", - "short", "ishort", "cshort", "float", "gr_complex"}; + std::vector invalid_item_types = {"i8", "tfgs", "cbite", + "shirt", "qshort", "csort", "flat", "igr_complex"}; - std::vector invalid_item_types = {"i8", "tfgs", "cbite", - "shirt", "qshort", "csort", "flat", "igr_complex"}; - - std::array< int8_t, 2*N > byte_array_in; - std::array< int8_t, 2*N > byte_array_out; - - std::array< int16_t, 2*N > short_array_in; - std::array< int16_t, 2*N > short_array_out; - - std::array< float, 2*N > float_array_in; - std::array< float, 2*N > float_array_out; + std::array byte_array_in; + std::array byte_array_out; + std::array short_array_in; + std::array short_array_out; + std::array float_array_in; + std::array float_array_out; }; TEST_F(ItemTypeHelpersTest, CheckValidTypes) @@ -93,16 +87,16 @@ TEST_F(ItemTypeHelpersTest, CheckValidTypes) TEST_F(ItemTypeHelpersTest, CheckSizes) { - EXPECT_EQ( item_type_size( "byte" ), 1 ); - EXPECT_EQ( item_type_size( "ibyte" ), 1 ); - EXPECT_EQ( item_type_size( "cbyte" ), 2 ); + EXPECT_EQ(item_type_size("byte"), 1); + EXPECT_EQ(item_type_size("ibyte"), 1); + EXPECT_EQ(item_type_size("cbyte"), 2); - EXPECT_EQ( item_type_size( "short" ), 2 ); - EXPECT_EQ( item_type_size( "ishort" ), 2 ); - EXPECT_EQ( item_type_size( "cshort" ), 4 ); + EXPECT_EQ(item_type_size("short"), 2); + EXPECT_EQ(item_type_size("ishort"), 2); + EXPECT_EQ(item_type_size("cshort"), 4); - EXPECT_EQ( item_type_size( "float" ), 4 ); - EXPECT_EQ( item_type_size( "gr_complex" ), 8 ); + EXPECT_EQ(item_type_size("float"), 4); + EXPECT_EQ(item_type_size("gr_complex"), 8); for (auto &invalid_type : invalid_item_types) @@ -113,154 +107,153 @@ TEST_F(ItemTypeHelpersTest, CheckSizes) TEST_F(ItemTypeHelpersTest, CheckMakeConverters) { - for( auto & input_type : valid_item_types ) - { - for( auto &output_type : valid_item_types ) + for (auto &input_type : valid_item_types) { - item_type_converter_t converter = nullptr; - - if( item_type_is_complex(input_type) == item_type_is_complex(output_type) ) - { - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr ); - } - else - { - EXPECT_THROW( converter = make_vector_converter(input_type, output_type), std::runtime_error ); - } + for (auto &output_type : valid_item_types) + { + item_type_converter_t converter = nullptr; + if (item_type_is_complex(input_type) == item_type_is_complex(output_type)) + { + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + } + else + { + EXPECT_THROW(converter = make_vector_converter(input_type, output_type), std::runtime_error); + } + } } - } } TEST_F(ItemTypeHelpersTest, CheckConversionsReal) { std::string input_type = "byte"; std::string output_type = "byte"; - item_type_converter_t converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), byte_array_in.data(), N ); - EXPECT_TRUE( std::equal( byte_array_in.begin(), byte_array_in.begin() + N, byte_array_out.begin() ) ); + item_type_converter_t converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), byte_array_in.data(), N); + EXPECT_TRUE(std::equal(byte_array_in.begin(), byte_array_in.begin() + N, byte_array_out.begin())); input_type = "byte"; output_type = "short"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), byte_array_in.data(), N ); - converter = make_vector_converter( output_type, input_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), short_array_out.data(), N ); - EXPECT_TRUE( std::equal( byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), byte_array_in.data(), N); + converter = make_vector_converter(output_type, input_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), short_array_out.data(), N); + EXPECT_TRUE(std::equal(byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin())); input_type = "byte"; output_type = "float"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( float_array_out.data(), byte_array_in.data(), N ); - converter = make_vector_converter( output_type, input_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), float_array_out.data(), N ); - EXPECT_TRUE( std::equal( byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(float_array_out.data(), byte_array_in.data(), N); + converter = make_vector_converter(output_type, input_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), float_array_out.data(), N); + EXPECT_TRUE(std::equal(byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin())); input_type = "short"; output_type = "short"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), short_array_in.data(), N ); - EXPECT_TRUE( std::equal( short_array_in.begin(), short_array_in.begin() + N, short_array_out.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), short_array_in.data(), N); + EXPECT_TRUE(std::equal(short_array_in.begin(), short_array_in.begin() + N, short_array_out.begin())); input_type = "short"; output_type = "float"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( float_array_out.data(), short_array_in.data(), N ); - converter = make_vector_converter( output_type, input_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), float_array_out.data(), N ); - EXPECT_TRUE( std::equal( short_array_out.begin(), short_array_out.begin() + N, short_array_in.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(float_array_out.data(), short_array_in.data(), N); + converter = make_vector_converter(output_type, input_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), float_array_out.data(), N); + EXPECT_TRUE(std::equal(short_array_out.begin(), short_array_out.begin() + N, short_array_in.begin())); input_type = "float"; output_type = "float"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( float_array_out.data(), float_array_in.data(), N ); - EXPECT_TRUE( std::equal( float_array_in.begin(), float_array_in.begin() + N, float_array_out.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(float_array_out.data(), float_array_in.data(), N); + EXPECT_TRUE(std::equal(float_array_in.begin(), float_array_in.begin() + N, float_array_out.begin())); } TEST_F(ItemTypeHelpersTest, CheckConversionsComplex) { std::string input_type = "cbyte"; std::string output_type = "cbyte"; - item_type_converter_t converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), byte_array_in.data(), N ); - EXPECT_TRUE( std::equal( byte_array_in.begin(), byte_array_in.begin() + N, byte_array_out.begin() ) ); + item_type_converter_t converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), byte_array_in.data(), N); + EXPECT_TRUE(std::equal(byte_array_in.begin(), byte_array_in.begin() + N, byte_array_out.begin())); input_type = "cbyte"; output_type = "ibyte"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), byte_array_in.data(), N ); - EXPECT_TRUE( std::equal( byte_array_in.begin(), byte_array_in.begin() + N, byte_array_out.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), byte_array_in.data(), N); + EXPECT_TRUE(std::equal(byte_array_in.begin(), byte_array_in.begin() + N, byte_array_out.begin())); input_type = "cbyte"; output_type = "cshort"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), byte_array_in.data(), N ); - converter = make_vector_converter( output_type, input_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), short_array_out.data(), N ); - EXPECT_TRUE( std::equal( byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), byte_array_in.data(), N); + converter = make_vector_converter(output_type, input_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), short_array_out.data(), N); + EXPECT_TRUE(std::equal(byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin())); input_type = "cbyte"; output_type = "ishort"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), byte_array_in.data(), N ); - converter = make_vector_converter( output_type, input_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), short_array_out.data(), N ); - EXPECT_TRUE( std::equal( byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), byte_array_in.data(), N); + converter = make_vector_converter(output_type, input_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), short_array_out.data(), N); + EXPECT_TRUE(std::equal(byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin())); input_type = "cbyte"; output_type = "gr_complex"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( float_array_out.data(), byte_array_in.data(), N ); - converter = make_vector_converter( output_type, input_type ); - EXPECT_NE( converter, nullptr); - converter( byte_array_out.data(), float_array_out.data(), N ); - EXPECT_TRUE( std::equal( byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(float_array_out.data(), byte_array_in.data(), N); + converter = make_vector_converter(output_type, input_type); + EXPECT_NE(converter, nullptr); + converter(byte_array_out.data(), float_array_out.data(), N); + EXPECT_TRUE(std::equal(byte_array_out.begin(), byte_array_out.begin() + N, byte_array_in.begin())); input_type = "cshort"; output_type = "cshort"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), short_array_in.data(), N ); - EXPECT_TRUE( std::equal( short_array_in.begin(), short_array_in.begin() + N, short_array_out.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), short_array_in.data(), N); + EXPECT_TRUE(std::equal(short_array_in.begin(), short_array_in.begin() + N, short_array_out.begin())); input_type = "cshort"; output_type = "ishort"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), short_array_in.data(), N ); - EXPECT_TRUE( std::equal( short_array_in.begin(), short_array_in.begin() + N, short_array_out.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), short_array_in.data(), N); + EXPECT_TRUE(std::equal(short_array_in.begin(), short_array_in.begin() + N, short_array_out.begin())); input_type = "cshort"; output_type = "gr_complex"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( float_array_out.data(), short_array_in.data(), N ); - converter = make_vector_converter( output_type, input_type ); - EXPECT_NE( converter, nullptr); - converter( short_array_out.data(), float_array_out.data(), N ); - EXPECT_TRUE( std::equal( short_array_out.begin(), short_array_out.begin() + N, short_array_in.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(float_array_out.data(), short_array_in.data(), N); + converter = make_vector_converter(output_type, input_type); + EXPECT_NE(converter, nullptr); + converter(short_array_out.data(), float_array_out.data(), N); + EXPECT_TRUE(std::equal(short_array_out.begin(), short_array_out.begin() + N, short_array_in.begin())); input_type = "gr_complex"; output_type = "gr_complex"; - converter = make_vector_converter( input_type, output_type ); - EXPECT_NE( converter, nullptr); - converter( float_array_out.data(), float_array_in.data(), N ); - EXPECT_TRUE( std::equal( float_array_in.begin(), float_array_in.begin() + N, float_array_out.begin() ) ); + converter = make_vector_converter(input_type, output_type); + EXPECT_NE(converter, nullptr); + converter(float_array_out.data(), float_array_in.data(), N); + EXPECT_TRUE(std::equal(float_array_in.begin(), float_array_in.begin() + N, float_array_out.begin())); }