special case finite numbers

Author: Craig Macomber

b+tree.d.ts

@@ -31,10 +31,6 @@ export declare function compareFiniteNumbers(a: number, b: number): number;
  * Compares strings lexically to form a strict partial ordering.
  */
 export declare function compareStrings(a: string, b: string): number;
-/**
- * If a and b are arrays, they are compared using '<' and '>', which may cause unexpected equality, for example [1] will be considered equal to ['1'].
- */
-export declare function compareFiniteNumbersOrStringOrArray(a: number | string | (number | string)[], b: number | string | (number | string)[]): number;
 /**
  * A reasonably fast collection of key-value pairs with a powerful API.
  * Largely compatible with the standard Map. BTree is a B+ tree data structure,

b+tree.js

@@ -13,7 +13,7 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyBTree = exports.compareFiniteNumbersOrStringOrArray = exports.compareStrings = exports.compareFiniteNumbers = exports.defaultComparator = void 0;
+exports.EmptyBTree = exports.compareStrings = exports.compareFiniteNumbers = exports.defaultComparator = void 0;
 /**
  * Compares DefaultComparables to form a strict partial ordering.
  *
@@ -24,9 +24,17 @@ exports.EmptyBTree = exports.compareFiniteNumbersOrStringOrArray = exports.compa
  * Two objects with equal valueOf compare the same, but compare unequal to primitives that have the same value.
  */
 function defaultComparator(a, b) {
-    // Compare types first.
+    // Special case finite numbers first for performance.
     // Note that the trick of using 'a - b' the checking for NaN to detect non numbers values does not work if the strings are numeric (ex: "5"),
     // leading most comparison functions using that approach to fail to have transitivity.
+    if (Number.isFinite(a) && Number.isFinite(b)) {
+        // Does not partially order NaNs or infinite values, but thats fine since they can't reach here.
+        // This will handle -0 and 0 as equal.
+        return a - b;
+    }
+    // Compare types and order values of different types by type.
+    // This prevents implicit conversion of strings to numbers from causing invaliding ordering,
+    // and generally simplifies which cases need to be considered below.
     var ta = typeof a;
     var tb = typeof b;
     if (ta !== tb) {
@@ -82,21 +90,6 @@ function compareStrings(a, b) {
 }
 exports.compareStrings = compareStrings;
 ;
-/**
- * If a and b are arrays, they are compared using '<' and '>', which may cause unexpected equality, for example [1] will be considered equal to ['1'].
- */
-function compareFiniteNumbersOrStringOrArray(a, b) {
-    // Strings can not be ordered relative to numbers using '<' and '>' since no matter the order, the comparison will return false.
-    var ta = typeof a;
-    var tb = typeof b;
-    if (ta !== tb) {
-        return ta < tb ? -1 : 1;
-    }
-    // Use < and > instead of < and === so arrays work correctly.
-    return a > b ? 1 : a < b ? -1 : 0;
-}
-exports.compareFiniteNumbersOrStringOrArray = compareFiniteNumbersOrStringOrArray;
-;
 /**
  * A reasonably fast collection of key-value pairs with a powerful API.
  * Largely compatible with the standard Map. BTree is a B+ tree data structure,

b+tree.test.ts

@@ -1,4 +1,4 @@
-import BTree, {IMap, EmptyBTree, defaultComparator, compareFiniteNumbers, compareFiniteNumbersOrStringOrArray, compareStrings} from './b+tree';
+import BTree, {IMap, EmptyBTree, defaultComparator, compareFiniteNumbers, compareStrings} from './b+tree';
 import SortedArray from './sorted-array';
 import MersenneTwister from 'mersenne-twister';
 
@@ -71,31 +71,6 @@ describe('compareStrings', () =>
   testComparison(compareStrings, [], values, []);
 });
 
-describe('compareFiniteNumbersOrStringOrArray', () =>
-{
-  const values = [
-    '24x',
-    '0',
-    '1',
-    '3',
-    'String',
-    '10',
-    0,
-    "NaN",
-    -0,
-    1,
-    10,
-    2,
-    [],
-    '[]',
-    [1],
-    ['1']
-  ];
-  const sorted = [-10, -1, -0, 0, 1, 2, 10];
-  testComparison(compareFiniteNumbersOrStringOrArray, sorted, values, [[0, -0], [[1], ['1']]]);
-});
-
-
 /**
  * Tests a comparison function, ensuring it produces a strict partial order over the provided values.
  * Additionally confirms that the comparison function has the correct definition of equality via expectedDuplicates.

b+tree.ts

@@ -45,9 +45,18 @@ export type DefaultComparable = number | string | (number | string)[] | { valueO
  * Two objects with equal valueOf compare the same, but compare unequal to primitives that have the same value.
  */
 export function defaultComparator(a: DefaultComparable, b: DefaultComparable): number {
-  // Compare types first.
+  // Special case finite numbers first for performance.
   // Note that the trick of using 'a - b' the checking for NaN to detect non numbers values does not work if the strings are numeric (ex: "5"),
   // leading most comparison functions using that approach to fail to have transitivity.
+  if (Number.isFinite(a) && Number.isFinite(b)) {
+    // Does not partially order NaNs or infinite values, but thats fine since they can't reach here.
+    // This will handle -0 and 0 as equal.
+    return a as number - (b as number);
+  }
+
+  // Compare types and order values of different types by type.
+  // This prevents implicit conversion of strings to numbers from causing invaliding ordering,
+  // and generally simplifies which cases need to be considered below.
   let ta = typeof a;
   let tb = typeof b;
   if (ta !== tb) {
@@ -86,7 +95,6 @@ export function defaultComparator(a: DefaultComparable, b: DefaultComparable): n
   return 0;
 };
 
-
 /**
  * Compares finite numbers to form a strict partial ordering.
  * 
@@ -103,20 +111,6 @@ export function compareStrings(a: string, b:string): number {
   return a > b ? 1 : a === b ? 0 : -1;
 };
 
-/**
- * If a and b are arrays, they are compared using '<' and '>', which may cause unexpected equality, for example [1] will be considered equal to ['1'].
- */
-export function compareFiniteNumbersOrStringOrArray(a: number | string | (number| string)[], b: number | string | (number| string)[]): number {
-  // Strings can not be ordered relative to numbers using '<' and '>' since no matter the order, the comparison will return false.
-  let ta = typeof a;
-  let tb = typeof b;
-  if (ta !== tb) {
-    return ta < tb ? -1 : 1;
-  }
-  // Use < and > instead of < and === so arrays work correctly.
-  return a > b ? 1 : a < b ? -1 : 0;
-};
-
 /**
  * A reasonably fast collection of key-value pairs with a powerful API. 
  * Largely compatible with the standard Map. BTree is a B+ tree data structure,