wehub-resource-sync
191 lines
6.3 KiB
C++
191 lines
6.3 KiB
C++
// Copyright 2025-present the zvec project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include <random>
|
|
#include <ailego/container/vector_array.h>
|
|
#include <gtest/gtest.h>
|
|
#include <zvec/ailego/utility/time_helper.h>
|
|
|
|
using namespace zvec;
|
|
|
|
TEST(NumericalVectorArray, General) {
|
|
ailego::NumericalVectorArray<float> arr;
|
|
ailego::NumericalVectorArray<float> &const_arr = arr;
|
|
EXPECT_TRUE(arr.empty());
|
|
EXPECT_EQ(0u, arr.dimension());
|
|
EXPECT_EQ(0u, arr.count());
|
|
EXPECT_EQ(0u, arr.bytes());
|
|
EXPECT_NE(nullptr, arr.data());
|
|
EXPECT_NE(nullptr, const_arr.data());
|
|
arr.shrink_to_fit();
|
|
arr.clear();
|
|
EXPECT_EQ(0u, arr.dimension());
|
|
EXPECT_EQ(0u, arr.count());
|
|
|
|
try {
|
|
arr.at(0);
|
|
} catch (const std::out_of_range &oor) {
|
|
std::cerr << "Out of Range error: " << oor.what() << '\n';
|
|
}
|
|
try {
|
|
const_arr.at(0);
|
|
} catch (const std::out_of_range &oor) {
|
|
std::cerr << "Out of Range error: " << oor.what() << '\n';
|
|
}
|
|
|
|
ailego::NumericalVector<float> vec1 = {10.0f, 11.0f, 12.0f, 13.0f, 14.0f,
|
|
15.0f, 16.0f, 17.0f, 18.0f, 19.0f};
|
|
ailego::NumericalVector<float> vec2 = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f,
|
|
6.0f, 7.0f, 8.0f, 9.0f, 0.0f};
|
|
arr.reset(10);
|
|
arr.append(vec1);
|
|
arr.append(vec2);
|
|
arr.append(vec1);
|
|
EXPECT_EQ(3u, arr.count());
|
|
EXPECT_EQ(10u, arr.dimension());
|
|
|
|
arr.reserve(10);
|
|
EXPECT_EQ(vec1, std::string(reinterpret_cast<const char *>(arr.at(0)),
|
|
arr.dimension() * sizeof(float)));
|
|
EXPECT_EQ(vec1, std::string(reinterpret_cast<const char *>(arr[2]),
|
|
arr.dimension() * sizeof(float)));
|
|
arr.replace(2, vec2);
|
|
EXPECT_EQ(vec2, std::string(reinterpret_cast<const char *>(const_arr.at(1)),
|
|
arr.dimension() * sizeof(float)));
|
|
EXPECT_EQ(vec2, std::string(reinterpret_cast<const char *>(const_arr[2]),
|
|
arr.dimension() * sizeof(float)));
|
|
|
|
arr.clear();
|
|
EXPECT_EQ(10u, arr.dimension());
|
|
EXPECT_EQ(0u, arr.count());
|
|
|
|
arr.reset(2);
|
|
arr.append(vec1.data(), 2, 5);
|
|
arr.append(vec2.data(), 2, 5);
|
|
EXPECT_EQ(2u, arr.dimension());
|
|
EXPECT_EQ(10u, arr.count());
|
|
|
|
ailego::NumericalVectorArray<float> arr1 = std::move(arr);
|
|
EXPECT_TRUE(arr.empty());
|
|
EXPECT_EQ(2u, arr.dimension());
|
|
EXPECT_EQ(0u, arr.count());
|
|
EXPECT_EQ(2u, arr1.dimension());
|
|
EXPECT_EQ(10u, arr1.count());
|
|
|
|
arr1.resize(8u);
|
|
EXPECT_EQ(8u, arr1.count());
|
|
|
|
arr1.resize(15u);
|
|
EXPECT_EQ(15u, arr1.count());
|
|
}
|
|
|
|
TEST(NumericalVectorArray, Batch) {
|
|
const size_t DIMENSION = 20;
|
|
const size_t COUNT = 20000u;
|
|
|
|
ailego::NumericalVectorArray<float> arr(DIMENSION);
|
|
std::random_device rd;
|
|
std::mt19937 gen(rd());
|
|
std::uniform_real_distribution<float> dist(0.0, 1.0);
|
|
std::string buffer;
|
|
|
|
for (size_t i = 0; i < COUNT; ++i) {
|
|
ailego::FixedVector<float, DIMENSION> vec;
|
|
for (size_t j = 0; j < DIMENSION; ++j) {
|
|
vec[j] = dist(gen);
|
|
}
|
|
arr.append(vec.data(), vec.size());
|
|
buffer.append((const char *)vec.data(), sizeof(vec));
|
|
}
|
|
EXPECT_EQ(COUNT, arr.count());
|
|
EXPECT_EQ(buffer, std::string((const char *)arr.data(), arr.bytes()));
|
|
}
|
|
|
|
TEST(BinaryVectorArray, General) {
|
|
ailego::BinaryVectorArray<uint64_t> arr64;
|
|
ailego::BinaryVectorArray<uint64_t> &const_arr64 = arr64;
|
|
EXPECT_TRUE(arr64.empty());
|
|
EXPECT_EQ(0u, arr64.dimension());
|
|
EXPECT_EQ(0u, arr64.count());
|
|
EXPECT_EQ(0u, arr64.bytes());
|
|
EXPECT_NE(nullptr, arr64.data());
|
|
EXPECT_NE(nullptr, const_arr64.data());
|
|
arr64.shrink_to_fit();
|
|
arr64.clear();
|
|
EXPECT_EQ(0u, arr64.dimension());
|
|
EXPECT_EQ(0u, arr64.count());
|
|
|
|
try {
|
|
arr64.at(0);
|
|
} catch (const std::out_of_range &oor) {
|
|
std::cerr << "Out of Range error: " << oor.what() << '\n';
|
|
}
|
|
try {
|
|
const_arr64.at(0);
|
|
} catch (const std::out_of_range &oor) {
|
|
std::cerr << "Out of Range error: " << oor.what() << '\n';
|
|
}
|
|
|
|
ailego::BinaryVector<uint64_t> vec1 = {true, false, true, true, false,
|
|
true, false, false, true, false};
|
|
ailego::BinaryVector<uint64_t> vec2 = {true, true, true, true,
|
|
false, false, false, true,
|
|
false, false, true, false};
|
|
EXPECT_EQ(64u, vec1.dimension());
|
|
EXPECT_EQ(64u, vec2.dimension());
|
|
arr64.reset(10);
|
|
arr64.append(vec1);
|
|
arr64.append(vec2);
|
|
arr64.append(vec1);
|
|
EXPECT_EQ(3u, arr64.count());
|
|
EXPECT_EQ(64u, arr64.dimension());
|
|
EXPECT_EQ(0u, arr64.bytes() % sizeof(uint64_t));
|
|
|
|
arr64.reserve(10);
|
|
EXPECT_EQ(vec1, std::string(reinterpret_cast<const char *>(arr64.at(0)),
|
|
arr64.dimension() >> 3));
|
|
EXPECT_EQ(vec1, std::string(reinterpret_cast<const char *>(arr64[2]),
|
|
arr64.dimension() >> 3));
|
|
arr64.replace(2, vec2);
|
|
EXPECT_EQ(vec2, std::string(reinterpret_cast<const char *>(const_arr64.at(1)),
|
|
arr64.dimension() >> 3));
|
|
EXPECT_EQ(vec2, std::string(reinterpret_cast<const char *>(const_arr64[2]),
|
|
arr64.dimension() >> 3));
|
|
|
|
arr64.clear();
|
|
EXPECT_EQ(64u, arr64.dimension());
|
|
EXPECT_EQ(0u, arr64.count());
|
|
|
|
ailego::BinaryVectorArray<uint32_t> arr32(1);
|
|
EXPECT_EQ(32u, arr32.dimension());
|
|
arr32.append((const uint32_t *)vec1.data(), 32, 2);
|
|
arr32.append((const uint32_t *)vec2.data(), 32, 2);
|
|
EXPECT_EQ(32u, arr32.dimension());
|
|
EXPECT_EQ(4u, arr32.count());
|
|
EXPECT_EQ(0u, arr64.bytes() % sizeof(uint32_t));
|
|
|
|
ailego::BinaryVectorArray<uint32_t> arr1 = std::move(arr32);
|
|
EXPECT_TRUE(arr32.empty());
|
|
EXPECT_EQ(32u, arr32.dimension());
|
|
EXPECT_EQ(0u, arr32.count());
|
|
EXPECT_EQ(32u, arr1.dimension());
|
|
EXPECT_EQ(4u, arr1.count());
|
|
|
|
arr1.resize(8u);
|
|
EXPECT_EQ(8u, arr1.count());
|
|
|
|
arr1.resize(1u);
|
|
EXPECT_EQ(1u, arr1.count());
|
|
}
|