Improve the benchmark data generator

Author: Kontinuation

benchmarks/test_bench_base.py

@@ -33,7 +33,7 @@ def setup_class(self):
                 {
                     "geom_type": "LineString",
                     "target_rows": num_geoms,
-                    "vertices_per_linestring_range": [2, 2],
+                    "vertices_per_linestring_range": [2, 10],
                 },
             ),
             (
@@ -70,33 +70,41 @@ def setup_class(self):
             ),
         ]:
             # Generate synthetic data with two different geometry sets that have overlapping spatial distribution
-            # This creates more realistic workloads for spatial predicates
-            
+            # The intersection rate between geom1 and geom2 will be around 2%.
+            # This creates more realistic workloads for spatial predicates.
+
             # Options for first geometry set (geom1) - left-leaning distribution
             options1 = base_options.copy()
-            options1.update({
-                "seed": 42,
-                "bounds": [0.0, 0.0, 80.0, 100.0],  # Slightly left-leaning
-                "size_range": [1.0, 15.0]  # Medium-sized geometries for good intersection chance
-            })
-            
-            # Options for second geometry set (geom2) - right-leaning distribution  
+            options1.update(
+                {
+                    "seed": 42,
+                    "bounds": [0.0, 0.0, 80.0, 100.0],  # Slightly left-leaning
+                    "size_range": [
+                        1.0,
+                        15.0,
+                    ],  # Medium-sized geometries for good intersection chance
+                }
+            )
+
+            # Options for second geometry set (geom2) - right-leaning distribution
             options2 = base_options.copy()
-            options2.update({
-                "seed": 1337,
-                "bounds": [20.0, 0.0, 100.0, 100.0],  # Slightly right-leaning
-                "size_range": [1.0, 15.0]  # Same size range for fair comparison
-            })
-            
+            options2.update(
+                {
+                    "seed": 43,
+                    "bounds": [20.0, 0.0, 100.0, 100.0],  # Slightly right-leaning
+                    "size_range": [1.0, 15.0],  # Same size range for fair comparison
+                }
+            )
+
             query = f"""
                 WITH geom1_data AS (
-                    SELECT 
+                    SELECT
                         geometry as geom1,
                         row_number() OVER () as id
                     FROM sd_random_geometry('{json.dumps(options1)}')
                 ),
                 geom2_data AS (
-                    SELECT 
+                    SELECT
                         geometry as geom2,
                         row_number() OVER () as id
                     FROM sd_random_geometry('{json.dumps(options2)}')
@@ -111,7 +119,7 @@ def setup_class(self):
             tab = self.sedonadb.execute_and_collect(query)
 
             self.sedonadb.create_table_arrow(name, tab)
-            # self.postgis.create_table_arrow(name, tab)
+            self.postgis.create_table_arrow(name, tab)
             self.duckdb.create_table_arrow(name, tab)
 
     def _get_eng(self, eng):

python/sedonadb/tests/functions/test_distance.py

@@ -43,4 +43,5 @@ def test_st_distance(eng, geom1, geom2, expected):
     eng.assert_query_result(
         f"SELECT ST_Distance({geom_or_null(geom1)}, {geom_or_null(geom2)})",
         expected,
+        numeric_epsilon=1e-8,
     )

rust/sedona-testing/src/datagen.rs

@@ -566,7 +566,8 @@ fn generate_random_linestring<R: rand::Rng>(
         );
         // Always sample in such a way that we end up with a valid linestring
         let num_vertices = rng.sample(vertices_dist).max(2);
-        let coords = generate_circular_vertices(center_x, center_y, half_size, num_vertices, false);
+        let coords =
+            generate_circular_vertices(rng, center_x, center_y, half_size, num_vertices, false);
         LineString::from(coords)
     }
 }
@@ -582,7 +583,8 @@ fn generate_random_polygon<R: rand::Rng>(rng: &mut R, options: &RandomGeometryOp
         );
         // Always sample in such a way that we end up with a valid Polygon
         let num_vertices = rng.sample(vertices_dist).max(3);
-        let coords = generate_circular_vertices(center_x, center_y, half_size, num_vertices, true);
+        let coords =
+            generate_circular_vertices(rng, center_x, center_y, half_size, num_vertices, true);
         let shell = LineString::from(coords);
         let mut holes = Vec::new();
 
@@ -593,7 +595,7 @@ fn generate_random_polygon<R: rand::Rng>(rng: &mut R, options: &RandomGeometryOp
         if add_hole {
             let new_size = half_size * hole_scale_factor;
             let mut coords =
-                generate_circular_vertices(center_x, center_y, new_size, num_vertices, true);
+                generate_circular_vertices(rng, center_x, center_y, new_size, num_vertices, true);
             coords.reverse();
             holes.push(LineString::from(coords));
         }
@@ -756,15 +758,20 @@ fn generate_non_overlapping_sub_rectangles(num_parts: usize, bounds: &Rect) -> V
     tiles
 }
 
-fn generate_circular_vertices(
+fn generate_circular_vertices<R: rand::Rng>(
+    rng: &mut R,
     center_x: f64,
     center_y: f64,
     radius: f64,
     num_vertices: usize,
     closed: bool,
 ) -> Vec<Coord> {
     let mut out = Vec::new();
-    let mut angle: f64 = 0.0;
+
+    // Randomize starting angle (0 to 2 * PI)
+    let start_angle_dist = Uniform::new(0.0, 2.0 * PI);
+    let mut angle: f64 = rng.sample(start_angle_dist);
+
     let dangle = 2.0 * PI / (num_vertices as f64).max(3.0);
     for _ in 0..num_vertices {
         out.push(Coord {