데이터 유형 추가.

WETSort/WETSort.cpp

 std::string sha1(const void* p, size_t s);
 
 const size_t testLength[] = {
-	1ULL << 21,
-	1ULL << 27,
+	1ULL << 24,
+	1ULL << 29,
 #ifndef _DEBUG
 	1ULL << 31,
 	1ULL << 33
 	std::string hash;
 };
 
+enum GenerateDataTypes
+{
+	GenUniform32,
+	GenUniform16,
+	GenUniform16Xor,
+	GenUniform8,
+	GenUniform8Xor,
+	GenNormal64,
+	GenNormal32,
+};
+
 #pragma pack(push, 1)
 template <size_t s>
 struct Element
 	int8_t buffer[s];
 	bool operator < (const Element& other) const
 	{
-		const int8_t* p0 = buffer;
-		const int8_t* p1 = other.buffer;
 		for (size_t i = 0; i < s; ++i)
 		{
-			int n = p0[0] - p1[0];
+			int n = int(buffer[i]) - int(other.buffer[i]);
 			if (n)
 				return n > 0;
-			p0++;
-			p1++;
 		}
 		return false;
 	}
 	}
 }
 
-void RunTest(size_t size)
+void RunTest(size_t size, GenerateDataTypes type)
 {
 	std::random_device rdev;
 	std::default_random_engine re(rdev());
-	std::uniform_int_distribution<unsigned short> dist(0, 0xff);
 
 	if (1)
 	{
 	// generate random number.
 	data0.clear();
 	data0.resize(size);
-	int16_t tmp = 0;
-	printf("Generating random data... (%zu bytes)\n", size);
-	for (size_t i = 0, e = size / sizeof(int32_t); i < e; ++i)
+
+	switch (type)
 	{
-		int16_t x = dist(re);
-		int16_t y = (i ^ (tmp << 4)) & 0xff;
-		tmp = y;
-		reinterpret_cast<int16_t*>(data0.data())[i] = (x << 16) | y;
+	case GenUniform32:
+		if (1)
+		{
+			printf("Generating random data... (%zu bytes, type: Uniform32)\n", size);
+			std::uniform_int_distribution<uint32_t> dist(0, 0xffffffff);
+			for (size_t i = 0, e = size / sizeof(uint32_t); i < e; ++i)
+			{
+				reinterpret_cast<uint32_t*>(data0.data())[i] = dist(re);
+			}
+		}
+		break;
+	case GenUniform16: 
+		if (1)
+		{
+			printf("Generating random data... (%zu bytes, type: Uniform16)\n", size);
+			std::uniform_int_distribution<uint16_t> dist(0, 0xffff);
+			for (size_t i = 0, e = size / sizeof(uint32_t); i < e; ++i)
+			{
+				reinterpret_cast<uint32_t*>(data0.data())[i] = dist(re);
+			}
+		}
+		break;
+	case GenUniform16Xor: 
+		if (1)
+		{
+			printf("Generating random data... (%zu bytes, type: Uniform16Xor)\n", size);
+			std::uniform_int_distribution<uint16_t> dist(0, 0xffff);
+			uint32_t tmp = dist(re);
+			for (size_t i = 0, e = size / sizeof(uint32_t); i < e; ++i)
+			{
+				uint32_t x = dist(re);
+				uint32_t y = (i ^ (tmp << 3)) & 0xff;
+				tmp = y;
+				reinterpret_cast<uint32_t*>(data0.data())[i] = (x << 16) | y;
+			}
+		}
+		break;
+	case GenUniform8:
+		if (1)
+		{
+			printf("Generating random data... (%zu bytes, type: Uniform8)\n", size);
+			std::uniform_int_distribution<uint16_t> dist(0, 0xff);
+			for (size_t i = 0, e = size / sizeof(uint32_t); i < e; ++i)
+			{
+				reinterpret_cast<uint32_t*>(data0.data())[i] = dist(re);
+			}
+		}
+		break;
+	case GenUniform8Xor:
+		if (1)
+		{
+			printf("Generating random data... (%zu bytes, type: Uniform8Xor)\n", size);
+			std::uniform_int_distribution<uint16_t> dist(0, 0xff);
+			uint32_t tmp = dist(re);
+			for (size_t i = 0, e = size / sizeof(uint32_t); i < e; ++i)
+			{
+				uint32_t val = dist(re);
+				val = val ^ (tmp << 1);
+				tmp = val;
+				reinterpret_cast<uint32_t*>(data0.data())[i] = val;
+			}
+		}
+		break;
+	case GenNormal64:
+		if (1)
+		{
+			printf("Generating random data... (%zu bytes, type: Normal64)\n", size);
+			std::normal_distribution<double> dist;
+			for (size_t i = 0, e = size / sizeof(double); i < e; ++i)
+			{
+				reinterpret_cast<double*>(data0.data())[i] = dist(re);
+			}
+		}
+		break;
+	case GenNormal32:
+		if (1)
+		{
+			printf("Generating random data... (%zu bytes, type: Normal32)\n", size);
+			std::normal_distribution<float> dist;
+			for (size_t i = 0, e = size / sizeof(float); i < e; ++i)
+			{
+				reinterpret_cast<float*>(data0.data())[i] = dist(re);
+			}
+		}
+		break;
 	}
 
+	// 1 byte
+	DoSortTest<1>();
+	// 2 byte
+	DoSortTest<2>();
 	// 3 bytes
 	DoSortTest<3>();
 	// 4 bytes
 	DoSortTest<4>();
 	// 5 bytes
 	DoSortTest<5>();
+	// 6
+	DoSortTest<6>();
+	// 7
+	DoSortTest<7>();
 	// 9 bytes
 	DoSortTest<9>();
-	// 16 bytes
-	DoSortTest<16>();
+	// 10
+	DoSortTest<10>();
+	// 11
+	DoSortTest<11>();
+	// 12
+	DoSortTest<12>();
+	// 13
+	DoSortTest<13>();
+	// 15
+	DoSortTest<15>();
 	// 17 bytes
 	DoSortTest<17>();
-	// 64
-	DoSortTest<64>();
-	// 97 bytes
-	DoSortTest<97>();
-	// 128
-	DoSortTest<128>();
-	// 512
-	DoSortTest<512>();
-	// 1024
-	DoSortTest<1024>();
-	// 4096
-	DoSortTest<4096>();
+	//// 32 bytes
+	//DoSortTest<32>();
+	//// 33 bytes
+	//DoSortTest<33>();
 }
 
 int main()
 {
-	// Set .error to 'true' to run the test!
-	testScore[arkiny].error = true;
-	testScore[ccm9026].error = true;
-	testScore[djarksnd].error = true;
-	testScore[insun].error = true;
-	testScore[prauser].error = true;
-	testScore[witdrg].error = true;
+	// Set .error to '0' to run the test!
+	testScore[arkiny].error   = 1;
+	testScore[ccm9026].error  = 1;
+	testScore[djarksnd].error = 1;
+	testScore[insun].error    = 1;
+	testScore[prauser].error  = 1;
+	testScore[witdrg].error   = 1;
 
 	auto PrintScore = [](int phase)
 	{
 			else
 			{
 				uint32_t s = (score.sum / double(score.num)) * 100.0;
-				printf("UID(%s) score: %d.\n", uidString[i], s);
+				const char* t = "";
+				if (s > 100)
+					t = "(PERFECT)";
+				else if (s > 90)
+					t = "(GOOD)";
+				else if (s < 60)
+					t = "(POOR)";
+				printf("UID(%s) score: %d. %s\n", uidString[i], s, t);
 			}
 		}
 		printf("-----------------------------------------\n\n");
 	for (size_t n : testLength)
 	{
 		printf("========= Phase %d / %d (%zu) ==========\n", index, int(std::size(testLength)), n);
-		RunTest(n);
+		for (auto t : {
+				GenUniform32,
+				GenUniform16,
+				GenUniform16Xor,
+				GenUniform8,
+				GenUniform8Xor,
+				GenNormal64,
+				GenNormal32
+			 })
+		{
+			RunTest(n, t);
+		}
+		//RunTest(n, GenNormal64);
 		PrintScore(index);
 		index++;
 	}