minimap2 0.2.25.0 → 0.2.25.1

data/ext/minimap2/lib/simde/test/run-tests.h

@@ -0,0 +1,260 @@
+#if !defined(SIMDE_RUN_TESTS_H)
+#define SIMDE_RUN_TESTS_H
+
+#include  "../simde/hedley.h"
+#include "munit/munit.h"
+#include "../simde/simde-common.h"
+
+#include <stdio.h>
+#include <math.h>
+
+SIMDE_DISABLE_UNWANTED_DIAGNOSTICS
+
+#if defined(HEDLEY_MSVC_VERSION)
+/* Unused function(s) */
+#pragma warning(disable:4505)
+#endif
+
+HEDLEY_DIAGNOSTIC_PUSH
+
+#define SIMDE_TESTS_CONCAT3_EX(a, b, c) a##b##c
+#define SIMDE_TESTS_CONCAT3(a, b, c) SIMDE_TESTS_CONCAT3_EX(a, b, c)
+
+#if defined(__cplusplus)
+#  define SIMDE_TESTS_CURRENT_LANG cpp
+#else
+#  define SIMDE_TESTS_CURRENT_LANG c
+#endif
+
+#if defined(SIMDE_NO_NATIVE)
+#  define SIMDE_TESTS_CURRENT_NATIVE emul
+#else
+#  define SIMDE_TESTS_CURRENT_NATIVE native
+#endif
+
+#define SIMDE_TESTS_GENERATE_SYMBOL_FULL(sym, arch, isa, native, lang) \
+  HEDLEY_CONCAT(HEDLEY_CONCAT(HEDLEY_CONCAT(HEDLEY_CONCAT(HEDLEY_CONCAT(HEDLEY_CONCAT(HEDLEY_CONCAT(HEDLEY_CONCAT(simde_tests_, HEDLEY_CONCAT(arch, _)), isa), _), native), _), lang),_),sym)
+
+#define SIMDE_TESTS_GENERATE_SYMBOL(sym) \
+  SIMDE_TESTS_GENERATE_SYMBOL_FULL(sym, SIMDE_TESTS_CURRENT_ARCH, SIMDE_TESTS_CURRENT_ISAX, SIMDE_TESTS_CURRENT_NATIVE, SIMDE_TESTS_CURRENT_LANG)
+
+#if defined(SIMDE_BUILD_CPP_TESTS)
+#define SIMDE_TESTS_GENERATE_NAME(name) \
+  "/" HEDLEY_STRINGIFY(name) "/" HEDLEY_STRINGIFY(SIMDE_TESTS_CURRENT_NATIVE) "/" HEDLEY_STRINGIFY(SIMDE_TESTS_CURRENT_LANG)
+#else
+#define SIMDE_TESTS_GENERATE_NAME(name) \
+  "/" HEDLEY_STRINGIFY(name) "/" HEDLEY_STRINGIFY(SIMDE_TESTS_CURRENT_NATIVE)
+#endif
+
+#define SIMDE_TESTS_DEFINE_TEST(name) \
+  { (char*) SIMDE_TESTS_GENERATE_NAME(name), test_simde_##name, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
+
+HEDLEY_BEGIN_C_DECLS
+
+#if !defined(HEDLEY_PGI_VERSION)
+#  define SIMDE_ALMOST_EQUAL_TO "≈"
+#else
+#  define SIMDE_ALMOST_EQUAL_TO "~=~"
+#endif
+
+SIMDE__FUNCTION_POSSIBLY_UNUSED
+static int
+simde_check_double_close(double a, double b, int precision) {
+  const double r = 1.0 * pow(10, HEDLEY_STATIC_CAST(double, precision));
+  return
+    HEDLEY_UNLIKELY(a < (b - r)) ||
+    HEDLEY_UNLIKELY(a > (b + r));
+}
+
+#define SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(VT, accessor) \
+  HEDLEY_ALWAYS_INLINE \
+  static void \
+  simde_assert_##VT##_##accessor##_close_ex(int line, const char* file, simde__##VT a, simde__##VT b, int precision) { \
+    simde__##VT##_private \
+      a_ = simde__##VT##_to_private(a), \
+      b_ = simde__##VT##_to_private(b);	\
+    \
+    for (int i = 0 ; i < HEDLEY_STATIC_CAST(int, sizeof(a_.accessor) / sizeof(a_.accessor[0])) ; i++) { \
+      if (simde_check_double_close(HEDLEY_STATIC_CAST(double, a_.accessor[i]), HEDLEY_STATIC_CAST(double, b_.accessor[i]), precision)) { \
+        fprintf(stderr, "%s:%d: assertion failed[%d]: %g " SIMDE_ALMOST_EQUAL_TO " %g (precision: 1e-%d)\n", file, line, i, a_.accessor[i], b_.accessor[i], precision); \
+        abort(); \
+      } \
+    } \
+  }
+
+SIMDE__FUNCTION_POSSIBLY_UNUSED
+static void random_f32v(size_t nmemb, simde_float32 v[HEDLEY_ARRAY_PARAM(nmemb)]) {
+  for (size_t i = 0 ; i < nmemb ; i++) {
+    do {
+      munit_rand_memory(sizeof(v[i]), HEDLEY_REINTERPRET_CAST(uint8_t*, &(v[i])));
+    } while (!isnormal(v[i]));
+  }
+}
+
+SIMDE__FUNCTION_POSSIBLY_UNUSED
+static simde_float64 random_f64_range(simde_float64 min, simde_float64 max) {
+  const simde_float64 range = max - min;
+  simde_float64 x = HEDLEY_STATIC_CAST(simde_float64, munit_rand_uint32());
+  x /= HEDLEY_STATIC_CAST(simde_float64, UINT32_MAX) / range;
+  x += min;
+  return x;
+}
+
+SIMDE__FUNCTION_POSSIBLY_UNUSED
+static simde_float32 random_f32_range(simde_float32 min, simde_float32 max) {
+  return HEDLEY_STATIC_CAST(simde_float32, random_f64_range(HEDLEY_STATIC_CAST(double, min), HEDLEY_STATIC_CAST(double, max)));
+}
+
+SIMDE__FUNCTION_POSSIBLY_UNUSED
+static void random_f64v(size_t nmemb, simde_float64 v[HEDLEY_ARRAY_PARAM(nmemb)]) {
+  for (size_t i = 0 ; i < nmemb ; i++) {
+    do {
+      munit_rand_memory(sizeof(v[i]), HEDLEY_REINTERPRET_CAST(uint8_t*, &(v[i])));
+    } while (!isnormal(v[i]));
+  }
+}
+
+#define random_intv_range(T, nmemb, v, min, max) \
+  do { \
+    for (size_t simde_tmp_i_ = 0 ; simde_tmp_i_ < nmemb ; simde_tmp_i_++) { \
+      ((T*) (v))[simde_tmp_i_] = munit_rand_int_range(min, max); \
+    } \
+  } while (0)
+
+#define TEST_PREFERRED_ITERATIONS (256)
+
+/* I'll probably move these into µnit, but I want to play around with
+   them for a while first. */
+
+#define simde_assert_array_full(prefix, suffix, T, fmt, nmemb, a, op, b) \
+  do { \
+    const T* simde__tmp_a_ = (a); \
+    const T* simde__tmp_b_ = (b); \
+    for (size_t simde__i_ = 0 ; simde__i_ < nmemb ; simde__i_++) { \
+      if (!(simde__tmp_a_[simde__i_] op simde__tmp_b_[simde__i_])) { \
+	munit_errorf("assertion failed: (" #a ")[%" MUNIT_SIZE_MODIFIER "u] " #op " (" #b ")[%" MUNIT_SIZE_MODIFIER "u] (" prefix "%" fmt suffix " " #op " " prefix "%" fmt suffix ")", simde__i_, simde__i_, simde__tmp_a_[simde__i_], simde__tmp_b_[simde__i_]); \
+      } \
+    } \
+  } while (0)
+
+#define simde_assert_typev(T, fmt, nmemb, a, op, b) \
+  simde_assert_array_full("", "", T, fmt, nmemb, a, op, b)
+
+#define simde_assert_f32v(nmemb, a, op, b) \
+  simde_assert_typev(simde_float32, "g", nmemb, a, op, b)
+
+#define simde_assert_intv(nmemb, a, op, b) \
+  simde_assert_typev(int, "d", nmemb, a, op, b)
+
+#define simde_assert_uintv(nmemb, a, op, b) \
+  simde_assert_typev(int, "u", nmemb, a, op, b)
+
+#define simde_assert_int8v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_int8_t, PRId8, nmemb, a, op, b)
+#define simde_assert_uint8v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_uint8_t, PRIu8, nmemb, a, op, b)
+#define simde_assert_int16v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_int16_t, PRId16, nmemb, a, op, b)
+#define simde_assert_uint16v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_uint16_t, PRIu16, nmemb, a, op, b)
+#define simde_assert_int32v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_int32_t, PRId32, nmemb, a, op, b)
+#define simde_assert_uint32v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_uint32_t, PRIu32, nmemb, a, op, b)
+#define simde_assert_int64v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_int64_t,  PRId64, nmemb, a, op, b)
+#define simde_assert_uint64v(nmemb, a, op, b) \
+  simde_assert_array_full("", "", munit_uint64_t, PRIu64, nmemb, a, op, b)
+
+#define simde_assert_f32v_equal(T, nmemb, a, b, precision) \
+  do { \
+    const T* simde_tmp_a_ = (a); \
+    const T* simde_tmp_b_ = (b); \
+    for (size_t simde_i_ = 0 ; simde_i_ < nmemb ; simde_i_++) { \
+      const T simde_tmp_diff_ = ((simde_tmp_a_[simde_i_] - simde_tmp_b_[simde_i_]) < 0) ? \
+	(simde_tmp_b_[simde_i_] - simde_tmp_a_[simde_i_]) : \
+	(simde_tmp_a_[simde_i_] - simde_tmp_b_[simde_i_]); \
+      if (MUNIT_UNLIKELY(simde_tmp_diff_ > 1e-##precision)) { \
+	munit_errorf("assertion failed: (" #a ")[%" MUNIT_SIZE_MODIFIER "u] == (" #b ")[%" MUNIT_SIZE_MODIFIER "u] (%." #precision "f == %." #precision "f)", simde_i_, simde_i_, simde_tmp_a_[simde_i_], simde_tmp_b_[simde_i_]); \
+      } \
+    } \
+  } while (0)
+
+#define simde_assert_f32v_close(T, nmemb, a, b, precision) \
+  do { \
+    const T* simde_tmp_a_ = (a); \
+    const T* simde_tmp_b_ = (b); \
+    for (size_t simde_i_ = 0 ; simde_i_ < nmemb ; simde_i_++) { \
+      const T simde_tmp_diff_ = ((simde_tmp_a_[simde_i_] - simde_tmp_b_[simde_i_]) < 0) ? \
+	(simde_tmp_b_[simde_i_] - simde_tmp_a_[simde_i_]) : \
+	(simde_tmp_a_[simde_i_] - simde_tmp_b_[simde_i_]); \
+      if (MUNIT_UNLIKELY(simde_tmp_diff_ > precision)) { \
+	munit_errorf("assertion failed: (" #a ")[%" MUNIT_SIZE_MODIFIER "u] == (" #b ")[%" MUNIT_SIZE_MODIFIER "u] (%" #precision ".1f == %" #precision ".1f)", simde_i_, simde_i_, simde_tmp_a_[simde_i_], simde_tmp_b_[simde_i_]); \
+      } \
+    } \
+  } while (0)
+
+#define simde_assert_f64v_close(T, nmemb, a, b, precision) \
+  do { \
+    const T* simde_tmp_a_ = (a); \
+    const T* simde_tmp_b_ = (b); \
+    for (size_t simde_i_ = 0 ; simde_i_ < nmemb ; simde_i_++) { \
+      const T simde_tmp_diff_ = ((simde_tmp_a_[simde_i_] - simde_tmp_b_[simde_i_]) < 0) ? \
+	(simde_tmp_b_[simde_i_] - simde_tmp_a_[simde_i_]) : \
+	(simde_tmp_a_[simde_i_] - simde_tmp_b_[simde_i_]); \
+      if (MUNIT_UNLIKELY(simde_tmp_diff_ > precision)) { \
+	munit_errorf("assertion failed: (" #a ")[%" MUNIT_SIZE_MODIFIER "u] == (" #b ")[%" MUNIT_SIZE_MODIFIER "u] (%" #precision ".1f == %" #precision ".1f)", simde_i_, simde_i_, simde_tmp_a_[simde_i_], simde_tmp_b_[simde_i_]); \
+      } \
+    } \
+  } while (0)
+
+/* These probably won't go into µnit; they're similar to the
+   simde_assert_*v macros above, but print in hex. */
+
+#define simde_assert_int8vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_int8_t, "02" PRIx8, nmemb, a, op, b)
+#define simde_assert_uint8vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_uint8_t, "02" PRIx8, nmemb, a, op, b)
+#define simde_assert_int16vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_int16_t, "04" PRIx16, nmemb, a, op, b)
+#define simde_assert_uint16vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_uint16_t, "04" PRIx16, nmemb, a, op, b)
+#define simde_assert_int32vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_int32_t, "08" PRIx32, nmemb, a, op, b)
+#define simde_assert_uint32vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_uint32_t, "08" PRIx32, nmemb, a, op, b)
+#define simde_assert_int64vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_int64_t, "016" PRIx64, nmemb, a, op, b)
+#define simde_assert_uint64vx(nmemb, a, op, b) \
+  simde_assert_array_full("0x", "", munit_uint64_t, "016" PRIx64, nmemb, a, op, b)
+
+#define simde_assert_int32_close(value, target) \
+  do { \
+    if (value != target && value != target + 1 && value != target - 1) \
+      munit_errorf("assertion failed: %s == %s (%" PRId32 " == %" PRId32 ")", #value, #target, value, target); \
+  } while (0)
+
+#define simde_assert_int64_close(value, target) \
+  do { \
+    if (value != target && value != target + 1 && value != target - 1) \
+      munit_errorf("assertion failed: %s == %s (%" PRId64 " == %" PRId64 ")", #value, #target, value, target); \
+  } while (0)
+
+HEDLEY_END_C_DECLS
+
+HEDLEY_DIAGNOSTIC_POP
+
+#if HEDLEY_HAS_WARNING("-Wpadded")
+#  pragma clang diagnostic ignored "-Wpadded"
+#elif defined(HEDLEY_MSVC_VERSION)
+#  pragma warning(disable:4324)
+#endif
+
+#if defined(HEDLEY_MSVC_VERSION)
+  /* nonstandard extension used : non-lvalue array converted to pointer */
+  #pragma warning(disable:4223)
+  /* Conditional expression is a constant */
+  #pragma warning(disable:4127)
+#endif
+
+#endif /* !defined(SIMDE_RUN_TESTS_H) */