Updating to convert to snake_case.

Author: RealTimeChris

GenerateGraphs.py

@@ -13,16 +13,16 @@ def parse_args():
 
 def get_raw_speeds(df):
     raw_speeds = {"Read": [], "Write": []}
-    libraries = df["libraryName"].unique()
+    libraries = df["library_name"].unique()
 
     for result_type in raw_speeds.keys():
-        result_type_df = df[df["resultType"] == result_type].sort_values(by="resultSpeed")
+        result_type_df = df[df["result_type"] == result_type].sort_values(by="result_speed")
 
         if result_type_df.empty:
             raw_speeds[result_type] = [0] * len(libraries)
             continue
 
-        speed_map = dict(zip(result_type_df["libraryName"], result_type_df["resultSpeed"]))
+        speed_map = dict(zip(result_type_df["library_name"], result_type_df["result_speed"]))
 
         raw_speeds[result_type] = [
             speed_map.get(library, 0) for library in libraries
@@ -32,24 +32,24 @@ def get_raw_speeds(df):
 
 def calculate_cumulative_speedup(df):
     cumulative_speedups = {"Read": [], "Write": []}
-    libraries = df["libraryName"].unique()
+    libraries = df["library_name"].unique()
 
     for result_type in cumulative_speedups.keys():
-        result_type_df = df[df["resultType"] == result_type].sort_values(by="resultSpeed")
+        result_type_df = df[df["result_type"] == result_type].sort_values(by="result_speed")
 
         if result_type_df.empty:
             cumulative_speedups[result_type] = [0] * len(libraries)
             continue
 
-        slowest_speed = result_type_df.iloc[0]["resultSpeed"]
+        slowest_speed = result_type_df.iloc[0]["result_speed"]
         result_type_speedups = [100]
 
         for i in range(1, len(result_type_df)):
-            current_speed = result_type_df.iloc[i]["resultSpeed"]
+            current_speed = result_type_df.iloc[i]["result_speed"]
             speedup = ((current_speed / slowest_speed) - 1) * 100 + 100
             result_type_speedups.append(speedup)
 
-        speedup_map = dict(zip(result_type_df["libraryName"], result_type_speedups))
+        speedup_map = dict(zip(result_type_df["library_name"], result_type_speedups))
         cumulative_speedups[result_type] = [
             speedup_map.get(library, 0) for library in libraries
         ]
@@ -85,21 +85,21 @@ def plot_speed_results(
     plt.gcf().set_facecolor("#0d1117")
     ax = plt.gca()
 
-    has_read_results = "Read" in df["resultType"].unique()
-    has_write_results = "Write" in df["resultType"].unique()
+    has_read_results = "Read" in df["result_type"].unique()
+    has_write_results = "Write" in df["result_type"].unique()
 
     if has_read_results:
-        sort_df = df[df["resultType"] == "Read"].sort_values(by="resultSpeed", ascending=False)
+        sort_df = df[df["result_type"] == "Read"].sort_values(by="result_speed", ascending=False)
     elif has_write_results:
-        sort_df = df[df["resultType"] == "Write"].sort_values(by="resultSpeed", ascending=False)
+        sort_df = df[df["result_type"] == "Write"].sort_values(by="result_speed", ascending=False)
     else:
         print("No read or write results found in the DataFrame.")
         return
 
-    sorted_libraries = sort_df["libraryName"].tolist()
+    sorted_libraries = sort_df["library_name"].tolist()
 
     library_colors = {
-        (row['libraryName'], row['resultType']): row['color']
+        (row['library_name'], row['result_type']): row['color']
         for _, row in df.iterrows()
     }
 
@@ -169,11 +169,11 @@ def main():
 
         cumulative_speedups = calculate_cumulative_speedup(df)
 
-        plot_speed_results(df, raw_speed, output_folder, test["testName"], is_cumulative = False, y_label = "Result Speed (MB/s)")
+        plot_speed_results(df, raw_speed, output_folder, test["test_name"], is_cumulative = False, y_label = "Result Speed (MB/s)")
 
-        plot_speed_results(df, cumulative_speedups, output_folder, test["testName"], is_cumulative = True, y_label = "Cumulative Speedup (%)", label_metric="%")
+        plot_speed_results(df, cumulative_speedups, output_folder, test["test_name"], is_cumulative = True, y_label = "Cumulative Speedup (%)", label_metric="%")
 
-        print(f'Graphs saved successfully for {test["testName"]}!')
+        print(f'Graphs saved successfully for {test["test_name"]}!')
 
 if __name__ == "__main__":
     main()

Source-2/canada.hpp Source/canada.hppSource-2/canada.hpp renamed to Source/canada.hpp

@@ -184,13 +184,155 @@ template<typename value_type> struct partial_test {
 	std::vector<value_type> m, s;
 };
 
+BNCH_SWT_HOST std::string generate_integer_part(uint64_t min_length = 1, uint64_t max_length = 15) {
+	uint64_t length = bnch_swt::random_generator<uint64_t>::impl(min_length, max_length);
+
+	if (length == 1 && bnch_swt::random_generator<uint64_t>::impl(0, 1) == 0 && bnch_swt::random_generator<uint64_t>::impl(0, 9) == 0)
+		return "0";
+
+	std::string s;
+	s += std::to_string(bnch_swt::random_generator<uint64_t>::impl(1, 9));
+
+	for (uint64_t i = 1; i < length; ++i) {
+		s += std::to_string(bnch_swt::random_generator<uint64_t>::impl(0, 9));
+	}
+	return s;
+}
+
+BNCH_SWT_HOST std::string maybe_add_sign(const std::string& s) {
+	return (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 1) ? ("-" + s) : s;
+}
+
+BNCH_SWT_HOST std::string generate_1_simple_integer() {
+	return maybe_add_sign(generate_integer_part(1, 10));
+}
+
+BNCH_SWT_HOST std::string generate_2_simple_float() {
+	std::string s = generate_integer_part(1, 5);
+	s += ".";
+
+	uint64_t fractional_length = bnch_swt::random_generator<uint64_t>::impl(1, 10);
+	for (uint64_t i = 0; i < fractional_length; ++i) {
+		s += std::to_string(bnch_swt::random_generator<uint64_t>::impl(0, 9));
+	}
+	return maybe_add_sign(s);
+}
+
+BNCH_SWT_HOST std::string generate_3_scientific() {
+	std::string s;
+
+	if (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 0) {
+		s = generate_integer_part(1, 3) + ".";
+		s += std::to_string(bnch_swt::random_generator<uint64_t>::impl(0, 9));
+	} else {
+		s = generate_integer_part(1, 5);
+	}
+
+	s += (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 0 ? 'e' : 'E');
+	s += (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 0 ? '+' : '-');
+	uint64_t exponent = bnch_swt::random_generator<uint64_t>::impl(1, 100);
+	s += std::to_string(exponent);
+
+	return maybe_add_sign(s);
+}
+
+BNCH_SWT_HOST std::string generate_4_min_max_boundary() {
+	if (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 0) {
+		double mantissa	  = bnch_swt::random_generator<double>::impl(1.0, 9.9);
+		uint64_t exponent = bnch_swt::random_generator<uint64_t>::impl(300, 308);
+		double val		  = mantissa * std::pow(10.0, exponent);
+		if (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 1)
+			val = -val;
+
+		std::stringstream ss;
+		ss << std::scientific << std::setprecision(16) << val;
+		return ss.str();
+	} else {
+		double mantissa	  = bnch_swt::random_generator<double>::impl(1.0, 9.9);
+		uint64_t exponent = bnch_swt::random_generator<uint64_t>::impl(300, 308);
+		double val		  = mantissa * std::pow(10.0, static_cast<double>(-static_cast<int64_t>(exponent)));
+		if (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 1)
+			val = -val;
+
+		std::stringstream ss;
+		ss << std::scientific << std::setprecision(16) << val;
+		return ss.str();
+	}
+}
+
+BNCH_SWT_HOST std::string generate_5_precision_boundary() {
+	std::string s;
+	s += maybe_add_sign(std::to_string(bnch_swt::random_generator<uint64_t>::impl(1, 9)));
+	s += ".";
+
+	for (uint64_t i = 0; i < 18; ++i) {
+		s += std::to_string(bnch_swt::random_generator<uint64_t>::impl(0, 9));
+	}
+
+	if (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 0) {
+		s += 'e';
+		s += std::to_string(bnch_swt::random_generator<uint64_t>::impl(1, 100));
+	}
+	return s;
+}
+
+BNCH_SWT_HOST std::string generate_6_zero_subnormal() {
+	if (bnch_swt::random_generator<uint64_t>::impl(0, 1) == 0) {
+		static constexpr std::array zero_forms = { "0", "0.0", "-0.0", "0e0", "-0e5", "0.0e-10" };
+		uint64_t index						   = bnch_swt::random_generator<uint64_t>::impl(0, zero_forms.size() - 1);
+		return zero_forms[index];
+	} else {
+		double mantissa = bnch_swt::random_generator<double>::impl(1.0, 9.9);
+		double val		= mantissa * std::pow(10.0, -315);
+
+		std::stringstream ss;
+		ss << std::scientific << std::setprecision(16) << val;
+		return maybe_add_sign(ss.str());
+	}
+}
+
+BNCH_SWT_HOST std::string generate_7_structural_edge() {
+	static constexpr std::array edge_forms = { "1e10", "-9e-10", "0.1", "-9.0", "1.2e0", "-3e+0", "123.000000", "0.0000001" };
+	uint64_t index						   = bnch_swt::random_generator<uint64_t>::impl(0, edge_forms.size() - 1);
+	return edge_forms[index];
+}
+
+BNCH_SWT_HOST std::string generate_random_double_string() {
+	static constexpr std::array weights = { 40.0, 30.0, 10.0, 5.0, 5.0, 5.0, 5.0 };
+
+	static constexpr std::array generators = { generate_1_simple_integer, generate_2_simple_float, generate_3_scientific, generate_4_min_max_boundary,
+		generate_5_precision_boundary, generate_6_zero_subnormal, generate_7_structural_edge };
+
+	uint64_t roll = bnch_swt::random_generator<uint64_t>::impl(0, 99);
+
+	uint64_t cumulative_weight = 0;
+	for (size_t i = 0; i < weights.size(); ++i) {
+		cumulative_weight += static_cast<uint64_t>(weights[i]);
+		if (roll < cumulative_weight) {
+			return generators[i]();
+		}
+	}
+	return generators.back()();
+}
+
+BNCH_SWT_HOST double generate_random_double() {
+	double test_double;
+	do {
+		std::string test_string = generate_random_double_string();
+		auto new_ptr			= test_string.data() + test_string.size();
+		test_double= strtod(test_string.data(), &new_ptr);
+	} while (test_double == std::numeric_limits<double>::infinity() || test_double == std::numeric_limits<double>::quiet_NaN() ||
+		test_double == -std::numeric_limits<double>::infinity());
+	return test_double;
+}
+
 struct test_generator {
 	template<jsonifier::concepts::string_t value_type> static value_type generate_value() {
 		return bnch_swt::random_generator<std::string>::impl(bnch_swt::random_generator<uint64_t>::impl(16ull, 64ull));
 	}
 
 	template<jsonifier::concepts::float_t value_type> static value_type generate_value() {
-		return bnch_swt::random_generator<double>::impl();
+		return generate_random_double();
 	}
 
 	template<jsonifier::concepts::bool_t value_type> static value_type generate_value() {

Source-2/citm_catalog.hpp Source/citm_catalog.hppSource-2/citm_catalog.hpp renamed to Source/citm_catalog.hpp

@@ -22,9 +22,9 @@
 /// https://github.com/RealTimeChris/jsonifier
 #pragma once
 
-#include "Jsonifier.hpp"
-#include "Simdjson.hpp"
-#include "Glaze.hpp"
+#include "jsonifier.hpp"
+#include "simdjson.hpp"
+#include "glaze.hpp"
 
 namespace tests {