remove compare and groupCompare

src/model/BooleanColumn.ts

@@ -177,16 +177,10 @@ export default class BooleanColumn extends ValueColumn<boolean> implements ICate
     this.fire([BooleanColumn.EVENT_FILTER_CHANGED, Column.EVENT_DIRTY_VALUES, Column.EVENT_DIRTY], this.currentFilter, this.currentFilter = filter);
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    const av = this.getValue(a);
-    const bv = this.getValue(b);
-    return av === bv ? 0 : (av < bv ? -1 : +1);
-  }
-
   toCompareValue(row: IDataRow) {
     const v = this.getValue(row);
     if (v == null) {
-      return null;
+      return NaN;
     }
     return v ? 1 : -1;
   }

src/model/BooleansColumn.ts

@@ -1,7 +1,6 @@
 import ArrayColumn, {IArrayColumnDesc} from './ArrayColumn';
 import {ISetColumn, toCategory} from './ICategoricalColumn';
 import {IDataRow} from './interfaces';
-import {FIRST_IS_MISSING} from './missing';
 
 export declare type IBooleansColumnDesc = IArrayColumnDesc<boolean>;
 
@@ -20,26 +19,11 @@ export default class BooleansColumn extends ArrayColumn<boolean> implements ISet
     return new Set(this.categories.filter((_, i) => vs[i]));
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    const aVal = this.getValue(a);
-    const bVal = this.getValue(b);
-    if (aVal == null) {
-      return bVal == null ? 0 : FIRST_IS_MISSING;
-    }
-    if (bVal == null) {
-      return -FIRST_IS_MISSING;
-    }
-
-    const aCat = aVal.filter((x) => x).length;
-    const bCat = bVal.filter((x) => x).length;
-    return (aCat - bCat);
-  }
-
   toCompareValue(row: IDataRow) {
     const v = this.getValue(row);
     if (v == null) {
-      return null;
+      return NaN;
     }
-    return v.filter((x) => x).length;
+    return v.reduce((a, b) => a +(b ? 1 : 0), 0);
   }
 }

src/model/BoxPlotColumn.ts

@@ -81,11 +81,7 @@ export default class BoxPlotColumn extends ValueColumn<IBoxPlotData> implements
 
   }
 
-  compare(a: IDataRow, b: IDataRow): number {
-    return compareBoxPlot(this, a, b);
-  }
-
-  toCompareValue(row: IDataRow): number | null {
+  toCompareValue(row: IDataRow): number {
     return toCompareBoxPlotValue(this, row);
   }
 

src/model/CategoricalColumn.ts

@@ -1,10 +1,10 @@
 import {Category, toolbar} from './annotations';
-import Column, {widthChanged, labelChanged, metaDataChanged, dirty, dirtyHeader, dirtyValues, rendererTypeChanged, groupRendererChanged, summaryRendererChanged, visibilityChanged} from './Column';
+import Column, {widthChanged, labelChanged, metaDataChanged, dirty, dirtyHeader, dirtyValues, rendererTypeChanged, groupRendererChanged, summaryRendererChanged, visibilityChanged, ICompareValue} from './Column';
 import ValueColumn, {dataLoaded} from './ValueColumn';
 import {
-  compareCategory, toCompareCategoryValue, groupCompareCategory,
+  toCompareCategoryValue,
   ICategoricalColumn, ICategoricalColumnDesc, ICategoricalFilter, ICategory,
-  isEqualCategoricalFilter, isCategoryIncluded, toCategories, toCategory, COMPARE_CATEGORY_VALUE_TYPES,
+  isEqualCategoricalFilter, isCategoryIncluded, toCategories, toCategory, COMPARE_CATEGORY_VALUE_TYPES, toGroupCompareCategoryValue, COMPARE_GROUP_CATEGORY_VALUE_TYPES,
 } from './ICategoricalColumn';
 import {IDataRow, IGroup, IGroupData} from './interfaces';
 import {missingGroup} from './missing';
@@ -167,10 +167,6 @@ export default class CategoricalColumn extends ValueColumn<string> implements IC
     this.fire([CategoricalColumn.EVENT_FILTER_CHANGED, Column.EVENT_DIRTY_VALUES, Column.EVENT_DIRTY], this.currentFilter, this.currentFilter = filter);
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    return compareCategory(this.getCategory(a), this.getCategory(b));
-  }
-
   toCompareValue(row: IDataRow) {
     return toCompareCategoryValue(this.getCategory(row));
   }
@@ -187,8 +183,12 @@ export default class CategoricalColumn extends ValueColumn<string> implements IC
     return {name: cat.label, color: cat.color};
   }
 
-  groupCompare(a: IGroupData, b: IGroupData): number {
-    return groupCompareCategory(a.rows, b.rows, this);
+  toCompareGroupValue(g: IGroupData): ICompareValue[] {
+    return toGroupCompareCategoryValue(g.rows, this);
+  }
+
+  toCompareGroupValueType() {
+    return COMPARE_GROUP_CATEGORY_VALUE_TYPES;
   }
 
   getGroupRenderer() {

src/model/Column.ts

@@ -535,16 +535,6 @@ export default class Column extends AEventDispatcher {
     return isMissingValue(this.getValue(row));
   }
 
-  /**
-   * compare function used to determine the order according to the values of the current column
-   * @param _a first element
-   * @param _b second element
-   * @return {number}
-   */
-  compare(_a: IDataRow, _b: IDataRow) {
-    return 0; //can't compare
-  }
-
   toCompareValue(_row: IDataRow): ICompareValue | ICompareValue[] {
     return 0;
   }
@@ -562,20 +552,14 @@ export default class Column extends AEventDispatcher {
     return defaultGroup;
   }
 
-  /**
-   * compares groups
-   * @param {IGroupData} a
-   * @param {IGroupData} b
-   * @return {number}
-   */
-  groupCompare(a: IGroupData, b: IGroupData) {
-    return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
-  }
-
   toCompareGroupValue(group: IGroupData): ICompareValue | ICompareValue[] {
     return group.name.toLowerCase();
   }
 
+  toCompareGroupValueType(): ECompareValueType | ECompareValueType[] {
+    return ECompareValueType.STRING;
+  }
+
   /**
    * flag whether any filter is applied
    * @return {boolean}

src/model/CompositeNumberColumn.ts

@@ -108,22 +108,22 @@ export default class CompositeNumberColumn extends CompositeColumn implements IN
     return isMissingValue(this.compute(row));
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    return NumberColumn.prototype.compare.call(this, a, b);
-  }
-
   toCompareValue(row: IDataRow) {
     return NumberColumn.prototype.toCompareValue.call(this, row);
   }
 
-  groupCompare(a: IGroupData, b: IGroupData) {
-    return NumberColumn.prototype.groupCompare.call(this, a, b);
+  toCompareValueType() {
+    return NumberColumn.prototype.toCompareValueType.call(this);
   }
 
   toCompareGroupValue(group: IGroupData) {
     return NumberColumn.prototype.toCompareGroupValue.call(this, group);
   }
 
+  toCompareGroupValueType() {
+    return NumberColumn.prototype.toCompareGroupValueType.call(this);
+  }
+
   getRenderer(): string {
     return NumberColumn.prototype.getRenderer.call(this);
   }

src/model/DateColumn.ts

@@ -3,7 +3,7 @@ import {Category, toolbar, dialogAddons} from './annotations';
 import {IDataRow, IGroupData} from './interfaces';
 import {FIRST_IS_MISSING, isMissingValue, missingGroup, isUnknown} from './missing';
 import ValueColumn, {IValueColumnDesc, dataLoaded} from './ValueColumn';
-import {widthChanged, labelChanged, metaDataChanged, dirty, dirtyHeader, dirtyValues, rendererTypeChanged, groupRendererChanged, summaryRendererChanged, visibilityChanged} from './Column';
+import {widthChanged, labelChanged, metaDataChanged, dirty, dirtyHeader, dirtyValues, rendererTypeChanged, groupRendererChanged, summaryRendererChanged, visibilityChanged, ECompareValueType} from './Column';
 import {IEventListener} from '../internal/AEventDispatcher';
 import Column from './Column';
 import {IDateFilter, IDateDesc, noDateFilter, isDateIncluded, isDummyDateFilter, isEqualDateFilter, IDateGrouper, restoreDateFilter, IDateColumn, toDateGroup, isDefaultDateGrouper, defaultDateGrouper} from './IDateColumn';
@@ -145,25 +145,10 @@ export default class DateColumn extends ValueColumn<Date> implements IDateColumn
     return isDateIncluded(this.currentFilter, this.getDate(row));
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    const av = this.getDate(a);
-    const bv = this.getDate(b);
-    if (av === bv) {
-      return 0;
-    }
-    if (!(av instanceof Date)) {
-      return (bv instanceof Date) ? FIRST_IS_MISSING : 0;
-    }
-    if (!(bv instanceof Date)) {
-      return FIRST_IS_MISSING * -1;
-    }
-    return av.getTime() - bv.getTime();
-  }
-
   toCompareValue(row: IDataRow) {
     const v = this.getValue(row);
     if (!(v instanceof Date)) {
-      return null;
+      return NaN;
     }
     return v.getTime();
   }
@@ -196,10 +181,13 @@ export default class DateColumn extends ValueColumn<Date> implements IDateColumn
     };
   }
 
-  groupCompare(a: IGroupData, b: IGroupData): number {
-    const av = choose(a.rows, this.currentGrouper, this).value;
-    const bv = choose(b.rows, this.currentGrouper, this).value;
-    return numberCompare(av, bv, false, false);
+  toCompareGroupValue(g: IGroupData): number {
+    const v = choose(g.rows, this.currentGrouper, this).value;
+    return v == null ? NaN : v;
+  }
+
+  toCompareGroupValueType() {
+    return ECompareValueType.NUMBER;
   }
 }
 

src/model/DatesColumn.ts

@@ -137,23 +137,6 @@ export default class DatesColumn extends ArrayColumn<Date | null> implements IDa
     }
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    const av = <Date[]>this.getValue(a).filter(Boolean);
-    const bv = <Date[]>this.getValue(b).filter(Boolean);
-    if (av === bv) {
-      return 0;
-    }
-    if (av.length === 0) {
-      return bv.length === 0 ? 0 : FIRST_IS_MISSING;
-    }
-    if (bv.length === 0) {
-      return -FIRST_IS_MISSING;
-    }
-    const as = compute(av, this.sort);
-    const bs = compute(bv, this.sort);
-    return as - bs;
-  }
-
   toCompareValue(row: IDataRow) {
     const vs = <Date[]>this.getValue(row).filter(Boolean);
     if (!vs) {

src/model/GroupColumn.ts

@@ -1,5 +1,5 @@
 import {Category, SupportType, toolbar, dialogAddons} from './annotations';
-import Column, {widthChanged, labelChanged, metaDataChanged, dirty, dirtyHeader, dirtyValues, rendererTypeChanged, groupRendererChanged, summaryRendererChanged, visibilityChanged} from './Column';
+import Column, {widthChanged, labelChanged, metaDataChanged, dirty, dirtyHeader, dirtyValues, rendererTypeChanged, groupRendererChanged, summaryRendererChanged, visibilityChanged, ECompareValueType} from './Column';
 import {IGroupData} from './interfaces';
 import {FIRST_IS_NAN, missingGroup} from './missing';
 import {IEventListener} from '../internal/AEventDispatcher';
@@ -76,25 +76,14 @@ export default class GroupColumn extends Column {
     }
   }
 
-  groupCompare(a: IGroupData, b: IGroupData) {
-    switch (this.groupSortMethod) {
-      case 'count':
-        return a.rows.length - b.rows.length;
-      default:
-        if (a.name === missingGroup.name) {
-          return b.name === missingGroup.name ? 0 : FIRST_IS_NAN;
-        }
-        if (b.name === missingGroup.name) {
-          return -FIRST_IS_NAN;
-        }
-        return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
-    }
-  }
-
   toCompareGroupValue(group: IGroupData) {
     if (this.groupSortMethod === 'count') {
       return group.rows.length;
     }
     return group.name === missingGroup.name ? null : group.name.toLowerCase();
   }
+
+  toCompareGroupValueType() {
+    return this.groupSortMethod === 'count' ? ECompareValueType.NUMBER : ECompareValueType.STRING;
+  }
 }

src/model/HierarchyColumn.ts

@@ -202,10 +202,6 @@ export default class HierarchyColumn extends ValueColumn<string> implements ICat
     return CategoricalColumn.prototype.getSet.call(this, row);
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    return CategoricalColumn.prototype.compare.call(this, a, b);
-  }
-
   toCompareValue(row: IDataRow) {
     return CategoricalColumn.prototype.toCompareValue.call(this, row);
   }

src/model/ICategoricalColumn.ts

@@ -1,4 +1,4 @@
-import Column, {ECompareValueType} from './Column';
+import Column, {ECompareValueType, ICompareValue} from './Column';
 import {IArrayColumn, isArrayColumn} from './IArrayColumn';
 import {IColumnDesc, IDataRow} from './interfaces';
 import {colorPool} from './internal';
@@ -58,7 +58,7 @@ export function toCategory(cat: (string | Partial<ICategory>), value: number, ne
 }
 
 /** @internal */
-export function compareCategory(a: ICategory | null, b: ICategory | null) {
+function compareCategory(a: ICategory | null, b: ICategory | null) {
   const aNull = a == null || isNaN(a.value);
   const bNull = b == null || isNaN(b.value);
   if (aNull || a == null) {
@@ -76,7 +76,7 @@ export function compareCategory(a: ICategory | null, b: ICategory | null) {
 /** @internal */
 export function toCompareCategoryValue(v: ICategory | null) {
   if (v == null) {
-    return null;
+    return [NaN, null];
   }
   return [v.value, v.label.toLowerCase()];
 }
@@ -139,6 +139,21 @@ export function groupCompareCategory(a: IDataRow[], b: IDataRow[], col: ICategor
   return aMostFrequent.cat.value - bMostFrequent.cat.value;
 }
 
+/** @internal */
+export function toGroupCompareCategoryValue(rows: IDataRow[], col: ICategoricalColumn): ICompareValue[] {
+  if (rows.length === 0) {
+    return [NaN, null, 0];
+  }
+  const mostFrequent = findMostFrequent(rows, col);
+  if (mostFrequent.cat == null) {
+    return [NaN, null, 0];
+  }
+  return [mostFrequent.cat.value, mostFrequent.cat.label.toLowerCase(), mostFrequent.count];
+}
+
+export const COMPARE_GROUP_CATEGORY_VALUE_TYPES = [ECompareValueType.NUMBER, ECompareValueType.STRING, ECompareValueType.NUMBER];
+
+
 /** @internal */
 export function toCategories(desc: ICategoricalDesc) {
   if (!desc.categories) {

src/model/INumberColumn.ts

@@ -74,7 +74,7 @@ export function compareBoxPlot(col: IBoxPlotColumn, a: IDataRow, b: IDataRow) {
 export function toCompareBoxPlotValue(col: IBoxPlotColumn, row: IDataRow) {
   const v = col.getBoxPlotData(row);
   const method = <keyof IBoxPlotData>col.getSortMethod();
-  return v == null ? null : <number>v[method];
+  return v == null ? NaN : <number>v[method];
 }
 
 export function getBoxPlotNumber(col: IBoxPlotColumn, row: IDataRow, mode: 'raw' | 'normalized'): number {

src/model/ImpositionBoxPlotColumn.ts

@@ -196,10 +196,6 @@ export default class ImpositionBoxPlotColumn extends CompositeColumn implements
     return w ? w.getRange() : ['0', '1'];
   }
 
-  compare(a: IDataRow, b: IDataRow) {
-    return BoxPlotColumn.prototype.compare.call(this, a, b);
-  }
-
   toCompareValue(row: IDataRow) {
     return BoxPlotColumn.prototype.toCompareValue.call(this, row);
   }
@@ -212,14 +208,14 @@ export default class ImpositionBoxPlotColumn extends CompositeColumn implements
     return BoxPlotColumn.prototype.group.call(this, row);
   }
 
-  groupCompare(a: IGroupData, b: IGroupData) {
-    return BoxPlotColumn.prototype.groupCompare.call(this, a, b);
-  }
-
   toCompareGroupValue(group: IGroupData) {
     return BoxPlotColumn.prototype.toCompareGroupValue.call(this, group);
   }
 
+  toCompareGroupValueType() {
+    return BoxPlotColumn.prototype.toCompareGroupValueType.call(this);
+  }
+
   insert(col: Column, index: number): Column | null {
     if (this._children.length === 0 && !isBoxPlotColumn(col)) {
       return null;