refactor: rename select→getByRank, rank→getRank

Consistent naming: getRank/getByRank/rangeByRank — all centered on 'Rank'.
- select() → getByRank(): element at k-th position in tree order
- rank() → getRank(): number of elements preceding key in tree order
- _selectIterative/_selectRecursive → _getByRankIterative/_getByRankRecursive
- _rankIterative/_rankRecursive → _getRankIterative/_getRankRecursive
- All JSDoc, tests, README, guides, RFC updated

Author: zrwusa

README.md

@@ -289,11 +289,11 @@ const tree = new RedBlackTree<number, string>([
 ], { comparator: (a, b) => b - a, enableOrderStatistic: true });
 
 // select(k) — find k-th element, O(log n)
-tree.select(0);              // 100 (1st in tree order)
-tree.select(2);              // 92  (3rd in tree order)
+tree.getByRank(0);              // 100 (1st in tree order)
+tree.getByRank(2);              // 92  (3rd in tree order)
 
 // rank(key) — count elements preceding key in tree order, O(log n)
-tree.rank(92);               // 2 (2 elements before 92 in tree order)
+tree.getRank(92);               // 2 (2 elements before 92 in tree order)
 
 // rangeByRank — pagination, O(log n + k)
 tree.rangeByRank(0, 2);      // [100, 95, 92] — top 3

docs-site-docusaurus/docs/guide/concepts.md

@@ -342,12 +342,12 @@ scores.sort((a, b) => a - b);
 const median = scores[Math.floor(scores.length / 2)]; // re-sort on every update
 ```
 
-✅ Order-statistic tree: O(log n) select/rank with live updates:
+✅ Order-statistic tree: O(log n) getByRank/getRank with live updates:
 
 ```javascript
 const tree = new RedBlackTree(scores, { enableOrderStatistic: true });
-const median = tree.select(Math.floor(tree.size / 2)); // O(log n)
-const rank = tree.rank(92); // "how many scores below 92?" — O(log n)
+const median = tree.getByRank(Math.floor(tree.size / 2)); // O(log n)
+const rank = tree.getRank(92); // "how many scores below 92?" — O(log n)
 const top3 = tree.rangeByRank(tree.size - 3, tree.size - 1); // O(log n + 3)
 ```
 

docs-site-docusaurus/docs/guide/guides.md

@@ -230,7 +230,7 @@ interface Player {
 }
 
 class Leaderboard {
-  // enableOrderStatistic gives O(log n) select/rank/rangeByRank
+  // enableOrderStatistic gives O(log n) getByRank/getRank/rangeByRank
   private scores = new RedBlackTree<number, Player>(
     [],
     { comparator: (a, b) => b - a, enableOrderStatistic: true }
@@ -255,19 +255,19 @@ class Leaderboard {
   // O(log n) — direct rank lookup
   getRank(playerId: string): number {
     if (!this.players.has(playerId)) return -1;
-    return this.scores.rank(this.players.get(playerId)!) + 1; // 1-based
+    return this.scores.getRank(this.players.get(playerId)!) + 1; // 1-based
   }
 
   // O(log n + k) — get k-th player by rank
   getPlayerAt(rank: number): Player | undefined {
-    const key = this.scores.select(rank - 1); // 0-indexed internally
+    const key = this.scores.getByRank(rank - 1); // 0-indexed internally
     return key !== undefined ? this.scores.get(key) : undefined;
   }
 
   // O(log n + k) — players around a given player
   getAroundMe(playerId: string, range: number): Player[] {
     if (!this.players.has(playerId)) return [];
-    const myRank = this.scores.rank(this.players.get(playerId)!);
+    const myRank = this.scores.getRank(this.players.get(playerId)!);
     const start = Math.max(0, myRank - range);
     const end = Math.min(this.scores.size - 1, myRank + range);
     return this.scores.rangeByRank(start, end)

docs-site-docusaurus/docs/guide/overview.md

@@ -149,8 +149,8 @@ rbTree.print()
 
 // Order-Statistic mode — O(log n) rank queries
 const ost = new RedBlackTree<number, string>([[1, 'A'], [2, 'B'], [3, 'C']], { enableOrderStatistic: true });
-ost.select(0);         // 1 (smallest key)
-ost.rank(2);           // 1 (one element before key 2)
+ost.getByRank(0);         // 1 (smallest key)
+ost.getRank(2);           // 1 (one element before key 2)
 ost.rangeByRank(0, 1); // [1, 2] (first two elements)
 ```
 

docs-site-docusaurus/docs/guide/quick-start.md

@@ -47,18 +47,18 @@ const tree = new RedBlackTree<number, string>([
 ], { comparator: (a, b) => b - a, enableOrderStatistic: true });
 
 // select(k) — find k-th element (0-indexed)
-console.log(tree.select(0));  // 100 (1st in tree order)
-console.log(tree.select(2));  // 92  (3rd in tree order)
+console.log(tree.getByRank(0));  // 100 (1st in tree order)
+console.log(tree.getByRank(2));  // 92  (3rd in tree order)
 
 // rank(key) — how many elements before this key?
-console.log(tree.rank(92));   // 2 (2 elements before 92 in tree order)
+console.log(tree.getRank(92));   // 2 (2 elements before 92 in tree order)
 
 // rangeByRank(start, end) — pagination
 console.log(tree.rangeByRank(0, 2)); // [100, 95, 92] — top 3
 
-// Inverse property: select(rank(key)) === key
-const k = tree.rank(85);
-console.log(tree.select(k));  // 85
+// Inverse property: getByRank(getRank(key)) === key
+const k = tree.getRank(85);
+console.log(tree.getByRank(k));  // 85
 ```
 
 ## Task Queue (Scheduling)

docs/GUIDES.md

@@ -225,7 +225,7 @@ interface Player {
 }
 
 class Leaderboard {
-  // enableOrderStatistic gives O(log n) select/rank/rangeByRank
+  // enableOrderStatistic gives O(log n) getByRank/getRank/rangeByRank
   private scores = new RedBlackTree<number, Player>(
     [],
     { comparator: (a, b) => b - a, enableOrderStatistic: true }
@@ -250,19 +250,19 @@ class Leaderboard {
   // O(log n) — direct rank lookup
   getRank(playerId: string): number {
     if (!this.players.has(playerId)) return -1;
-    return this.scores.rank(this.players.get(playerId)!) + 1; // 1-based
+    return this.scores.getRank(this.players.get(playerId)!) + 1; // 1-based
   }
 
   // O(log n) — get k-th player by rank
   getPlayerAt(rank: number): Player | undefined {
-    const key = this.scores.select(rank - 1); // 0-indexed internally
+    const key = this.scores.getByRank(rank - 1); // 0-indexed internally
     return key !== undefined ? this.scores.get(key) : undefined;
   }
 
   // O(log n + k) — players around a given player
   getAroundMe(playerId: string, range: number): Player[] {
     if (!this.players.has(playerId)) return [];
-    const myRank = this.scores.rank(this.players.get(playerId)!);
+    const myRank = this.scores.getRank(this.players.get(playerId)!);
     const start = Math.max(0, myRank - range);
     const end = Math.min(this.scores.size - 1, myRank + range);
     return this.scores.rangeByRank(start, end)

docs/rfcs/order-statistic-tree.md

@@ -36,7 +36,7 @@ enableOrderStatistic?: boolean; // default: false
 
 When `false` (default):
 - `_count` is NOT maintained (no overhead)
-- `select()`, `rank()`, `rangeByRank()` throw `Error('Order statistic is not enabled')`
+- `getByRank()`, `getRank()`, `rangeByRank()` throw `Error('Order statistic is not enabled')`
 
 When `true`:
 - `_count` is maintained on every insert, delete, and rotation
@@ -47,7 +47,7 @@ When `true`:
 The option propagates through the inheritance chain:
 ```ts
 const map = new TreeMap<string, number>([], { enableOrderStatistic: true });
-map.select(0); // ✅ works
+map.getByRank(0); // ✅ works
 ```
 
 ## API Design
@@ -93,29 +93,29 @@ const tree = new RedBlackTree<number>(
   { enableOrderStatistic: true }
 );
 
-tree.select(0);  // 20 (smallest)
-tree.select(3);  // 50 (median)
-tree.select(6);  // 80 (largest)
-tree.select(7);  // undefined (out of bounds)
-tree.select(-1); // undefined
+tree.getByRank(0);  // 20 (smallest)
+tree.getByRank(3);  // 50 (median)
+tree.getByRank(6);  // 80 (largest)
+tree.getByRank(7);  // undefined (out of bounds)
+tree.getByRank(-1); // undefined
 
 // With callback — get node
-tree.select(3, node => node);  // BSTNode { key: 50 }
+tree.getByRank(3, node => node);  // BSTNode { key: 50 }
 
 // With callback — get entry
-tree.select(3, node => [node.key, node.value]);  // [50, undefined]
+tree.getByRank(3, node => [node.key, node.value]);  // [50, undefined]
 
 // TreeMap
 const map = new TreeMap<string, number>(
   [['alice', 95], ['bob', 87], ['charlie', 92]],
   { enableOrderStatistic: true }
 );
-map.select(0);  // 'alice' (keys sorted alphabetically)
-map.select(2);  // 'charlie'
+map.getByRank(0);  // 'alice' (keys sorted alphabetically)
+map.getByRank(2);  // 'charlie'
 
 // TreeSet
 const set = new TreeSet<number>([10, 20, 30], { enableOrderStatistic: true });
-set.select(1);  // 20
+set.getByRank(1);  // 20
 ```
 
 ### rank(key) — Get the rank of a key
@@ -172,23 +172,23 @@ const tree = new RedBlackTree<number>(
   { enableOrderStatistic: true }
 );
 
-tree.rank(10);  // 0 (smallest, 0 elements less than it)
-tree.rank(30);  // 2 (20 and 10 are less)
-tree.rank(50);  // 4
-tree.rank(25);  // 2 (would be inserted at position 2)
-tree.rank(5);   // 0 (would be inserted at position 0)
-tree.rank(100); // 5 (would be inserted at end)
+tree.getRank(10);  // 0 (smallest, 0 elements less than it)
+tree.getRank(30);  // 2 (20 and 10 are less)
+tree.getRank(50);  // 4
+tree.getRank(25);  // 2 (would be inserted at position 2)
+tree.getRank(5);   // 0 (would be inserted at position 0)
+tree.getRank(100); // 5 (would be inserted at end)
 
 // Inverse relationship
-tree.select(tree.rank(30)); // 30
-tree.rank(tree.select(2)!); // 2
+tree.getByRank(tree.getRank(30)); // 30
+tree.getRank(tree.getByRank(2)!); // 2
 
 // TreeMap
 const map = new TreeMap<string, number>(
   [['alice', 95], ['bob', 87], ['charlie', 92]],
   { enableOrderStatistic: true }
 );
-map.rank('bob'); // 1
+map.getRank('bob'); // 1
 ```
 
 ### rangeByRank(start, end) — Get elements by rank range
@@ -312,8 +312,8 @@ rangeByRank(start: number, end: number): (K | undefined)[] {
 ```
 
 Each call site provides a sensible fallback value after `raise()`:
-- `select` → `undefined`
-- `rank` → `-1`
+- `getByRank` → `undefined`
+- `getRank` → `-1`
 - `rangeByRank` → `[]`
 
 In `throw` mode (default), the fallback is never reached. In other modes, the function degrades gracefully.
@@ -324,12 +324,12 @@ New code uses `raise()`. Existing `throw` statements are gradually migrated —
 
 ## IterationType Support
 
-Both `select` and `rank` walk a single root-to-leaf path, similar to `ceiling`/`floor`.
+Both `getByRank` and `getRank` walk a single root-to-leaf path, similar to `ceiling`/`floor`.
 
 - **ITERATIVE** (default): while loop, O(1) space
 - **RECURSIVE**: function calls, O(log n) stack space
 
-`rangeByRank` uses `select` + in-order traversal, both support IterationType.
+`rangeByRank` uses `getByRank` + in-order traversal, both support IterationType.
 
 ## Edge Cases
 
@@ -374,7 +374,7 @@ In TreeMultiMap, a single node can represent multiple entries.
    - With callback
 
 4. **Inverse relationship**
-   - `select(rank(key)) === key` for all keys
+   - `getByRank(getRank(key)) === key` for all keys
    - `rank(select(k)) === k` for all valid k
 
 5. **Count maintenance**
@@ -390,14 +390,14 @@ In TreeMultiMap, a single node can represent multiple entries.
    - TreeMultiSet: duplicate handling
 
 7. **enableOrderStatistic: false**
-   - select/rank/rangeByRank all throw
+   - getByRank/getRank/rangeByRank all throw
    - No count maintenance overhead (count stays 1)
 
 8. **IterationType**
    - All methods produce same results with RECURSIVE and ITERATIVE
 
 9. **Stress test**
-   - Insert 10K random elements, verify select/rank consistency
+   - Insert 10K random elements, verify getByRank/getRank consistency
    - Random insert/delete sequence, verify count integrity after each operation
 
 ## Implementation Order
@@ -408,8 +408,8 @@ In TreeMultiMap, a single node can represent multiple entries.
 4. Wire count updates into BST insert/delete
 5. Wire count updates into AVL rotations
 6. Wire count updates into RBT rotations + fixup
-7. Implement `select`
-8. Implement `rank`
+7. Implement `getByRank`
+8. Implement `getRank`
 9. Implement `rangeByRank`
 10. Verify all tests pass
 11. Run performance benchmark (before/after with enableOrderStatistic: false)