Add test code

Author: gjbex

source_code/intersection_trees/intersection_tree.py

@@ -226,10 +226,31 @@ def create_queries(size: int = 1_000, max_end: int = 1_000_000) -> Queries:
 
 
 def populate_db(db: Node | None, intervals: typing.Sequence[Interval]) -> Node:
+    '''Populate an existing database with additional intervals or create a new one.
+
+    Parameters
+    ----------
+    db: Node | None
+        existing database to populate, if None a new database is created
+    intervals: typing.Sequence[Interval]
+        intervals to insert into the database
+
+    Returns
+    -------
+    Node
+        root of the populated intersection tree
+
+    Raises
+    ------
+    ValueError
+        if intervals is empty
+    '''
     if len(intervals) == 0:
         raise ValueError('At least 1 interval is required')
+    start_idx = 0
     if db is None:
-        db = Node(intervals.pop(0))
-    for interval in intervals:
+        db = Node(intervals[0])
+        start_idx = 1
+    for interval in intervals[start_idx:]:
         db.insert(interval)
-    return db
+    return db

source_code/intersection_trees/intersection_trees.ipynb

@@ -459,7 +459,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 2,
    "id": "efe82236-da69-4654-8f26-23f2a5da6419",
    "metadata": {},
    "outputs": [],
@@ -803,7 +803,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 3,
    "id": "153b9a8d-c90a-43ad-bb9b-8bd03b062397",
    "metadata": {},
    "outputs": [],
@@ -999,6 +999,59 @@
    "source": [
     "It is clear that the intersection tree implementation is more efficient than the naive approaches.  The expected time complexity is $\\bigO(N \\log N)$ for $|Q| = |D| = N$.  Likely, the actual time complexity will be worse since the vinary tree is unlikely to be balanced."
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eff509fe-8612-4ccf-bd91-d6fb7535f551",
+   "metadata": {},
+   "source": [
+    "## Testing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d763a5d-3bc2-47d0-831d-585521e20b63",
+   "metadata": {},
+   "source": [
+    "Since the naive appreach is pretty straightforward, and the intersection tree is a bit more sophisticated, it might be wise to compare the results by way of test."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "88c24d03-83ef-4f3e-9332-846cba39b52c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import intersection_tree\n",
+    "import naive_intersectionic_queries\n",
+    "\n",
+    "random.seed(1234)\n",
+    "max_end = 1_000_000\n",
+    "nr_intervals = 1_000\n",
+    "nr_queries = 1_000\n",
+    "db_intervals = [\n",
+    "    intersection_tree.generate_interval(max_end=max_end) for _ in range(nr_intervals)\n",
+    "]\n",
+    "queries = intersection_tree.create_queries(size=nr_queries, max_end=max_end)\n",
+    "\n",
+    "db = intersection_tree.populate_db(None, db_intervals)\n",
+    "db_results = intersection_tree.execute_queries(queries, db)\n",
+    "\n",
+    "naive_db = db_intervals\n",
+    "naive_db_result = naive_intersectionic_queries.execute_queries(queries, naive_db)\n",
+    "\n",
+    "assert len(db_results) == len(naive_db_result)\n",
+    "assert set(db_results) == set(naive_db_result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb4b24f3-f503-4ecf-9c10-0c371b3119b2",
+   "metadata": {},
+   "source": [
+    "Both algorithms yield identical results."
+   ]
   }
  ],
  "metadata": {