Method test_column

test/test_alp_sample.cpp:98–187

	template <typename PT>
	void test_column(const alp_bench::ALPColumnDescriptor& column) {
		using UT = typename alp::inner_t<PT>::ut;
		using ST = typename alp::inner_t<PT>::st;

		auto* input_arr        = reinterpret_cast<PT*>(intput_buf);
		auto* sample_arr       = reinterpret_cast<PT*>(sample_buf);
		auto* right_arr        = reinterpret_cast<UT*>(right_buf);
		auto* ffor_right_arr   = reinterpret_cast<UT*>(ffor_right_buf);
		auto* unffor_right_arr = reinterpret_cast<UT*>(unffor_right_buf);
		auto* glue_arr         = reinterpret_cast<PT*>(glue_buf);
		auto* exc_arr          = reinterpret_cast<PT*>(exception_buf);
		auto* dec_dbl_arr      = reinterpret_cast<PT*>(decoded_buf);
		auto* encoded_arr      = reinterpret_cast<ST*>(encoded_buf);
		auto* base_arr         = reinterpret_cast<ST*>(base_buf);
		auto* ffor_arr         = reinterpret_cast<ST*>(ffor_buf);

		std::ifstream file(column.csv_file_path, std::ios::in);
		if (!file) { throw std::runtime_error(column.csv_file_path + " : " + strerror(errno)); }

		alp::state<PT> stt;
		size_t         tuples_count {alp::config::VECTOR_SIZE};
		size_t         rowgroup_offset {0};

		double      value_to_encode;
		std::string val_str;
		// keep storing values from the text file so long as data exists:
		size_t row_idx {0};
		while (file >> val_str) {
			if constexpr (std::is_same_v<PT, double>) {
				value_to_encode = std::stod(val_str);
			} else {
				value_to_encode = std::stof(val_str);
			}

			input_arr[row_idx] = value_to_encode;
			row_idx += 1;
		}

		// Init
		alp::encoder<PT>::init(input_arr, rowgroup_offset, tuples_count, sample_arr, stt);

		switch (stt.scheme) {
		case alp::Scheme::ALP_RD: {
			alp::rd_encoder<PT>::init(input_arr, rowgroup_offset, tuples_count, sample_arr, stt);

			alp::rd_encoder<PT>::encode(input_arr, rd_exc_arr, pos_arr, exc_c_arr, right_arr, left_arr, stt);
			ffor::ffor(right_arr, ffor_right_arr, stt.right_bit_width, &stt.right_for_base);
			ffor::ffor(left_arr, ffor_left_arr, stt.left_bit_width, &stt.left_for_base);

			// Decode
			unffor::unffor(ffor_right_arr, unffor_right_arr, stt.right_bit_width, &stt.right_for_base);
			unffor::unffor(ffor_left_arr, unffor_left_arr, stt.left_bit_width, &stt.left_for_base);
			alp::rd_encoder<PT>::decode(
			    glue_arr, unffor_right_arr, unffor_left_arr, rd_exc_arr, pos_arr, exc_c_arr, stt);

			for (size_t i = 0; i < alp::config::VECTOR_SIZE; ++i) {
				auto l = input_arr[i];
				auto r = glue_arr[i];