#include <stdio.h>

// 相邻元素去重
int	removeDuplicates(int* nums, int n){
	if	(n	==	0)	return	0;
	int	slow	=	0,	fast	=	1;
	while	(fast	<	n)	{
		if	(nums[fast]	!=	nums[slow])	{
			slow++;
			//	维护	nums[0..slow]	⽆重复
			nums[slow]	=	nums[fast];
		}
		fast++;
	}
	//	⻓度为索引	+	1
	return	slow	+	1;
 }
 
 // 相同元素去重 set
 int toSet(int* nums, _Bool* flag, int n){
	if	(n	==	0)	return	0;
	int	slow	=	0,	fast	=	1;
	while	(fast	<	n)	{
        int  hashcode = nums[fast] % n;
		if	(nums[fast]	!=	nums[slow] && !flag[hashcode])	{
		    flag[hashcode] = 1;
			slow++;
			//	维护	nums[0..slow]	⽆重复
			nums[slow]	=	nums[fast];
		}
		fast++;
	}
	//	⻓度为索引	+	1
	return	slow	+	1;
 }
 
 
 void main() {
     int a[10] = {1, 1, 2, 2, 1, 1, 3, 1, 2, 2};
     int size = removeDuplicates(a, 10);
     for(int i = 0; i < size; ++i)
        printf("%d ", a[i]);
     printf("\n ");
     
    _Bool flag[10] = {0};    
    size = toSet(a, flag, 10);
    for(int i = 0; i < size; ++i)
        printf("%d ", a[i]);
     
 }

#include <stdio.h>

const char* matchString(const char* content, const char* sub) {
	// 数据初始化
	size_t size = strlen(content);
	size_t sub_size = strlen(sub);
	int flag[256] = {0};		// 字符数统计
	
	// 搜索区间
	const char* begin = content;
	const char* end = content + size;
	
	// 双指针动态滑动窗口
	const char* _left = begin;
	const char* right = begin;
	
	// 滑动匹配
	for(;right < end; ++right) {
		++flag[*right];	// 窗口内字符数统计
		
		// 缩小窗口，寻找可行解
		int i = 0;
		for(; i < sub_size;) {
			if(right - _left < sub_size)
				break;	// 窗口失效
			if(!flag[*(sub + i)])
				break; // 窗口失效
			if(*(_left + i) != *(sub + i)) {
				--flag[*(_left + i)]; // 窗口内字符数更新
				++_left;
				i= 0;
				continue;	// 缩小窗口，重新匹配
			}
			++i;
		}
		
		if(i == sub_size)
			return _left;  // 查找成功
	}
	return end;	// 查找失败
}
	
int main () {
	printf("%s\n", matchString("abccbaaabcbaabcacbacb", "acb"));
	return 0;
}

#include "property_bindings/src/property.h"
#include <iostream>

int calculateArea(int width, int height) {
  return (width * height) * 0.5;
}

struct rectangle {
  property<rectangle*> parent = nullptr;
  property<int> width = 150;
  property<int> height = 75;
  property<int> area = [&]{ return calculateArea(width, height); };

  property<std::string> color = [&]{
    if (parent() && area > parent()->area)
      return std::string("blue");
    else
      return std::string("red");
  };
};

int test() {
  rectangle parent;
  rectangle child;
  std::cout << child.color() << std::endl;
  //outputs "red"
  child.parent = &parent;
  parent.width = 2;
  std::cout << child.color() << std::endl;
  //outputs "blue"
  return 1;
}

#define ORYOL_WINDOWS   1

#include "callstack/StackWalker.h"
#include "callstack/StackTrace.h"
#include "callstack/StackWalker.cc"
#include "callstack/StackTrace.cc"


void func() {
    char callstack[4096];
    Oryol::StackTrace::Dump(callstack, sizeof(callstack));
}

void test() {
    func();
}

#include <type_traits>
#include <utility>
#include <cstdint>
#include <iostream>

template<class T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
constexpr std::underlying_type_t<T> to_underlying(T t) noexcept
{
    return static_cast<std::underlying_type_t<T>>(t);
}

template<class R, class T, std::enable_if_t<std::is_enum_v<R>, int> = 0,
    std::enable_if_t<!std::is_enum_v<T>, int> = 0>
constexpr R to_underlying(R& val, T t) noexcept
{
    using UnderlyingType = std::underlying_type_t<R>;
    UnderlyingType underlyingColor = static_cast<UnderlyingType>(t);
    val = static_cast<R>(underlyingColor);
    return val;
}

template<class T, std::enable_if_t<!std::is_enum_v<T>, int> = 0>
constexpr T to_underlying(T t) noexcept
{
    return t;
}


void test() {
    enum class E : std::uint8_t { A = 0, B, C };   
    int x = to_underlying(E::B);
    int x1 = to_underlying(E::A);
    std::cout << x << "," << x1 << std::endl;
}

// 模板参数类型区分
template <class T>
static std::string cppdemangle() {
    std::string s{cppdemangle(typeid(std::remove_cv_t<std::remove_reference_t<T>>))};
    if (std::is_const_v<std::remove_reference_t<T>>)
        s += " const";
    if (std::is_volatile_v<std::remove_reference_t<T>>)
        s += " volatile";
    if (std::is_lvalue_reference_v<T>)
        s += " &";
    if (std::is_rvalue_reference_v<T>)
        s += " &&";
    return s;
}

// 显示转换枚举值
template <class T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
constexpr std::underlying_type_t<T> to_underlying(T t) noexcept {
    return static_cast<std::underlying_type_t<T>>(t);
}

template <class T, std::enable_if_t<!std::is_enum_v<T>, int> = 0>
constexpr T to_underlying(T t) noexcept {
    return t;
}

//文件操作
static std::string file_get_content(std::string const &path) {
  std::ifstream fin(path);
  std::string content;
  std::istreambuf_iterator<char> iit(fin), eiit;
  std::back_insert_iterator<std::string> sit(content);
  std::copy(iit, eiit, sit);
  return content;
}

static void file_put_content(std::string const &path, std::string const &content) {
  std::ofstream fout(path);
  fout << content;
}

static bool file_exists(std::string const &path) {
  std::ifstream fin(path);
  return (bool)fin;
}

// win min max冲突
#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX
#endif
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#endif
/* FUN FACT: DID YOU KNOW THAT MICROSOFT BUYS GITHUB? */
#if __has_include(<windows.h>)
#include <windows.h>
#elif __has_include(<math.h>)
#include <math.h>
#endif
/* FUN FACT: DID YOU KNOW THAT MICROSOFT INVENTS VSCODE? */
#ifdef min
#undef min
#endif
#ifdef max
#undef max
#endif
#ifdef near
#undef near
#endif
#ifdef far
#undef far
#endif
#endif

// 耗时
#define TICK(x) auto bench_##x = std::chrono::steady_clock::now();
#define TOCK(x) std::printf("%s: %lfs\n", #x, std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - bench_##x).count());

// 随机字符串生成
inline std::string randomStringGenerator(const int len)
{
std::string res;
static const char alphanum[] = "0123456789"
							   "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
							   "abcdefghijklmnopqrstuvwxyz";

for (int i = 0; i < len; ++i)
  res += alphanum[((size_t)std::rand() % (sizeof(alphanum) - 1))];
return res;
}

//	C++20之三目运算
template<typename T>
void compare(T x, T y)
{
    auto ret = x <=> y;
    std::cout << "name: " << typeid(ret).name() << std::endl;
    if (ret < 0)
        std::cout << "x < y:" << x << "," << y << std::endl;
    else if (ret == 0)
        std::cout << "x == y:" << x << "," << y << std::endl;
    else
        std::cout << "x > y:" << x << "," << y << std::endl;
}

// C++20之字符与数值转换
#include <charconv>
// std::to_chars: converts an integer or floating-point value to a character sequence
std::array<char, 10> buffer;
// 注意:std::errc没有到bool的隐式转换,所以你不能像下面这样检查: if (res.ec) {} or if (!res.ec) {}
if (auto [ptr, ec] = std::to_chars(buffer.data(), buffer.data() + buffer.size(), val_int); ec == std::errc()) {
	std::cout << "str:" << std::string_view(buffer.data(), ptr - buffer.data()) << "\n"; // str:88
	*ptr = '\0'; // 保证结尾有一个空字符
	std::cout << "buffer:" << buffer.data() << "\n"; // buffer:88
} else {
	std::cerr << "fail to call to_char:" << std::make_error_code(ec).message() << "\n";
	return -1;
}

auto str2 = "456.789";
float val2{ 0.f };
auto [ptr2, ec2] = std::from_chars(str2.data(), str2.data() + str2.size(), val2);
if (ec2 == std::errc())
	std::cout << "val2:" << val2 << "\n"; // val2:456.789
else if (ec2 == std::errc::invalid_argument)
	std::cerr << "Error: this is not a number: " << str2 << "\n";
else if (ec2 == std::errc::result_out_of_range)
	std::cerr << "Error: this number is larger than an float: " << str2 << "\n";
else
	std::cerr << "fail to call from_chars:" << std::make_error_code(ec2).message() << "\n";
	
// C++17之并行策略
#include <algorithm>
#include <iostream>
#include <vector>
#include <execution>
std::vector<int> v = { 5, 2, 3, 1, 4 };
std::vector<int> v2(5);
std::sort(std::execution::seq, v.begin(), v.end());		// 向量
std::for_each(std::execution::unseq, v.begin(), v.end(), [](int x) { std::cout << x << " "; });	// 向量化单线程
std::transform(std::execution::par, v1.begin(), v1.end(), v2.begin(), [](int x) { return x * x; });  // 多线程
std::for_each(std::execution::par_unseq, v.begin(), v.end(), [](int x) { std::cout << x << " "; });	 // 硬软件或SMID

https://www.geeksforgeeks.org/execution-policy-of-stl-algorithms-in-modern-cpp/

// C++头文件定义全局变量

class InlineVariable {
public:
	inline static int var{ 10 }; // 不带inline,则只能在类外初始化;即使在类外初始化,如果被多个cpp文件包含也会error;带inline后,即使被多个cpp文件包含也OK
	inline static std::string name{ "Messy_Test" }; // 整个程序中只有一个
	inline static thread_local int count{ 1 }; // 每个线程有一个
	std::string city{ "BeiJing" }; // 每个实例有一个
};
inline InlineVariable inline_variable; // 不带inline,则会报重复定义;带inline后,即使被多个cpp文件包含也OK

// 获取实际对象地址
std::addressof(c)

#include <string>
#include <sstream>
#include <algorithm>
#include <iostream>
#include <iomanip>

template <class T0, class T1, class = void>
struct _has_stream_bit_shl : std::false_type {};

template <class T0, class T1>
struct _has_stream_bit_shl<T0, T1, std::void_t<decltype(
    std::declval<T0>() << std::declval<T1>()
    )>> : std::true_type {};

template <class T, class = void>
struct _has_range_begin_end : std::false_type {};

template <class T>
struct _has_range_begin_end<T, std::void_t<decltype(
    std::begin(std::declval<T>()) != std::end(std::declval<T>())
    )>> : std::true_type {};

template <class T, class = void>
struct _has_tuple_size : std::false_type {};

template <class T>
struct _has_tuple_size<T, std::void_t<decltype(
    std::tuple_size<T>::value
    )>> : std::true_type {};

struct _to_stream_impl {
    template <class Os, class T, std::size_t ...Is>
    static void _helper_tuple_to_stream(Os& os, T const& t, std::string_view fms, std::index_sequence<Is...>) {
        os << '(';
        (to_stream(os, std::get<0>(t), fms), ..., (os << ' ', to_stream(os, std::get<Is + 1>(t), fms)));
        os << ')';
    }

    template <class Os, class T, std::enable_if_t<!_has_stream_bit_shl<Os&, T const&>::value
        && (std::tuple_size<T>::value >= 1), int> = 0>
    static void to_stream(Os& os, T const& t, std::string_view fms) {
        return _helper_tuple_to_stream(os, t, fms, std::make_index_sequence<std::tuple_size_v<T> -1>{});
    }

    template <class Os, class T>
    static auto to_stream(Os& os, T const& t, std::string_view fms) -> decltype((std::enable_if_t<!_has_stream_bit_shl<Os&, T const&>::value && !_has_range_begin_end<T>::value, void>)(std::declval<T&>()[0], std::declval<T&>().length())) {
        os << "[glm: ";
        for (int i = 0; i < t.length(); ++i) {
            to_stream(os, t[i], fms);
            os << ", ";
        }
        os << "]";
    }

    template <class Os, class T, std::enable_if_t<!_has_stream_bit_shl<Os&, T const&>::value
        && (std::tuple_size<T>::value == 0), int> = 0>
    static void to_stream(Os& os, T const& t, std::string_view fms) {
        os << "()";
    }

    template <class Os, class T, std::enable_if_t<!_has_stream_bit_shl<Os&, T const&>::value
        && !_has_tuple_size<T>::value&& _has_range_begin_end<T>::value, int> = 0>
    static void to_stream(Os& os, T const& t, std::string_view fms) {
        auto it = std::begin(t);
        auto eit = std::end(t);
        os << '[';
        if (it != eit) {
            to_stream(os, *it, fms);
            ++it;
            for (; it != eit; ++it) {
                os << ' ';
                to_stream(os, *it, fms);
            }
        }
        os << ']';
    }

    template <class Os, class T, std::enable_if_t<_has_stream_bit_shl<Os&, T const&>::value && !std::is_enum<T>::value, int> = 0>
    static void to_stream(Os& os, T const& t, std::string_view fms) {
        auto flgs = os.flags();
        if (fms.size() != 0) {
            if (fms.size() != 0 && fms[0] == '-') {
                fms = fms.substr(1);
                os << std::right;
            }
            if (fms.size() != 0 && fms[0] == '0') {
                fms = fms.substr(1);
                os << std::setfill('0');
            }
            {
                int tmp = 0;
                while (fms.size() != 0 && '0' <= fms[0] && '9' >= fms[0]) {
                    tmp *= 10;
                    tmp += fms[0] - '0';
                    fms = fms.substr(1);
                }
                if (tmp != 0)
                    os << std::setw(tmp);
            }
            if (fms.size() != 0 && fms[0] == '.') {
                fms = fms.substr(1);
                int tmp = 0;
                while (fms.size() != 0 && '0' <= fms[0] && '9' >= fms[0]) {
                    tmp *= 10;
                    tmp += fms[0] - '0';
                    fms = fms.substr(1);
                }
                os << std::setprecision(tmp);
            }
            if (fms.size() != 0) {
                switch (fms[0]) {
                case 'x': os << std::hex; break;
                case 'd': os << std::dec; break;
                case 'o': os << std::oct; break;
                };
            }
        }
        os << t;
        os.flags(flgs);
    }

    template <class Os, class T, std::enable_if_t<std::is_enum<T>::value
        && _has_stream_bit_shl<Os&, typename std::underlying_type<T>::type const&>::value, int> = 0>
    static void to_stream(Os& os, T const& t, std::string_view fms) {
        os << std::underlying_type_t<T>{t};
    }
};



template <class Os, class T>
void to_stream(Os& os, T const& t, std::string_view fms) {
    _to_stream_impl::to_stream(os, t, fms);
}

template <class T>
std::string to_string(T const& t, std::string_view fms) {
    std::ostringstream ss;
    to_stream(ss, t, fms);
    return ss.str();
}

template <class T>
std::string to_string(T const& t) {
    if constexpr (std::is_convertible_v<T, std::string>) {
        return t;
    }
    else {
        std::ostringstream ss;
        to_stream(ss, t, {});
        return ss.str();
    }
}



template <int curr, class Os, class It, class ...Args>
bool __format(Os& os, It fb, It fe, std::tuple<Args const &...> const& args) {
    if constexpr (curr >= sizeof...(Args)) {
        if (fb != fe)
            os << std::string_view(fb, fe - fb);
        return curr > sizeof...(Args);
    }
    else {
        if (fb == fe) return false;
        auto ib = std::find(fb, fe, '{');
        if (ib == fe) return false;
        os << std::string_view(fb, ib - fb);
        ++ib;
        auto ie = std::find(ib, fe, '}');
        if (ie == fe) return false;
        ++ie;
        auto fms = std::string_view(ib, ie - ib);
        if (auto i = fms.find(':'); i != std::string_view::npos) {
            fms = fms.substr(i + 1);
        }
        to_stream(os, std::get<curr>(args), fms);
        return __format<curr + 1>(os, ie, fe, args);
    }
}

template <class Os, class ...Args>
bool format_to(Os& os, std::string_view fmt, Args const &...args) {
    return __format<0>(os, fmt.data(), fmt.data() + fmt.size(), std::tuple<Args const &...>(args...));
}

template <class ...Args>
std::string format(std::string_view fmt, Args const &...args) {
    std::stringstream ss;
    format_to(ss, fmt, args...);
    return ss.str();
}


void test() {
    std::cout << format("add({}+{})={}\n", 1, 2, 3);
}

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <stdarg.h>
#include <string>

template <class ...Ts>
std::string cformat(const char *fmt, Ts &&...ts) {
    int n = snprintf(nullptr, 0, fmt, std::forward<Ts>(ts)...);
    if (n < 0) return {};
    std::string res;
    res.resize(n + 2);
    n = snprintf(res.data(), n + 1, fmt, std::forward<Ts>(ts)...);
    res.resize(n);
    return res;
}

#include <faiss/utils/simdlib.h>

#include <cstddef>
#include <cstdint>
#include <memory>
#include <random>
#include <vector>

#include <omp.h>

#include <faiss/IndexFlat.h>
#include <faiss/IndexIVFPQFastScan.h>
#include <faiss/impl/AuxIndexStructures.h>

#include <faiss/IndexFlat.h>
//#include <faiss/gpu/GpuIndexFlat.h>
//#include <faiss/gpu/GpuIndexIVFFlat.h>
//#include <faiss/gpu/StandardGpuResources.h>


using namespace faiss;


void testCmpltAndBlendInplace() {
    simd8float32 lowestValues(0, 1, 2, 3, 4, 5, 6, 7);
    simd8uint32 lowestIndices(0, 1, 2, 3, 4, 5, 6, 7);

    simd8float32 candidateValues0(5, 5, 5, 5, 5, 5, 5, 5);
    simd8uint32 candidateIndices0(10, 11, 12, 13, 14, 15, 16, 17);
    cmplt_and_blend_inplace(
        candidateValues0, candidateIndices0, lowestValues, lowestIndices);

    simd8float32 candidateValues1(6, 6, 6, 6, 6, 6, 6, 6);
    simd8uint32 candidateIndices1(20, 21, 22, 23, 24, 25, 26, 27);
    cmplt_and_blend_inplace(
        candidateValues1, candidateIndices1, lowestValues, lowestIndices);

    simd8float32 candidateValues2(0, 1, 2, 3, 4, 5, 5, 5);
    simd8uint32 candidateIndices2(30, 31, 32, 33, 34, 35, 36, 37);
    cmplt_and_blend_inplace(
        candidateValues2, candidateIndices2, lowestValues, lowestIndices);

    simd8float32 expectedValues(0, 1, 2, 3, 4, 5, 5, 5);
    simd8uint32 expectedIndices(0, 1, 2, 3, 4, 5, 16, 17);
    //ASSERT_TRUE(lowestValues.is_same_as(expectedValues));
    //ASSERT_TRUE(lowestIndices.is_same_as(expectedIndices));
}

void testCmpltMinMaxFloat() {
    simd8float32 minValues(0, 0, 0, 0, 0, 0, 0, 0);
    simd8uint32 minIndices(0, 0, 0, 0, 0, 0, 0, 0);
    simd8float32 maxValues(0, 0, 0, 0, 0, 0, 0, 0);
    simd8uint32 maxIndices(0, 0, 0, 0, 0, 0, 0, 0);

    simd8float32 candidateValues0(5, 5, 5, 5, 5, 5, 5, 5);
    simd8uint32 candidateIndices0(10, 11, 12, 13, 14, 15, 16, 17);
    simd8float32 currentValues0(0, 1, 2, 3, 4, 5, 6, 7);
    simd8uint32 currentIndices0(0, 1, 2, 3, 4, 5, 6, 7);

    cmplt_min_max_fast(
        candidateValues0,
        candidateIndices0,
        currentValues0,
        currentIndices0,
        minValues,
        minIndices,
        maxValues,
        maxIndices);

    simd8float32 expectedMinValues(0, 1, 2, 3, 4, 5, 5, 5);
    simd8uint32 expectedMinIndices(0, 1, 2, 3, 4, 5, 16, 17);
    //ASSERT_TRUE(minValues.is_same_as(expectedMinValues));
    //ASSERT_TRUE(minIndices.is_same_as(expectedMinIndices));

    simd8float32 expectedMaxValues(5, 5, 5, 5, 5, 5, 6, 7);
    // the result is not 10,11,12,13,14,5,6,7 because it is _fast version
    simd8uint32 expectedMaxIndices(10, 11, 12, 13, 14, 15, 6, 7);
    //ASSERT_TRUE(maxValues.is_same_as(expectedMaxValues));
    //ASSERT_TRUE(maxIndices.is_same_as(expectedMaxIndices));
}

void testSearch() {
    // small vectors and database
    int d = 64;
    size_t nb = 4000;

    // ivf centroids
    size_t nlist = 4;

    // more than 2 threads to surface
    // problems related to multi-threading
    omp_set_num_threads(8);

    // random database, also used as queries
    std::vector<float> database(nb * d);
    std::mt19937 rng;
    std::uniform_real_distribution<> distrib;
    for (size_t i = 0; i < nb * d; i++) {
        database[i] = distrib(rng);
    }

    // build index
    faiss::IndexFlatL2 coarse_quantizer(d);
    faiss::IndexIVFPQFastScan index(
        &coarse_quantizer, d, nlist, d / 2, 4, faiss::METRIC_L2, 32);
    index.pq.cp.niter = 10; // speed up train
    index.nprobe = nlist;
    index.train(nb, database.data());
    index.add(nb, database.data());

    std::vector<float> distances(nb);
    std::vector<faiss::idx_t> labels(nb);
    auto t = std::chrono::high_resolution_clock::now();
    int k = 1;
    index.nprobe = k;
    index.search(nb, database.data(), k, distances.data(), labels.data());
    auto knn_time = std::chrono::high_resolution_clock::now() - t;

    int n_ok = 0;
    for (int q = 0; q < nb; q++) {
        for (int i = 0; i < k; i++)
            if (database[q * k + i] == distances[q])
                n_ok++;
    }
    //EXPECT_GT(n_ok, nb * 0.4);
    //faiss::RangeSearchResult rsr(nb);
    //t = std::chrono::high_resolution_clock::now();
    //index.range_search(nb, database.data(), 1.0, &rsr);
    //auto range_time = std::chrono::high_resolution_clock::now() - t;

    //// we expect the perf of knn and range search
    //// to be similar, at least within a factor of 4
    //ASSERT_LE(range_time, knn_time * 4);
    //ASSERT_LE(knn_time, range_time * 4);
}

/*
void testGPU() {
    int d = 64;      // dimension
    int nb = 100000; // database size
    int nq = 10000;  // nb of queries

    std::mt19937 rng;
    std::uniform_real_distribution<> distrib;

    float* xb = new float[d * nb];
    float* xq = new float[d * nq];

    for (int i = 0; i < nb; i++) {
        for (int j = 0; j < d; j++)
            xb[d * i + j] = distrib(rng);
        xb[d * i] += i / 1000.;
    }

    for (int i = 0; i < nq; i++) {
        for (int j = 0; j < d; j++)
            xq[d * i + j] = distrib(rng);
        xq[d * i] += i / 1000.;
    }

    faiss::gpu::StandardGpuResources res;

    // Using a flat index

    faiss::gpu::GpuIndexFlatL2 index_flat(&res, d);

    printf("is_trained = %s\n", index_flat.is_trained ? "true" : "false");
    index_flat.add(nb, xb); // add vectors to the index
    printf("ntotal = %ld\n", index_flat.ntotal);

    int k = 4;

    { // search xq
        long* I = new long[k * nq];
        float* D = new float[k * nq];

        index_flat.search(nq, xq, k, D, I);

        // print results
        printf("I (5 first results)=\n");
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < k; j++)
                printf("%5ld ", I[i * k + j]);
            printf("\n");
        }

        printf("I (5 last results)=\n");
        for (int i = nq - 5; i < nq; i++) {
            for (int j = 0; j < k; j++)
                printf("%5ld ", I[i * k + j]);
            printf("\n");
        }

        delete[] I;
        delete[] D;
    }

    // Using an IVF index

    int nlist = 100;
    faiss::gpu::GpuIndexIVFFlat index_ivf(&res, d, nlist, faiss::METRIC_L2);

    assert(!index_ivf.is_trained);
    index_ivf.train(nb, xb);
    assert(index_ivf.is_trained);
    index_ivf.add(nb, xb); // add vectors to the index

    printf("is_trained = %s\n", index_ivf.is_trained ? "true" : "false");
    printf("ntotal = %ld\n", index_ivf.ntotal);

    { // search xq
        long* I = new long[k * nq];
        float* D = new float[k * nq];

        index_ivf.search(nq, xq, k, D, I);

        // print results
        printf("I (5 first results)=\n");
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < k; j++)
                printf("%5ld ", I[i * k + j]);
            printf("\n");
        }

        printf("I (5 last results)=\n");
        for (int i = nq - 5; i < nq; i++) {
            for (int j = 0; j < k; j++)
                printf("%5ld ", I[i * k + j]);
            printf("\n");
        }

        delete[] I;
        delete[] D;
    }

    delete[] xb;
    delete[] xq;
}
*/

void test() {
    testCmpltAndBlendInplace();
    testCmpltMinMaxFloat();
    testSearch();
    //testGPU():
}