minimap2 0.2.25.1 → 0.2.25.2

data/ext/minimap2/lib/simde/test/x86/test-avx.h

@@ -1,16 +0,0 @@
-#include "../../simde/x86/avx.h"
-
-#include "test-sse2.h"
-
-#if !defined(SIMDE_TEST_X86_AVX)
-#define SIMDE_TEST_X86_AVX
-
-SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m256, f32)
-SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m256d, f64)
-
-#define simde_assert_m256_close(a, b, precision) \
-  simde_assert_m256_f32_close_ex(__LINE__, __FILE__, a, b, precision)
-#define simde_assert_m256d_close(a, b, precision) \
-  simde_assert_m256d_f64_close_ex(__LINE__, __FILE__, a, b, precision)
-
-#endif /* !defined(SIMDE_TEST_X86_AVX) */

data/ext/minimap2/lib/simde/test/x86/test-avx512.h

@@ -1,25 +0,0 @@
-#include "../../simde/x86/avx512f.h"
-
-#include "test-avx.h"
-
-#if !defined(SIMDE_TEST_X86_AVX512)
-#define SIMDE_TEST_X86_AVX512
-
-SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m512, f32)
-SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m512d, f64)
-
-#define simde_assert_m512_close(a, b, precision) \
-  simde_assert_m512_f32_close_ex(__LINE__, __FILE__, a, b, precision)
-#define simde_assert_m512d_close(a, b, precision) \
-  simde_assert_m512d_f64_close_ex(__LINE__, __FILE__, a, b, precision)
-
-#define simde_assert_mmask8(a, op, b) \
-  munit_assert_uint8(HEDLEY_STATIC_CAST(uint8_t, a), op, HEDLEY_STATIC_CAST(uint8_t, b))
-#define simde_assert_mmask16(a, op, b) \
-  munit_assert_uint16(HEDLEY_STATIC_CAST(uint16_t, a), op, HEDLEY_STATIC_CAST(uint16_t, b))
-#define simde_assert_mmask32(a, op, b) \
-  munit_assert_uint32(HEDLEY_STATIC_CAST(uint32_t, a), op, HEDLEY_STATIC_CAST(uint32_t, b))
-#define simde_assert_mmask64(a, op, b) \
-  munit_assert_uint64(HEDLEY_STATIC_CAST(uint64_t, a), op, HEDLEY_STATIC_CAST(uint64_t, b))
-
-#endif /* !defined(SIMDE_TEST_X86_AVX512) */

data/ext/minimap2/lib/simde/test/x86/test-mmx.h

@@ -1,13 +0,0 @@
-#include "../../simde/x86/mmx.h"
-
-#include "test-x86-internal.h"
-
-#if !defined(SIMDE_TEST_X86_MMX)
-#define SIMDE_TEST_X86_MMX
-
-SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m64, f32)
-
-#define simde_assert_m64_close(a, b, precision) \
-  simde_assert_m64_f32_close_ex(__LINE__, __FILE__, a, b, precision)
-
-#endif /* !defined(SIMDE_TEST_X86_MMX) */

data/ext/minimap2/lib/simde/test/x86/test-sse.h

@@ -1,13 +0,0 @@
-#include "../../simde/x86/sse.h"
-
-#include "test-mmx.h"
-
-#if !defined(SIMDE_TEST_X86_SSE)
-#define SIMDE_TEST_X86_SSE
-
-SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m128, f32)
-
-#define simde_assert_m128_close(a, b, precision) \
-  simde_assert_m128_f32_close_ex(__LINE__, __FILE__, a, b, precision)
-
-#endif /* !defined(SIMDE_TEST_X86_SSE) */

data/ext/minimap2/lib/simde/test/x86/test-sse2.h

@@ -1,13 +0,0 @@
-#include "../../simde/x86/sse2.h"
-
-#include "test-sse.h"
-
-#if !defined(SIMDE_TEST_X86_SSE2)
-#define SIMDE_TEST_X86_SSE2
-
-SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m128d, f64)
-
-#define simde_assert_m128d_close(a, b, precision) \
-  simde_assert_m128d_f64_close_ex(__LINE__, __FILE__, a, b, precision)
-
-#endif /* !defined(SIMDE_TEST_X86_SSE2) */

data/ext/minimap2/lib/simde/test/x86/test-x86-internal.h

@@ -1,196 +0,0 @@
-#if !defined(SIMDE_TESTS_X86_INTERNAL_H)
-#define SIMDE_TESTS_CURRENT_ARCH x86
-
-#include "../run-tests.h"
-
-/* Assert that two vectors are bit-identical without worring about the
-   underlying type. */
-#define simde_assert_vec_equal(a, b, T) do { \
-    const T##_private simde_a_ = T##_to_private(a); \
-    const T##_private simde_b_ = T##_to_private(b); \
-    for (int simde_i_ = 0 ; simde_i_ < HEDLEY_STATIC_CAST(int, (sizeof(simde_a_.u32f) / sizeof(simde_a_.u32f[0]))) ; simde_i_++) { \
-      if (HEDLEY_UNLIKELY(simde_a_.u32f[simde_i_] != simde_b_.u32f[simde_i_])) { \
-        munit_errorf("assertion failed: " #a ".u32f[%d] (%" PRIxFAST32 ") != " #b ".u32f[%d] (%" PRIxFAST32 ")", \
-            simde_i_, simde_a_.u32f[simde_i_], \
-            simde_i_, simde_b_.u32f[simde_i_]); \
-      } \
-    } \
-  } while(0)
-#define simde_assert_m64_equal(a, b) \
-  simde_assert_vec_equal(a, b, simde__m64)
-#define simde_assert_m128_equal(a, b) \
-  simde_assert_vec_equal(a, b, simde__m128)
-#define simde_assert_m128i_equal(a, b) \
-  simde_assert_vec_equal(a, b, simde__m128i)
-#define simde_assert_m128d_equal(a, b) \
-  simde_assert_vec_equal(a, b, simde__m128d)
-#define simde_assert_m256_equal(a, b) \
-  simde_assert_vec_equal(a, b, simde__m256)
-#define simde_assert_m256i_equal(a, b) \
-  simde_assert_vec_equal(a, b, simde__m256i)
-#define simde_assert_m256d_equal(a, b) \
-  simde_assert_vec_equal(a, b, simde__m256d)
-
-/* Assert that every integer in two vectors are equal */
-#define simde_assert_vec_i(a, op, b, T, accessor, fmt) do { \
-      const T##_private simde_a_ = T##_to_private(a); \
-      const T##_private simde_b_ = T##_to_private(b); \
-      for (int simde_i_ = 0 ; simde_i_ < HEDLEY_STATIC_CAST(int, (sizeof(simde_a_.accessor) / sizeof(simde_a_.accessor[0]))) ; simde_i_++) { \
-        if (HEDLEY_UNLIKELY(!(simde_a_.accessor[simde_i_] op simde_b_.accessor[simde_i_]))) { \
-          munit_errorf("assertion failed: " #a "." #accessor "[%d] " #op " " #b "." #accessor "[%d] (%" fmt " " #op " %" fmt ")", \
-              simde_i_, simde_i_, simde_a_.accessor[simde_i_], simde_b_.accessor[simde_i_]); \
-        } \
-      } \
-    } while (0)
-#define simde_assert_m512i_i8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i,  i8,  PRId8)
-#define simde_assert_m512i_i16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i, i16, PRId16)
-#define simde_assert_m512i_i32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i, i32, PRId32)
-#define simde_assert_m512i_i64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i, i64, PRId64)
-#define simde_assert_m512i_u8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i,  u8,  PRIu8)
-#define simde_assert_m512i_u16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i, u16, PRIu16)
-#define simde_assert_m512i_u32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i, u32, PRIu32)
-#define simde_assert_m512i_u64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m512i, u64, PRIu64)
-#define simde_assert_m256i_i8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i,  i8,  PRId8)
-#define simde_assert_m256i_i16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i, i16, PRId16)
-#define simde_assert_m256i_i32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i, i32, PRId32)
-#define simde_assert_m256i_i64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i, i64, PRId64)
-#define simde_assert_m256i_u8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i,  u8,  PRIu8)
-#define simde_assert_m256i_u16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i, u16, PRIu16)
-#define simde_assert_m256i_u32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i, u32, PRIu32)
-#define simde_assert_m256i_u64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m256i, u64, PRIu64)
-#define simde_assert_m128i_i8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i,  i8,  PRId8)
-#define simde_assert_m128i_i16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i, i16, PRId16)
-#define simde_assert_m128i_i32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i, i32, PRId32)
-#define simde_assert_m128i_i64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i, i64, PRId64)
-#define simde_assert_m128i_u8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i,  u8,  PRIu8)
-#define simde_assert_m128i_u16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i, u16, PRIu16)
-#define simde_assert_m128i_u32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i, u32, PRIu32)
-#define simde_assert_m128i_u64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m128i, u64, PRIu64)
-#define simde_assert_m64_i8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64,  i8,  PRId8)
-#define simde_assert_m64_i16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64, i16, PRId16)
-#define simde_assert_m64_i32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64, i32, PRId32)
-#define simde_assert_m64_i64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64, i64, PRId64)
-#define simde_assert_m64_u8(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64,  u8,  PRIu8)
-#define simde_assert_m64_u16(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64, u16, PRIu16)
-#define simde_assert_m64_u32(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64, u32, PRIu32)
-#define simde_assert_m64_u64(a, op, b) \
-  simde_assert_vec_i(a, op, b, simde__m64, u64, PRIu64)
-
-/* Assert that the integer values in each vector are approximately equal. */
-#define simde_assert_vec_i_close(a, b, precision, T, accessor, fmt) do { \
-      const T##_private simde_a_ = T##_to_private(a); \
-      const T##_private simde_b_ = T##_to_private(b); \
-      for (int simde_i_ = 0 ; simde_i_ < HEDLEY_STATIC_CAST(int, (sizeof(simde_a_.accessor) / sizeof(simde_a_.accessor[0]))) ; simde_i_++) { \
-        if (!((simde_a_.accessor[simde_i_] <= (simde_b_.accessor[simde_i_] + precision)) && (simde_a_.accessor[simde_i_] >= (simde_b_.accessor[simde_i_] - precision)))) { \
-          munit_errorf("assertion failed: " #a "." #accessor "[%d] " SIMDE_ALMOST_EQUAL_TO " " #b "." #accessor "[%d] (%" fmt " " SIMDE_ALMOST_EQUAL_TO " %" fmt ")", \
-              simde_i_, simde_i_, simde_a_.accessor[simde_i_], simde_b_.accessor[simde_i_]); \
-        } \
-      } \
-    } while(0)
-
-#define simde_assert_m64_i8_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, i8, PRId8)
-#define simde_assert_m64_i16_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, i16, PRId16)
-#define simde_assert_m64_i32_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, i32, PRId32)
-#define simde_assert_m64_i64_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, i64, PRId64)
-#define simde_assert_m64_u8_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, u8, PRIu8)
-#define simde_assert_m64_u16_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, u16, PRIu16)
-#define simde_assert_m64_u32_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, u32, PRIu32)
-#define simde_assert_m64_u64_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m64, u64, PRIu64)
-#define simde_assert_m128i_i8_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, i8, PRId8)
-#define simde_assert_m128i_i16_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, i16, PRId16)
-#define simde_assert_m128i_i32_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, i32, PRId32)
-#define simde_assert_m128i_i64_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, i64, PRId64)
-#define simde_assert_m128i_u8_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, u8, PRIu8)
-#define simde_assert_m128i_u16_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, u16, PRIu16)
-#define simde_assert_m128i_u32_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, u32, PRIu32)
-#define simde_assert_m128i_u64_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m128i, u64, PRIu64)
-#define simde_assert_m256i_i8_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, i8, PRId8)
-#define simde_assert_m256i_i16_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, i16, PRId16)
-#define simde_assert_m256i_i32_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, i32, PRId32)
-#define simde_assert_m256i_i64_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, i64, PRId64)
-#define simde_assert_m256i_u8_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, u8, PRIu8)
-#define simde_assert_m256i_u16_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, u16, PRIu16)
-#define simde_assert_m256i_u32_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, u32, PRIu32)
-#define simde_assert_m256i_u64_close(a, b, precision) \
-  simde_assert_vec_i_close(a, b, precision, simde__m256i, u64, PRIu64)
-
-HEDLEY_BEGIN_C_DECLS
-
-#define SIMDE_TESTS_GENERATE_SUITE_GETTERS(isax) \
-  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, c)(void); \
-  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, cpp)(void); \
-  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   c)(void); \
-  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   cpp)(void)
-
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(mmx);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse2);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse3);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(ssse3);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse4_1);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse4_2);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(fma);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx2);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx512f);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx512bw);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx512vl);
-SIMDE_TESTS_GENERATE_SUITE_GETTERS(svml);
-
-HEDLEY_END_C_DECLS
-
-#endif /* !defined(SIMDE_TESTS_X86_INTERNAL_H) */

data/ext/minimap2/lib/simde/test/x86/test-x86.c

@@ -1,48 +0,0 @@
-#include "test-x86.h"
-#include "test-x86-internal.h"
-
-#include <stdio.h>
-
-#if defined(SIMDE_BUILD_CPP_TESTS)
-#define SUITES_PER_ISAX 4
-#define SET_CHILDREN_FOR_ARCH(isax) \
-  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, c)(); \
-  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   c)(); \
-  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, cpp)(); \
-  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   cpp)()
-#else
-#define SUITES_PER_ISAX 2
-#define SET_CHILDREN_FOR_ARCH(isax) \
-  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, c)(); \
-  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   c)()
-#endif
-
-MunitSuite*
-simde_tests_x86_get_suite(void) {
-  static MunitSuite children[(14 * SUITES_PER_ISAX) + 1];
-  static MunitSuite suite = { "/x86", NULL, children, 1, MUNIT_SUITE_OPTION_NONE };
-  static const MunitSuite empty = { NULL, NULL, NULL, 1, MUNIT_SUITE_OPTION_NONE };
-
-  size_t i = 0;
-
-  SET_CHILDREN_FOR_ARCH(mmx);
-  SET_CHILDREN_FOR_ARCH(sse);
-  SET_CHILDREN_FOR_ARCH(sse2);
-  SET_CHILDREN_FOR_ARCH(sse3);
-  SET_CHILDREN_FOR_ARCH(ssse3);
-  SET_CHILDREN_FOR_ARCH(sse4_1);
-  SET_CHILDREN_FOR_ARCH(sse4_2);
-  SET_CHILDREN_FOR_ARCH(avx);
-  SET_CHILDREN_FOR_ARCH(fma);
-  SET_CHILDREN_FOR_ARCH(avx2);
-  SET_CHILDREN_FOR_ARCH(avx512f);
-  SET_CHILDREN_FOR_ARCH(avx512bw);
-  SET_CHILDREN_FOR_ARCH(avx512vl);
-  SET_CHILDREN_FOR_ARCH(svml);
-
-  children[i++] = empty;
-
-  munit_assert_size(i, <=, sizeof(children) / sizeof(children[0]));
-
-  return &suite;
-}

data/ext/minimap2/lib/simde/test/x86/test-x86.h

@@ -1,8 +0,0 @@
-#include "../../simde/hedley.h"
-#include "../munit/munit.h"
-
-HEDLEY_BEGIN_C_DECLS
-
-MunitSuite* simde_tests_x86_get_suite(void);
-
-HEDLEY_END_C_DECLS