sequenzo 0.1.17__cp311-cp311-win_amd64.whl → 0.1.19__cp311-cp311-win_amd64.whl

sequenzo/dissimilarity_measures/src/xsimd/test/test_batch_manip.cpp

@@ -3,6 +3,7 @@
  * Martin Renou                                                             *
  * Copyright (c) QuantStack                                                 *
  * Copyright (c) Serge Guelton                                              *
+ * Copyright (c) Marco Barbone                                              *
  *                                                                          *
  * Distributed under the terms of the BSD 3-Clause License.                 *
  *                                                                          *
@@ -14,101 +15,182 @@
 
 #include "test_utils.hpp"
 
+// Compile time tests for include/xsimd/arch/common/xsimd_common_swizzle.hpp
 namespace xsimd
 {
-    template <typename T, std::size_t N>
-    struct init_swizzle_base
+    namespace kernel
     {
-        using swizzle_vector_type = std::array<T, N>;
-        swizzle_vector_type lhs_in, exped_reverse, exped_fill, exped_dup, exped_ror, exped_rol;
-
-        template <int... Indices>
-        std::vector<swizzle_vector_type> create_swizzle_vectors()
+        namespace detail
         {
-            std::vector<swizzle_vector_type> vects;
-
-            /* Generate input data */
-            for (std::size_t i = 0; i < N; ++i)
-            {
-                lhs_in[i] = static_cast<T>(2 * i + 1);
-            }
-            vects.push_back(std::move(lhs_in));
-
-            /* Expected reversed data */
-            for (std::size_t i = 0; i < N; ++i)
-            {
-                exped_reverse[i] = lhs_in[N - 1 - i];
-                exped_fill[i] = lhs_in[N - 1];
-                exped_dup[i] = lhs_in[2 * (i / 2)];
-                exped_ror[i] = lhs_in[(i - 1) % N];
-                exped_rol[i] = lhs_in[(i + 1) % N];
-            }
-            vects.push_back(std::move(exped_reverse));
-            vects.push_back(std::move(exped_fill));
-            vects.push_back(std::move(exped_dup));
-            vects.push_back(std::move(exped_ror));
-            vects.push_back(std::move(exped_rol));
-
-            return vects;
+            // ────────────────────────────────────────────────────────────────────────
+            //  compile-time tests (identity, all-different, dup-lo, dup-hi)
+            //  8-lane identity
+            static_assert(is_identity<std::uint32_t, 0, 1, 2, 3, 4, 5, 6, 7>(), "identity failed");
+            // 8-lane reverse is all-different but not identity
+            static_assert(is_all_different<std::uint32_t, 7, 6, 5, 4, 3, 2, 1, 0>(), "all-diff failed");
+            static_assert(!is_identity<std::uint32_t, 7, 6, 5, 4, 3, 2, 1, 0>(), "identity on reverse");
+            // 8-lane dup-lo (repeat 0..3 twice)
+            static_assert(is_dup_lo<std::uint32_t, 0, 1, 2, 3, 0, 1, 2, 3>(), "dup_lo failed");
+            static_assert(!is_dup_hi<std::uint32_t, 0, 1, 2, 3, 0, 1, 2, 3>(), "dup_hi on dup_lo");
+            // 8-lane dup-hi (repeat 4..7 twice)
+            static_assert(is_dup_hi<std::uint32_t, 4, 5, 6, 7, 4, 5, 6, 7>(), "dup_hi failed");
+            static_assert(!is_dup_lo<std::uint32_t, 4, 5, 6, 7, 4, 5, 6, 7>(), "dup_lo on dup_hi");
+            // ────────────────────────────────────────────────────────────────────────
+            //  4-lane identity
+            static_assert(is_identity<std::uint32_t, 0, 1, 2, 3>(), "4-lane identity failed");
+            // 4-lane reverse all-different but not identity
+            static_assert(is_all_different<std::uint32_t, 3, 2, 1, 0>(), "4-lane all-diff failed");
+            static_assert(!is_identity<std::uint32_t, 3, 2, 1, 0>(), "4-lane identity on reverse");
+            // 4-lane dup-lo (repeat 0..1 twice)
+            static_assert(is_dup_lo<std::uint32_t, 0, 1, 0, 1>(), "4-lane dup_lo failed");
+            static_assert(!is_dup_hi<std::uint32_t, 0, 1, 0, 1>(), "4-lane dup_hi on dup_lo");
+            // 4-lane dup-hi (repeat 2..3 twice)
+            static_assert(is_dup_hi<std::uint32_t, 2, 3, 2, 3>(), "4-lane dup_hi failed");
+            static_assert(!is_dup_lo<std::uint32_t, 2, 3, 2, 3>(), "4-lane dup_lo on dup_hi");
+
+            static_assert(is_cross_lane<0, 1, 0, 1>(), "dup-lo only → crossing");
+            static_assert(is_cross_lane<2, 3, 2, 3>(), "dup-hi only → crossing");
+            static_assert(is_cross_lane<0, 3, 3, 3>(), "one low + rest high → crossing");
+            static_assert(!is_cross_lane<1, 0, 2, 3>(), "mixed low/high → no crossing");
+            static_assert(!is_cross_lane<0, 1, 2, 3>(), "mixed low/high → no crossing");
+
+            static_assert(no_duplicates_v<0, 1, 2, 3>(), "N=4: [0,1,2,3] → distinct");
+            static_assert(!no_duplicates_v<0, 1, 2, 2>(), "N=4: [0,1,2,2] → dup");
+
+            static_assert(no_duplicates_v<0, 1, 2, 3, 4, 5, 6, 7>(), "N=8: [0..7] → distinct");
+            static_assert(!no_duplicates_v<0, 1, 2, 3, 4, 5, 6, 0>(), "N=8: last repeats 0");
         }
-    };
+    }
 }
 
-template <class T>
-struct Reversor
+namespace xsimd
 {
-    static constexpr T get(T i, T n)
+    template <template <class> class Pattern, class Vec>
+    void fill_pattern(Vec& dst, const Vec& src)
     {
-        return n - 1 - i;
+        using size_type = typename Vec::size_type;
+        for (size_type i = 0; i < src.size(); ++i)
+        {
+            dst[i] = src[Pattern<size_type>::get(i, static_cast<size_type>(src.size()))];
+        }
     }
-};
 
-template <class T>
-struct Last
-{
-    static constexpr T get(T, T n)
+    template <class T>
+    struct Reversor
     {
-        return n - 1;
-    }
-};
+        static constexpr T get(T i, T n) { return n - 1 - i; }
+    };
+    template <class T>
+    struct Last
+    {
+        static constexpr T get(T, T n) { return n - 1; }
+    };
+    template <class T>
+    struct DupReal
+    {
+        static constexpr T get(T i, T) { return (i & ~T { 1 }); }
+    };
 
-template <class T>
-struct Dup
-{
-    static constexpr T get(T i, T)
+    template <class T>
+    struct DupImag
     {
-        return 2 * (i / 2);
-    }
-};
+        static constexpr T get(T i, T) { return (i & ~T { 1 }) + 1; }
+    };
+    template <class T>
+    struct SwapRI
+    {
+        static constexpr T get(T i, T)
+        {
+            return i ^ T { 1 };
+        }
+    };
+    template <class T>
+    struct Identity
+    {
+        static constexpr T get(T i, T) { return i; }
+    };
+    template <class T>
+    struct DupLowPair
+    {
+        static constexpr T get(T i, T) { return i / 2; }
+    };
+    template <class T>
+    struct DupHighPair
+    {
+        static constexpr T get(T i, T n) { return n / 2 + i / 2; }
+    };
 
-template <class T>
-struct as_index
-{
-    using type = xsimd::as_unsigned_integer_t<T>;
-};
+    template <class T>
+    struct RotateRight1
+    {
+        static constexpr T get(T i, T n) { return (i + n - 1) % n; }
+    };
+    template <class T>
+    struct RotateLeft1
+    {
+        static constexpr T get(T i, T n) { return (i + 1) % n; }
+    };
 
-template <class T>
-struct as_index<std::complex<T>> : as_index<T>
-{
-};
+    template <class T>
+    struct ReversePairs
+    {
+        static constexpr T get(T i, T) { return (i & ~T { 1 }) | (1 - (i & T { 1 })); }
+    };
+    template <class T>
+    struct EvenThenOdd
+    {
+        static constexpr T get(T i, T n)
+        {
+            return (i < n / 2 ? 2 * i : 2 * (i - n / 2) + 1);
+        }
+    };
+    template <class T>
+    struct OddThenEven
+    {
+        static constexpr T get(T i, T n)
+        {
+            return (i < n / 2 ? 2 * i + 1 : 2 * (i - n / 2));
+        }
+    };
+    template <class T>
+    struct InterleavePairs
+    {
+        static constexpr T get(T i, T n)
+        {
+            return (i & 1) ? (i / 2 + n / 2) : (i / 2);
+        }
+    };
+    template <class T>
+    struct as_index
+    {
+        using type = xsimd::as_unsigned_integer_t<T>;
+    };
 
+    template <class T>
+    struct as_index<std::complex<T>> : as_index<T>
+    {
+    };
+} // namespace xsimd
+
+//------------------------------------------------------------------------------
+// insert_test: unchanged from original
+//------------------------------------------------------------------------------
 template <class B>
 struct insert_test
 {
     using batch_type = B;
     using value_type = typename B::value_type;
-    static constexpr size_t size = B::size;
 
     void insert_first()
     {
         value_type fill_value = 0;
         value_type sentinel_value = 1;
         batch_type v(fill_value);
-        batch_type w = insert(v, sentinel_value, ::xsimd::index<0>());
-        std::array<value_type, batch_type::size> data;
+        batch_type w = xsimd::insert(v, sentinel_value, xsimd::index<0>());
+        std::array<value_type, batch_type::size> data {};
         w.store_unaligned(data.data());
         CHECK_SCALAR_EQ(data.front(), sentinel_value);
-        for (size_t i = 1; i < batch_type::size; ++i)
+        for (std::size_t i = 1; i < batch_type::size; ++i)
             CHECK_SCALAR_EQ(data[i], fill_value);
     }
 
@@ -117,10 +199,11 @@ struct insert_test
         value_type fill_value = 0;
         value_type sentinel_value = 1;
         batch_type v(fill_value);
-        batch_type w = insert(v, sentinel_value, ::xsimd::index<batch_type::size - 1>());
-        std::array<value_type, batch_type::size> data;
+        batch_type w = xsimd::insert(v, sentinel_value,
+                                     xsimd::index<batch_type::size - 1>());
+        std::array<value_type, batch_type::size> data {};
         w.store_unaligned(data.data());
-        for (size_t i = 0; i < batch_type::size - 1; ++i)
+        for (std::size_t i = 0; i < batch_type::size - 1; ++i)
             CHECK_SCALAR_EQ(data[i], fill_value);
         CHECK_SCALAR_EQ(data.back(), sentinel_value);
     }
@@ -129,15 +212,8 @@ struct insert_test
 TEST_CASE_TEMPLATE("[insert_test]", B, BATCH_TYPES)
 {
     insert_test<B> Test;
-    SUBCASE("insert_first")
-    {
-        Test.insert_first();
-    }
-
-    SUBCASE("insert_last")
-    {
-        Test.insert_last();
-    }
+    SUBCASE("insert_first") { Test.insert_first(); }
+    SUBCASE("insert_last") { Test.insert_last(); }
 }
 
 template <class B>
@@ -146,120 +222,87 @@ struct swizzle_test
     using batch_type = B;
     using value_type = typename B::value_type;
     using arch_type = typename B::arch_type;
-    static constexpr size_t size = B::size;
+    static constexpr std::size_t N = B::size;
+    using vec_t = std::array<value_type, N>;
 
-    void rotate_right()
+    // Build the input [1,3,5,...,2N-1]
+    static vec_t make_lhs()
     {
-        xsimd::init_swizzle_base<value_type, size> swizzle_base;
-        auto swizzle_vecs = swizzle_base.create_swizzle_vectors();
-        auto v_lhs = swizzle_vecs[0];
-        auto v_exped = swizzle_vecs[4];
-
-        B b_lhs = B::load_unaligned(v_lhs.data());
-        B b_exped = B::load_unaligned(v_exped.data());
-
-        B b_res = xsimd::rotate_right<1>(b_lhs);
-        CHECK_BATCH_EQ(b_res, b_exped);
+        vec_t v;
+        for (std::size_t i = 0; i < N; ++i)
+            v[i] = static_cast<value_type>(2 * i + 1);
+        return v;
     }
 
-    void rotate_left()
+    template <template <class> class Pattern>
+    void run()
     {
-        xsimd::init_swizzle_base<value_type, size> swizzle_base;
-        auto swizzle_vecs = swizzle_base.create_swizzle_vectors();
-        auto v_lhs = swizzle_vecs[0];
-        auto v_exped = swizzle_vecs[5];
+        vec_t lhs = make_lhs();
+        vec_t expect = lhs;
+        xsimd::fill_pattern<Pattern>(expect, lhs);
 
-        B b_lhs = B::load_unaligned(v_lhs.data());
-        B b_exped = B::load_unaligned(v_exped.data());
+        auto b_lhs = batch_type::load_unaligned(lhs.data());
+        auto b_expect = batch_type::load_unaligned(expect.data());
 
-        B b_res = xsimd::rotate_left<1>(b_lhs);
-        CHECK_BATCH_EQ(b_res, b_exped);
+        using idx_t = typename xsimd::as_index<value_type>::type;
+        auto idx_batch = xsimd::make_batch_constant<idx_t, Pattern<idx_t>, arch_type>();
+
+        CHECK_BATCH_EQ(xsimd::swizzle(b_lhs, idx_batch), b_expect);
+        CHECK_BATCH_EQ(xsimd::swizzle(b_lhs,
+                                      static_cast<xsimd::batch<idx_t, arch_type>>(idx_batch)),
+                       b_expect);
     }
 
-    void swizzle_reverse()
+    void rotate_right()
     {
-        xsimd::init_swizzle_base<value_type, size> swizzle_base;
-        auto swizzle_vecs = swizzle_base.create_swizzle_vectors();
-        auto v_lhs = swizzle_vecs[0];
-        auto v_exped = swizzle_vecs[1];
-
-        B b_lhs = B::load_unaligned(v_lhs.data());
-        B b_exped = B::load_unaligned(v_exped.data());
-
-        using index_type = typename as_index<value_type>::type;
-        auto index_batch = xsimd::make_batch_constant<index_type, Reversor<index_type>, arch_type>();
-
-        B b_res = xsimd::swizzle(b_lhs, index_batch);
-        CHECK_BATCH_EQ(b_res, b_exped);
-
-        B b_dyres = xsimd::swizzle(b_lhs, (xsimd::batch<index_type, arch_type>)index_batch);
-        CHECK_BATCH_EQ(b_dyres, b_exped);
+        vec_t lhs = make_lhs(), expect;
+        std::rotate_copy(lhs.begin(), lhs.end() - 1, lhs.end(), expect.begin());
+        CHECK_BATCH_EQ(xsimd::rotate_right<1>(batch_type::load_unaligned(lhs.data())),
+                       batch_type::load_unaligned(expect.data()));
     }
-
-    void swizzle_fill()
+    void rotate_left()
     {
-        xsimd::init_swizzle_base<value_type, size> swizzle_base;
-        auto swizzle_vecs = swizzle_base.create_swizzle_vectors();
-        auto v_lhs = swizzle_vecs[0];
-        auto v_exped = swizzle_vecs[2];
-
-        B b_lhs = B::load_unaligned(v_lhs.data());
-        B b_exped = B::load_unaligned(v_exped.data());
-
-        using index_type = typename as_index<value_type>::type;
-        auto index_batch = xsimd::make_batch_constant<index_type, Last<index_type>, arch_type>();
-
-        B b_res = xsimd::swizzle(b_lhs, index_batch);
-        CHECK_BATCH_EQ(b_res, b_exped);
-
-        B b_dyres = xsimd::swizzle(b_lhs, (xsimd::batch<index_type, arch_type>)index_batch);
-        CHECK_BATCH_EQ(b_dyres, b_exped);
+        vec_t lhs = make_lhs(), expect;
+        std::rotate_copy(lhs.begin(), lhs.begin() + 1, lhs.end(), expect.begin());
+        CHECK_BATCH_EQ(xsimd::rotate_left<1>(batch_type::load_unaligned(lhs.data())),
+                       batch_type::load_unaligned(expect.data()));
     }
-
-    void swizzle_dup()
+    void rotate_left_inv()
     {
-        xsimd::init_swizzle_base<value_type, size> swizzle_base;
-        auto swizzle_vecs = swizzle_base.create_swizzle_vectors();
-        auto v_lhs = swizzle_vecs[0];
-        auto v_exped = swizzle_vecs[3];
-
-        B b_lhs = B::load_unaligned(v_lhs.data());
-        B b_exped = B::load_unaligned(v_exped.data());
-
-        using index_type = typename as_index<value_type>::type;
-        auto index_batch = xsimd::make_batch_constant<index_type, Dup<index_type>, arch_type>();
-
-        B b_res = xsimd::swizzle(b_lhs, index_batch);
-        CHECK_BATCH_EQ(b_res, b_exped);
-
-        B b_dyres = xsimd::swizzle(b_lhs, (xsimd::batch<index_type, arch_type>)index_batch);
-        CHECK_BATCH_EQ(b_dyres, b_exped);
+        vec_t lhs = make_lhs(), expect;
+        std::rotate_copy(lhs.begin(), lhs.end() - 1, lhs.end(), expect.begin());
+        CHECK_BATCH_EQ(xsimd::rotate_left<N - 1>(batch_type::load_unaligned(lhs.data())),
+                       batch_type::load_unaligned(expect.data()));
     }
 };
 
+// Macro to instantiate one SUBCASE per pattern
+#define XSIMD_SWIZZLE_PATTERN_CASE(PAT) \
+    SUBCASE(#PAT) { swizzle_test<B>().template run<xsimd::PAT>(); }
+
 TEST_CASE_TEMPLATE("[swizzle]", B, BATCH_SWIZZLE_TYPES)
 {
-    swizzle_test<B> Test;
-    SUBCASE("reverse")
-    {
-        Test.swizzle_reverse();
-    }
-
-    SUBCASE("rotate")
-    {
-        Test.rotate_left();
-        Test.rotate_right();
-    }
-
-    SUBCASE("fill")
-    {
-        Test.swizzle_fill();
-    }
-
-    SUBCASE("dup")
-    {
-        Test.swizzle_dup();
-    }
+    // All existing patterns:
+    XSIMD_SWIZZLE_PATTERN_CASE(Reversor);
+    XSIMD_SWIZZLE_PATTERN_CASE(Last);
+    XSIMD_SWIZZLE_PATTERN_CASE(DupReal);
+    XSIMD_SWIZZLE_PATTERN_CASE(DupImag);
+    XSIMD_SWIZZLE_PATTERN_CASE(SwapRI);
+    XSIMD_SWIZZLE_PATTERN_CASE(Identity);
+    XSIMD_SWIZZLE_PATTERN_CASE(DupLowPair);
+    XSIMD_SWIZZLE_PATTERN_CASE(DupHighPair);
+    XSIMD_SWIZZLE_PATTERN_CASE(RotateRight1);
+    XSIMD_SWIZZLE_PATTERN_CASE(RotateLeft1);
+    XSIMD_SWIZZLE_PATTERN_CASE(ReversePairs);
+    XSIMD_SWIZZLE_PATTERN_CASE(EvenThenOdd);
+    XSIMD_SWIZZLE_PATTERN_CASE(OddThenEven);
+    XSIMD_SWIZZLE_PATTERN_CASE(InterleavePairs);
+    // Rotation checks:
+    SUBCASE("rotate_left") { swizzle_test<B>().rotate_left(); }
+    SUBCASE("rotate_left_inv") { swizzle_test<B>().rotate_left_inv(); }
+    SUBCASE("rotate_right") { swizzle_test<B>().rotate_right(); }
 }
 
-#endif
+#undef XSIMD_SWIZZLE_PATTERN_CASE
+
+#endif /* XSIMD_NO_SUPPORTED_ARCHITECTURE */

sequenzo/dissimilarity_measures/src/xsimd/test/test_load_store.cpp

@@ -39,7 +39,9 @@ struct load_store_test
     using ulong_vector_type = std::vector<unsigned long, allocator<unsigned long>>;
 #endif
     using float_vector_type = std::vector<float, allocator<float>>;
+#if !XSIMD_WITH_NEON || XSIMD_WITH_NEON64
     using double_vector_type = std::vector<double, allocator<double>>;
+#endif
 
     int8_vector_type i8_vec;
     uint8_vector_type ui8_vec;
@@ -54,7 +56,9 @@ struct load_store_test
     ulong_vector_type ul_vec;
 #endif
     float_vector_type f_vec;
+#if !XSIMD_WITH_NEON || XSIMD_WITH_NEON64
     double_vector_type d_vec;
+#endif
 
     array_type expected;
 
@@ -73,7 +77,9 @@ struct load_store_test
         init_test_vector(ul_vec);
 #endif
         init_test_vector(f_vec);
+#if !XSIMD_WITH_NEON || XSIMD_WITH_NEON64
         init_test_vector(d_vec);
+#endif
     }
 
     void test_load()

sequenzo/dissimilarity_measures/src/xsimd/test/test_memory.cpp

@@ -46,7 +46,7 @@ TEST_CASE("[is_aligned]")
     float f[100];
     void* unaligned_f = static_cast<void*>(&f[0]);
     constexpr std::size_t alignment = xsimd::default_arch::alignment();
-    std::size_t aligned_f_size;
+    std::size_t aligned_f_size = sizeof(f);
     void* aligned_f = std::align(alignment, sizeof(f), unaligned_f, aligned_f_size);
     CHECK_UNARY(xsimd::is_aligned(aligned_f));
 

sequenzo/dissimilarity_measures/src/xsimd/test/test_power.cpp

@@ -13,6 +13,7 @@
 #ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
 
 #include "test_utils.hpp"
+#include <iostream>
 
 template <class B>
 struct power_test
@@ -40,9 +41,9 @@ struct power_test
         for (size_t i = 0; i < nb_input; ++i)
         {
             zero_input[i] = 0;
-            lhs_input[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25));
+            lhs_input[i] = value_type(i / 4 + 1.2 * std::sqrt(i + 0.25));
             zlhs_input[i] = lhs_input[i] * (i % 2);
-            rhs_input[i] = value_type(10.2) / (i + 2) + value_type(0.25);
+            rhs_input[i] = value_type(10.2 / (i + 2) + 0.25);
         }
 
         expected.resize(nb_input);
@@ -103,6 +104,7 @@ struct power_test
             CHECK_EQ(diff, 0);
 #endif
         }
+#ifndef __FAST_MATH__
         // pow 0^-x
         {
             std::transform(zero_input.cbegin(), zero_input.cend(), rhs_input.cbegin(), expected.begin(),
@@ -120,17 +122,18 @@ struct power_test
             INFO("pow(0, -x)");
             CHECK_EQ(diff, 0);
         }
+#endif
         // ipow
         {
             long k = 0;
             std::transform(lhs_input.cbegin(), lhs_input.cend(), expected.begin(),
                            [&k, this](const value_type& l)
-                           { auto arg = k / size - nb_input / size / 2; ++k; return std::pow(l, arg); });
+                           { auto arg = k / size / 8000 - nb_input / size / 8000 / 2; ++k; return std::pow(l, arg); });
             batch_type lhs_in, out;
             for (size_t i = 0; i < nb_input; i += size)
             {
                 detail::load_batch(lhs_in, lhs_input, i);
-                out = pow(lhs_in, i / size - nb_input / size / 2);
+                out = pow(lhs_in, i / size / 8000 - nb_input / size / 8000 / 2);
                 detail::store_batch(out, res, i);
             }
             size_t diff = detail::get_nb_diff(res, expected);

sequenzo/dissimilarity_measures/src/xsimd/test/test_select.cpp

@@ -34,10 +34,14 @@ struct select_test
         nb_input = size * 10000;
         lhs_input.resize(nb_input);
         rhs_input.resize(nb_input);
+        auto clamp = [](double v)
+        {
+            return static_cast<value_type>(std::min(v, static_cast<double>(std::numeric_limits<value_type>::max())));
+        };
         for (size_t i = 0; i < nb_input; ++i)
         {
-            lhs_input[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25));
-            rhs_input[i] = value_type(10.2) / (i + 2) + value_type(0.25);
+            lhs_input[i] = clamp(i / 4 + 1.2 * std::sqrt(i + 0.25));
+            rhs_input[i] = clamp(10.2 / (i + 2) + 0.25);
         }
         expected.resize(nb_input);
         res.resize(nb_input);