Method encode_simdized

include/alp/encoder.hpp:307–400

	}

	static inline void encode_simdized(const PT*            input_vector,
	                                   PT*                  exceptions,
	                                   exp_p_t*             exceptions_positions,
	                                   exp_c_t*             exceptions_count,
	                                   ST*                  encoded_integers,
	                                   const factor_idx_t   factor_idx,
	                                   const exponent_idx_t exponent_idx) {
		// These arrays are thread_local static to ensure thread safety during multithreaded compression.
		// See: https://github.com/cwida/ALP/issues/41 for discussion.
		// Without thread_local, static arrays would be shared between threads, causing data races.
		alignas(64) thread_local static PT ENCODED_VALUE_ARR[1024];
		alignas(64) thread_local static PT VALUE_ARR_WITHOUT_SPECIALS[1024];
		alignas(64) thread_local static UT TMP_INDEX_ARR[1024];

		exp_p_t  current_exceptions_count {0};
		uint64_t exceptions_idx {0};

		// make copy of input with all special values replaced by  ENCODING_UPPER_LIMIT
		const auto* tmp_input = reinterpret_cast<const UT*>(input_vector);
		for (size_t i {0}; i < config::VECTOR_SIZE; i++) {
			const auto is_special =
			    ((tmp_input[i] & Constants<PT>::SIGN_BIT_MASK) >=
			     Constants<PT>::EXPONENTIAL_BITS_MASK) // any NaN, +inf and -inf
			                                           // (https://stackoverflow.com/questions/29730530/)
			    || tmp_input[i] == Constants<PT>::NEGATIVE_ZERO;

			if (is_special) {
				VALUE_ARR_WITHOUT_SPECIALS[i] = ENCODING_UPPER_LIMIT;
			} else {
				VALUE_ARR_WITHOUT_SPECIALS[i] = input_vector[i];
			}
		}

#pragma clang loop vectorize_width(64)
		for (size_t i {0}; i < config::VECTOR_SIZE; i++) {
			auto const actual_value = VALUE_ARR_WITHOUT_SPECIALS[i];

			// Attempt conversion
			const ST encoded_value = encode_value<false>(actual_value, factor_idx, exponent_idx);
			encoded_integers[i]    = encoded_value;
			const PT decoded_value = decoder<PT>::decode_value(encoded_value, factor_idx, exponent_idx);
			ENCODED_VALUE_ARR[i]   = decoded_value;
		}

#ifdef __AVX512F__
		if constexpr (std::is_same_v<PT, double>) {
			for (size_t i {0}; i < config::VECTOR_SIZE; i = i + 8) {
				__m512d l            = _mm512_loadu_pd(ENCODED_VALUE_ARR + i);
				__m512d r            = _mm512_loadu_pd(VALUE_ARR_WITHOUT_SPECIALS + i);
				__m512i index        = _mm512_loadu_pd(DOUBLE_INDEX_ARR + i);
				auto    is_exception = _mm512_cmpneq_pd_mask(l, r);
				_mm512_mask_compressstoreu_pd(TMP_INDEX_ARR + exceptions_idx, is_exception, index);
				exceptions_idx += LOOKUP_TABLE[is_exception];
			}
		} else {
			for (size_t i {0}; i < config::VECTOR_SIZE; i = i + 16) {
				__m512   l            = _mm512_loadu_ps(ENCODED_VALUE_ARR + i);
				__m512   r            = _mm512_loadu_ps(VALUE_ARR_WITHOUT_SPECIALS + i);