Reorganise the project

haversine_02/src/generator/gen_argparser.cpp

@@ -0,0 +1,66 @@
+#include "generator/gen_argparser.h"
+#include "aliases.h"
+#include <argp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+INTERNAL error_t argp_parser(i32 key, char *arg, argp_state *state);
+
+INTERNAL argp parser = {};
+
+INTERNAL argp_option options[] = {
+    {.name = "seed", .key = 's', .arg = "SEED"},
+    {.name = "cluster", .key = 'c'},
+    {0, 0, 0, 0, 0, 0},
+};
+
+GeneratorArgs parse_args(i32 argc, char *argv[]) {
+  GeneratorArgs args = {};
+
+  parser.options = options;
+  parser.parser = argp_parser;
+  parser.args_doc = "COUNT";
+
+  argp_parse(&parser, argc, argv, 0, 0, &args);
+
+  if (args.seed == 0) {
+    args.seed = time(NULL);
+  }
+
+  return args;
+}
+
+error_t argp_parser(i32 key, char *arg, argp_state *state) {
+  GeneratorArgs *args = (GeneratorArgs *)state->input;
+
+  switch (key) {
+  case 's':
+    args->seed = strtoul(arg, NULL, 10);
+
+    break;
+  case 'c':
+    args->clustered = true;
+
+    break;
+  case ARGP_KEY_ARG:
+    if (state->arg_num >= 1) {
+      argp_usage(state);
+    }
+
+    args->count = strtoull(arg, NULL, 10);
+
+    break;
+  case ARGP_KEY_END:
+    if (state->arg_num < 1) {
+      argp_usage(state);
+    }
+
+    break;
+  default:
+    return ARGP_ERR_UNKNOWN;
+  }
+
+  return 0;
+}

haversine_02/src/generator/generator.cpp

@@ -0,0 +1,115 @@
+#include "generator/generator.h"
+#include "aliases.h"
+#include "point_types.h"
+#include <math.h>
+#include <stdlib.h>
+
+#define X_MIN -180.0
+#define X_MAX 180.0
+#define Y_MIN -90.0
+#define Y_MAX 90.0
+
+f64 generate_random_double(f64 min, f64 max);
+Point generate_random_point(f64 x_min, f64 x_max, f64 y_min, f64 y_max);
+PointPair generate_random_pair(f64 x_min, f64 x_max, f64 y_min, f64 y_max);
+
+void fill_pairs_array(PairArray *pairs, bool clustered) {
+  if (clustered) {
+    u64 digit_count = (u64)log10(pairs->count) + 1;
+
+    u64 cluster_count = 0;
+
+    if (digit_count > 2) {
+      cluster_count = digit_count * 8;
+    } else {
+      cluster_count = digit_count;
+    }
+
+    Point clusters[cluster_count];
+    f64 radii[cluster_count];
+
+    u64 pairs_per_cluster = pairs->count / cluster_count;
+    u64 generated_pairs = 0;
+    u64 pairs_to_generate = 0;
+
+    for (u64 i = 0; i < cluster_count; ++i) {
+      clusters[i] = {
+          generate_random_double(X_MIN, X_MAX),
+          generate_random_double(Y_MIN, Y_MAX),
+      };
+
+      radii[i] = generate_random_double(0.0, (digit_count - 1) * 40.0);
+
+      f64 cluster_x_min = clusters[i].x - radii[i];
+      if (cluster_x_min < X_MIN) {
+        cluster_x_min = X_MIN;
+      }
+
+      f64 cluster_x_max = clusters[i].x + radii[i];
+      if (cluster_x_max > X_MAX) {
+        cluster_x_max = X_MAX;
+      }
+
+      f64 cluster_y_min = clusters[i].y - radii[i];
+      if (cluster_y_min < Y_MIN) {
+        cluster_y_min = Y_MIN;
+      }
+
+      f64 cluster_y_max = clusters[i].y + radii[i];
+      if (cluster_y_max > Y_MAX) {
+        cluster_y_max = Y_MAX;
+      }
+
+      pairs_to_generate = 0;
+
+      if (generated_pairs + pairs_per_cluster < pairs->count) {
+        pairs_to_generate = pairs_per_cluster;
+      } else {
+        pairs_to_generate = pairs->count - generated_pairs;
+      }
+
+      for (u64 i = 0; i < pairs_to_generate; ++i) {
+        // clang-format off
+        pairs->pairs[generated_pairs + i] = generate_random_pair(
+					cluster_x_min,
+					cluster_x_max,
+					cluster_y_min,
+					cluster_y_max
+				);
+        // clang-format on
+      }
+
+      generated_pairs += pairs_to_generate;
+    }
+  } else {
+    for (u64 i = 0; i < pairs->count; ++i) {
+      pairs->pairs[i] = generate_random_pair(X_MIN, X_MAX, Y_MIN, Y_MAX);
+    }
+  }
+}
+
+f64 generate_random_double(f64 min, f64 max) {
+  u32 num = rand();
+
+  f64 result = min + (((f64)num / (f64)RAND_MAX) * (max - min));
+
+  return result;
+}
+
+Point generate_random_point(f64 x_min, f64 x_max, f64 y_min, f64 y_max) {
+  Point p = {
+      generate_random_double(x_min, x_max),
+      generate_random_double(y_min, y_max),
+  };
+
+  return p;
+}
+
+PointPair generate_random_pair(f64 x_min, f64 x_max, f64 y_min, f64 y_max) {
+  PointPair pair = {
+      generate_random_point(x_min, x_max, y_min, y_max),
+      generate_random_point(x_min, x_max, y_min, y_max),
+  };
+
+  return pair;
+}

haversine_02/src/generator/main.cpp

@@ -0,0 +1,44 @@
+#include "aliases.h"
+#include "generator/gen_argparser.h"
+#include "generator/generator.h"
+#include "haversine.h"
+#include "point_types.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#define EARTH_RADIUS_KM 6371.0
+
+i32 main(i32 argc, char *argv[]) {
+  GeneratorArgs args = parse_args(argc, argv);
+
+  srand(args.seed);
+
+  PairArray arr = {args.count, NULL};
+  arr.pairs = (PointPair *)malloc(arr.count * sizeof(PointPair));
+
+  fill_pairs_array(&arr, args.clustered);
+
+  write_pairs_to_json(arr, "pairs.json");
+
+  FILE *fp = fopen("count_and_distances", "w");
+
+  if (fp) {
+    fwrite(&(arr.count), sizeof(arr.count), 1, fp);
+
+    i64 sum = 0;
+    for (u64 i = 0; i < arr.count; ++i) {
+      f64 distance = haversine_of_degrees(arr.pairs[i], EARTH_RADIUS_KM);
+
+      fwrite(&distance, sizeof(f64), 1, fp);
+
+      sum += distance;
+    }
+    printf("%ld\n", sum / arr.count);
+
+    fclose(fp);
+  }
+
+  free(arr.pairs);
+
+  return 0;
+}