minor stylistic change

Author: jermp

include/builders/external_memory_builder_partitioned_phf.hpp

@@ -30,7 +30,7 @@ struct external_memory_builder_partitioned_phf {
         build_timings timings;
         if (config.verbose) {
             std::cout << "num_partitions " << num_partitions << std::endl;
-            std::cout << "using " << static_cast<double>(config.ram) / 1000000000 << " GB of RAM"
+            std::cout << "using " << static_cast<double>(config.ram) / 1'000'000'000 << " GB of RAM"
                       << std::endl;
         }
 

include/builders/external_memory_builder_single_phf.hpp

@@ -66,12 +66,12 @@ struct external_memory_builder_single_phf {
         if (bitmap_taken_bytes + hashed_pilots_cache_bytes >= ram) {
             std::stringstream ss;
             ss << "not enough RAM available, the bitmap alone takes "
-               << static_cast<double>(bitmap_taken_bytes) / 1000000000 << " GB of space.";
+               << static_cast<double>(bitmap_taken_bytes) / 1'000'000'000 << " GB of space.";
             throw std::runtime_error(ss.str());
         }
 
         if (config.verbose) {
-            constexpr uint64_t GB = 1000000000;
+            constexpr uint64_t GB = 1'000'000'000;
             uint64_t peak = num_keys * (sizeof(bucket_payload_pair) + sizeof(uint64_t)) +
                             (num_keys + num_buckets) * sizeof(uint64_t);
             std::cout << "lambda (avg. bucket size) = " << config.lambda << std::endl;
@@ -100,7 +100,7 @@ struct external_memory_builder_single_phf {
                 auto stop = clock_type::now();
                 if (config.verbose) {
                     std::cout << " == map+sort " << tfm.get_num_pairs_files()
-                              << " files(s) took: " << to_microseconds(stop - start) / 1000000
+                              << " files(s) took: " << to_microseconds(stop - start) / 1'000'000
                               << " seconds" << std::endl;
                 }
                 start = clock_type::now();
@@ -112,8 +112,9 @@ struct external_memory_builder_single_phf {
                 tfm.remove_all_pairs_files();
                 stop = clock_type::now();
                 if (config.verbose) {
-                    std::cout << " == merge+check took: " << to_microseconds(stop - start) / 1000000
-                              << " seconds" << std::endl;
+                    std::cout << " == merge+check took: "
+                              << to_microseconds(stop - start) / 1'000'000 << " seconds"
+                              << std::endl;
                     std::cout << " == max bucket size = " << int(tfm.max_bucket_size())
                               << std::endl;
                 }

include/builders/internal_memory_builder_single_phf.hpp

@@ -90,14 +90,15 @@ struct internal_memory_builder_single_phf {
             map(hashes, num_keys, pairs_blocks, config);
             auto elapsed = to_microseconds(clock_type::now() - start);
             if (config.verbose) {
-                std::cout << " == map+sort took: " << elapsed / 1000000 << " seconds" << std::endl;
+                std::cout << " == map+sort took: " << elapsed / 1'000'000 << " seconds"
+                          << std::endl;
             }
 
             start = clock_type::now();
             merge(pairs_blocks, buckets, config.verbose);
             elapsed = to_microseconds(clock_type::now() - start);
             if (config.verbose) {
-                std::cout << " == merge+check took: " << elapsed / 1000000 << " seconds"
+                std::cout << " == merge+check took: " << elapsed / 1'000'000 << " seconds"
                           << std::endl;
             }
         }
@@ -106,7 +107,7 @@ struct internal_memory_builder_single_phf {
         time.mapping_ordering_microseconds = to_microseconds(clock_type::now() - start);
         if (config.verbose) {
             std::cout << " == mapping+ordering took "
-                      << time.mapping_ordering_microseconds / 1000000 << " seconds " << std::endl;
+                      << time.mapping_ordering_microseconds / 1'000'000 << " seconds " << std::endl;
             buckets.print_bucket_size_distribution();
         }
 
@@ -129,7 +130,7 @@ struct internal_memory_builder_single_phf {
         }
         time.searching_microseconds = to_microseconds(clock_type::now() - start);
         if (config.verbose) {
-            std::cout << " == search took " << time.searching_microseconds / 1000000 << " seconds"
+            std::cout << " == search took " << time.searching_microseconds / 1'000'000 << " seconds"
                       << std::endl;
         }
 

src/build.cpp

@@ -465,7 +465,7 @@ int main(int argc, char** argv) {
     /* Optional arguments. */
     constexpr bool OPTIONAL = !REQUIRED;
     parser.add("alpha",
-               "The table load factor. It must be a quantity > 0 and <= 1 (Defaults is " +
+               "The table load factor. It must be a quantity > 0 and <= 1 (Default is " +
                    std::to_string(constants::default_alpha) + ").",
                "-a", OPTIONAL);
     parser.add("avg_partition_size", "Average partition size for HEM.", "-p", OPTIONAL);

src/example.cpp

@@ -7,7 +7,7 @@ int main() {
     using namespace pthash;
 
     /* Generate 1M random 64-bit keys as input data. */
-    static const uint64_t num_keys = 1000000;
+    static const uint64_t num_keys = 1'000'000;
     static const uint64_t seed = 1234567890;
     std::cout << "generating input data..." << std::endl;
     auto keys = distinct_uints<uint64_t>(num_keys, seed);
@@ -21,7 +21,7 @@ int main() {
     config.lambda = 5;
     config.alpha = 0.97;
     config.verbose = true;
-    config.avg_partition_size = 100000;
+    config.avg_partition_size = 100'000;
     config.num_threads = 4;
     config.dense_partitioning = true;
 
@@ -54,9 +54,9 @@ int main() {
     double total_microseconds = timings.partitioning_microseconds +
                                 timings.mapping_ordering_microseconds +
                                 timings.searching_microseconds + timings.encoding_microseconds;
-    std::cout << "function built in " << to_microseconds(clock_type::now() - start) / 1000000
+    std::cout << "function built in " << to_microseconds(clock_type::now() - start) / 1'000'000
               << " seconds" << std::endl;
-    std::cout << "computed: " << total_microseconds / 1000000 << " seconds" << std::endl;
+    std::cout << "computed: " << total_microseconds / 1'000'000 << " seconds" << std::endl;
 
     /* Compute and print the number of bits spent per key. */
     double bits_per_key = static_cast<double>(f.num_bits()) / f.num_keys();

test/test_internal_memory_dense_partitioned_mphf.cpp

@@ -52,7 +52,7 @@ void test_internal_memory_dense_partitioned_mphf(Iterator keys, uint64_t num_key
 }
 
 int main() {
-    static const uint64_t universe = 100000;
+    static const uint64_t universe = 100'000;
     for (int i = 0; i != 5; ++i) {
         uint64_t num_keys = constants::table_size_per_partition + (random_value() % universe);
         std::vector<uint64_t> keys = distinct_uints<uint64_t>(num_keys, random_value());

test/test_internal_memory_partitioned_mphf.cpp

@@ -24,7 +24,7 @@ void test_internal_memory_partitioned_mphf(Iterator keys, uint64_t num_keys) {
     config.verbose = false;
     config.seed = random_value();
 
-    std::vector<uint64_t> avg_partition_size{1000, 10000, 100000, 1000000};
+    std::vector<uint64_t> avg_partition_size{1'000, 10'000, 100'000, 1'000'000};
     std::vector<double> L{4.0, 4.5, 5.0, 5.5, 6.0};
     std::vector<double> A{1.0, 0.99, 0.98, 0.97, 0.96};
     for (auto lambda : L) {

test/test_internal_memory_single_mphf.cpp

@@ -55,7 +55,7 @@ void test_internal_memory_single_mphf(Iterator keys, uint64_t num_keys) {
 }
 
 int main() {
-    static const uint64_t universe = 100000;
+    static const uint64_t universe = 100'000;
     for (int i = 0; i != 5; ++i) {
         uint64_t num_keys = random_value() % universe;
         if (num_keys == 0) num_keys = 1;