feat(comparator): added comparator class for comparisons

Author: IPRIT

src/lib/index.ts

@@ -1 +1,2 @@
 export * from './math';
+export * from './utils';

src/lib/math/greatest-common-divisor/greatest-common-divisor.spec.ts

@@ -1,4 +1,5 @@
 // tslint:disable:no-expression-statement
+// @ts-ignore
 import test from 'ava';
 import { greatestCommonDivisor } from './greatest-common-divisor';
 

src/lib/utils/comparator/comparator.spec.ts

@@ -0,0 +1,59 @@
+// tslint:disable:no-expression-statement
+import test from 'ava';
+import { Comparator } from './comparator';
+
+test('comparator equal', t => {
+  const comparator = new Comparator<number>((a, b) =>
+    a === b ? 0 : a < b ? -1 : 1
+  );
+  t.is(comparator.equal(1, 1), true);
+  t.is(comparator.equal(1, 2), false);
+});
+
+test('comparator equal (default comparer)', t => {
+  const numberComparator = new Comparator<number>();
+  t.is(numberComparator.equal(-1, -1), true);
+  t.is(numberComparator.equal(3, 4), false);
+
+  const stringComparator = new Comparator<string>();
+  t.is(stringComparator.equal('s', 's'), true);
+  t.is(stringComparator.equal('2019 Year', '2020 Year'), false);
+});
+
+test('comparator less', t => {
+  const comparator = new Comparator<number>();
+  t.is(comparator.less(3, 4), true);
+  t.is(comparator.less(-4, -3), true);
+  t.is(comparator.less(-1, -1), false);
+});
+
+test('comparator lessOrEqual', t => {
+  const comparator = new Comparator<number>();
+  t.is(comparator.lessOrEqual(3, 4), true);
+  t.is(comparator.lessOrEqual(-1, -1), true);
+  t.is(comparator.lessOrEqual(-1, -2), false);
+});
+
+test('comparator greater', t => {
+  const comparator = new Comparator<number>();
+  t.is(comparator.greater(4, 3), true);
+  t.is(comparator.greater(-1, -1), false);
+});
+
+test('comparator greaterOrEqual', t => {
+  const comparator = new Comparator<number>();
+  t.is(comparator.greaterOrEqual(4, 3), true);
+  t.is(comparator.greaterOrEqual(-1, -1), true);
+  t.is(comparator.greaterOrEqual(-2, -1), false);
+});
+
+test('comparator reverse', t => {
+  const comparator = new Comparator<number>();
+  t.is(comparator.less(3, 4), true);
+
+  comparator.reverse();
+  t.is(comparator.less(3, 4), false);
+
+  comparator.reverse();
+  t.is(comparator.less(3, 4), true);
+});

src/lib/utils/comparator/comparator.ts

@@ -0,0 +1,60 @@
+type TCompareFn = (a, b) => number;
+
+export class Comparator<T> {
+  public static defaultCompareFn(a, b): number {
+    return a === b ? 0 : a < b ? -1 : 1;
+  }
+
+  private compareFn: TCompareFn;
+
+  constructor(compareFn: TCompareFn = Comparator.defaultCompareFn) {
+    if (typeof compareFn !== 'function') {
+      compareFn = Comparator.defaultCompareFn;
+    }
+
+    this.compareFn = compareFn;
+  }
+
+  /**
+   * Checks if two values are equal
+   */
+  public equal(a: T, b: T): boolean {
+    return this.compareFn(a, b) === 0;
+  }
+
+  /**
+   * Checks if variable "a" is less than "b"
+   */
+  public less(a: T, b: T): boolean {
+    return this.compareFn(a, b) < 0;
+  }
+
+  /**
+   * Checks if variable "a" is greater than "b"
+   */
+  public greater(a: T, b: T): boolean {
+    return this.compareFn(a, b) > 0;
+  }
+
+  /**
+   * Checks if variable "a" is less than or equal to "b"
+   */
+  public lessOrEqual(a: T, b: T): boolean {
+    return this.less(a, b) || this.equal(a, b);
+  }
+
+  /**
+   * Checks if variable "a" is greater than or equal to "b"
+   */
+  public greaterOrEqual(a: T, b: T): boolean {
+    return this.greater(a, b) || this.equal(a, b);
+  }
+
+  /**
+   * Reverses the comparison order
+   */
+  public reverse(): void {
+    const compareFn = this.compareFn;
+    this.compareFn = (a, b) => compareFn(b, a);
+  }
+}

src/lib/utils/index.ts

@@ -0,0 +1 @@
+export * from './comparator/comparator';