benchmarking HashMaps

Author: amejiarosario

benchmarks/hashmap.spec.js

@@ -0,0 +1,26 @@
+const HashMap = require('../src/data-structures/hash-maps/hash-map');
+const fs = require('fs');
+const readline = require('readline');
+const stream = require('stream');
+
+describe('HashMap Performance Test', () => {
+  describe('#set', () => {
+    it('set lots of values', (done) => {
+      hashMap = new HashMap();
+
+      const instream = fs.createReadStream('./words.txt');
+      const outstream = new stream;
+      const rl = readline.createInterface(instream, outstream);
+
+      rl.on('line', function(line) {
+        console.log(line);
+      });
+
+      rl.on('close', function() {
+        expect(hashMap.collisions).toBeLessThan(1);
+        done();
+      });
+
+    });
+  });
+});

benchmarks/words.txt

@@ -0,0 +1,24 @@
+the
+of
+and
+to
+a
+in
+for
+is
+on
+that
+by
+this
+with
+i
+you
+it
+not
+or
+be
+are
+from
+at
+as
+your

package-lock.json

@@ -7,11 +7,14 @@
     "lodash": "4.17.10"
   },
   "devDependencies": {
+    "asciichart": "1.5.7",
     "eslint": "4.19.1",
     "eslint-config-airbnb-base": "12.1.0",
     "eslint-plugin-import": "2.12.0",
     "eslint-plugin-jest": "21.17.0",
-    "jest": "23.0.1"
+    "jest": "23.6.0",
+    "numbers": "0.7.0",
+    "pandas-js": "0.2.4"
   },
   "scripts": {
     "test": "jest src/data-structures # jest # mocha src/**/*spec.js # jasmine JASMINE_CONFIG_PATH=jasmine.json # node jasmine-runner.js",

package.json

@@ -0,0 +1,70 @@
+const assert = require('assert');
+
+/**
+ * Calculates polynomial hash code that maps a key (value) to an integer (unbounded).
+ * It uses a 20 bit offset to avoid Unicode value overlaps
+ * @param {any} key
+ * @returns {BigInt} returns big integer (unbounded) that maps to the key
+ */
+function hashCode(key) {
+  const array = Array.from(`${key}${typeof key}`);
+  return array.reduce((hashCode, char, position) => {
+    return hashCode + BigInt(char.codePointAt(0)) * (2n ** (BigInt(position) * 20n));
+  }, 0n);
+}
+
+/**
+ * Compression function: maps an arbitrary integer to integer in the range of [0… BUCKET_SIZE -1].
+ * @param {BigInt} hashCode
+ * @param {Number} size bucket size
+ * @returns {Number} array index
+ */
+function compressToIndex(hashCode, size = 10) {
+  return parseInt(hashCode % BigInt(size), 10);
+}
+
+/**
+ *
+ * @param {*} key
+ */
+function hashFunction(key, size = 10) {
+  return compressToIndex(hashCode(key), size);
+}
+
+
+function printHash(el) {
+  const code = hashCode(el);
+  return { s: el, v: code.toLocaleString(), hex: code.toString(16), hashFn: compressToIndex(code) };
+}
+
+// similar ending
+console.table(['00', '10', '20', '30', '40', '50', '60', '70', '80', '90'].map(printHash));
+// similar start
+console.table(['10', '11', '12', '13', '14', '15', '16', '17', '18', '19'].map(printHash));
+
+console.table(['@', '#', '#!', 'stop', 'pots', 'Ca', 'DB'].map(printHash));
+
+// all different
+// console.table(['cat', 'dog', 'rat', 'art', 10, '10', {a:1}, '😸', '🐶', '😸🐶', '🐶😸'].map(printHash));
+// console.log(hashCode(Array(1500).fill('😁').join('')));
+// console.log(hashFunction(Array(1500).fill('😁').join('')));
+
+
+// function test(){
+//   return 1n + 2n;
+// }
+
+// test();
+
+
+// hashCode(10); //=> 97
+// hashCode('10'); //=> 97
+
+assert.notEqual(hashCode(10), hashCode('10'), 'Hash code should be different with different types');
+assert.notEqual(hashCode('10string'), hashCode('10'), 'Hash code should be different with different types');
+
+hashCode(10) === hashCode('10'); //=> false
+hashCode('10') === hashCode('10string'); //=> false
+hashCode('art') === hashCode('rat'); //=> false
+hashCode('😄') === hashCode('😄'); //=> true
+hashCode('😄') === hashCode('😸'); //=> false

sortedArray1e4.txt

@@ -0,0 +1,67 @@
+const assert = require('assert');
+
+/**
+ *
+ * @param {*} key
+ */
+function hashFunction(key, size = 10) {
+  const primeNumber = 1327144003n; // 2 ** 77232917 - 1
+
+  const hashCode = Array.from(key.toString()).reduce((hash, char) => {
+    return (hash * primeNumber + BigInt(char.codePointAt(0))) % BigInt(size);
+  }, 0n);
+
+  return parseInt(hashCode, 10);
+}
+
+// function hashCodeJava(key) {
+//   let h = 0;
+//   const value = key.toString();
+//   const length = value.length >> 1;
+
+//   for (let i = 0; i < length; i++) {
+//     h = 31 * h + value.codePointAt(i);
+//   }
+//   return h;
+// }
+
+function printHash(key) {
+  return { s: key, hashFn: hashFunction(key) };
+}
+
+// similar ending
+// console.table(['00', '10', '20', '30', '40', '50', '60', '70', '80', '90'].map(printHash));
+// similar start
+// console.table(['10', '11', '12', '13', '14', '15', '16', '17', '18', '19'].map(printHash));
+
+// console.table(['@', '#', '#!', 'stop', 'pots', 'Ca', 'DB', 'polygenelubricants', 'Pneumonoultramicroscopicsilicovolcanoconiosis'].map(printHash));
+
+const size = 5100;
+console.log(printHash(Array(size).fill('😁').join('')).hashFn);
+console.log(printHash(Array(size).fill('1').join('')).hashFn);
+console.log(printHash(Array(size).fill('A').join('')).hashFn);
+
+
+// all different
+// console.table(['cat', 'dog', 'rat', 'art', 10, '10', {a:1}, '😸', '🐶', '😸🐶', '🐶😸'].map(printHash));
+// console.log(hashFunction(Array(1500).fill('😁').join('')));
+
+
+// function test(){
+//   return 1n + 2n;
+// }
+
+// test();
+
+
+// hashCode(10); //=> 97
+// hashCode('10'); //=> 97
+
+// assert.notEqual(hashCode(10), hashCode('10'), 'Hash code should be different with different types');
+// assert.notEqual(hashCode('10string'), hashCode('10'), 'Hash code should be different with different types');
+
+// hashCode(10) === hashCode('10'); //=> false
+// hashCode('10') === hashCode('10string'); //=> false
+// hashCode('art') === hashCode('rat'); //=> false
+// hashCode('😄') === hashCode('😄'); //=> true
+// hashCode('😄') === hashCode('😸'); //=> false

src/data-structures/hash-maps/hashing-offset-test.js

@@ -0,0 +1,82 @@
+const primes = [31n, 33n, 37n, 39n, 41n, 101n, 8191n, 131071n, 524287n, 6700417n, 1327144003n, 9007199254740881n];
+
+function doubleToLongBits(number) {
+  const buffer = new ArrayBuffer(8); // 8 bytes for float64
+  const dataView = new DataView(buffer);
+  dataView.setFloat64(0, number); // set as float64
+  return dataView.getBigInt64(0); // read as long int (BigInt)
+}
+
+function hashNumber(number) {
+  const bigInt = doubleToLongBits(number);
+  return bigInt > 0 ? bigInt : ((2n ** 63n) + (bigInt * -1n));
+}
+
+/**
+ * Polynomial hash codes
+ * @param {any} key
+ */
+function hashString(key) {
+  return Array.from(key.toString()).reduce((hash, char) => {
+    return (hash * 33n) + BigInt(char.codePointAt(0));
+  }, 0n);
+}
+
+function hashCode(key) {
+  if (typeof(key) === 'number') {
+    return hashNumber(key);
+  }
+  return 2n ** 64n + hashString(key);
+}
+
+function hashIndex({key, size = 16} = {}) {
+  // return hashCode(key) % BigInt(size); // modulo size
+
+  // Multiply-Add-Divide (MAD) compression
+  const p = 524287n; // prime number larger than size.
+  const a = 8191n; // random [1..p-1]
+  const b = 0n; // random [0..p-1]
+  return ( (a * hashCode(key) + b) % p ) % BigInt(size);
+}
+
+module.exports = {
+  hashCode,
+  hashIndex
+}
+
+/**
+
+function prepareToPrint(key){
+  return { key: key.substring ? `${key.substring(0, 10)} (${key.length})` : key, hashCode: hashCode(key), hashIndex10: hashIndex({key, size: 10}) };
+}
+
+const res = [-2, -1, 0.5, 1, 2, 3, Math.PI, Number.MAX_VALUE, 2.7976931348623157e+308, 17.976931348623156e+400,
+  '😁',
+  'hola',
+  '@', '#', '#!', 'stop', 'pots', 'Ca', 'DB', 'polygenelubricants',
+  'Aa',
+  'BB',
+  'aoffckzdaoffckzdatafwjsh',
+  'aoffckzdaoffckzdbhlijevx',
+  Array(50).fill('1').join(''),
+  // types
+  {a:1},
+  1n,
+  1,
+  '1',
+  function a() {return;}
+  ]
+  .map(prepareToPrint);
+
+console.table(res);
+
+const res1 = [
+    Array(1500).fill('1').join(''),
+    Array(1500).fill('😁').join(''),
+    // Array(1500).fill('z').join(''),
+  ]
+  .map(prepareToPrint);
+
+  console.log(res1);
+
+// */

src/data-structures/hash-maps/hashing-prime-test.js

@@ -0,0 +1,59 @@
+const HashTable = require('./hash-map');
+// const asciichart = require ('asciichart');
+// const { Series } = require('pandas-js');
+
+const dict = new HashTable();
+
+const keys = [];
+const values = [];
+for (let i = 0; i < 1e1; i++) {
+  keys.push(makeid());
+  values.push(parseInt(Math.random()*1e2));
+}
+
+console.time('SET');
+for (let i = 0; i < keys.length; i++) {
+  dict.set(keys[i], values[i]);
+}
+console.timeEnd('SET');
+
+console.time('GET');
+for (let i = 0; i < keys.length; i++) {
+  const val = dict.get(keys[i]);
+}
+console.timeEnd('GET');
+
+// distibution
+const usage = dict.buckets.reduce((array, el, index) => {
+  array[index] = el.length;
+  return array;
+}, Array(dict.buckets.length).fill(0));
+
+console.log(usage, dict.buckets);
+
+const ds = new Series(usage);
+console.log({
+  length: usage.length,
+  max: Math.max.apply(null, usage),
+  min: Math.min.apply(null, usage),
+  count: ds.length,
+  mean: ds.mean(),
+  std: ds.std(),
+  variance: ds.variance(),
+});
+
+// console.log({elementsByBucket});
+// console.log (asciichart.plot(elementsByBucket));
+
+// Helpers
+
+function makeid() {
+  const text = [];
+  const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ñåé😁🖖1234567890!@#$%^&*()_+{}';<>?";
+
+  for (let i = 0; i < 5; i++) {
+    text.push(possible.charAt(Math.floor(Math.random() * possible.length)));
+  }
+
+  return text.join('');
+}

src/data-structures/hash-maps/hashing.js

@@ -0,0 +1,108 @@
+/**
+ * Related:
+ * https://github.com/numbers/numbers.js/blob/master/test/statistic.test.js
+ */
+class Stats {
+  constructor(serie = []) {
+    this.serie = serie;
+  }
+
+  set serie(serie) {
+    this.originalArray = serie;
+    this.sortedArray = serie.sort((a, b) => b - a);
+    this.evenSet = serie % 2 === 0;
+    this.oddSet = !this.evenSet;
+    this.length = serie.length;
+    this.middleIndex = parseInt(serie.length / 2);
+  }
+
+  get serie() {
+    return this.sortedArray;
+  }
+
+  count() {
+    return this.serie.length;
+  }
+
+  sum() {
+    return this.serie.reduce((sum, el) => sum + el);
+  }
+
+  /**
+   * The mean is the average of the numbers: a calculated "central" value of a set of numbers.
+   *
+   * add up all the numbers, then divide by how many numbers there are.
+   */
+  mean() {
+    return this.sum() / this.count();
+  }
+
+  /**
+   * "middle" value
+   */
+  median(array = this.serie) {
+    const sortedArray = array.sort((a, b) => b - a);
+    const count = sortedArray.length;
+    const middle = parseInt(count/2);
+    if (count % 2 === 0) {
+      // even
+      return {
+        median: (sortedArray[middle] + sortedArray[middle - 1]) / 2,
+        medianIndex: null,
+      };
+    }
+    // odd
+    return {
+      median: sortedArray[middle],
+      medianIndex: middle,
+    };
+  }
+
+  /**
+   * A quartile is a type of quantile.
+   * The first quartile (Q1) is defined as the middle number between the smallest number and the median of the data set.
+   * The second quartile (Q2) is the median of the data.
+   * The third quartile (Q3) is the middle value between the median and the highest value of the data set.
+   *
+   * Use the median to divide the ordered data set into two halves.
+   * If there are an odd number of data points in the original ordered data set, include the median (the central value in the ordered list) in both halves.
+   * If there are an even number of data points in the original ordered data set, split this data set exactly in half.
+   * The lower quartile value is the median of the lower half of the data. The upper quartile value is the median of the upper half of the data.
+   */
+  quartile() {
+    const { medianIndex, median } = this.median();
+    let q1;
+    let q3;
+
+    if (this.evenSet) {
+      // even - split half
+      q1 = this.median(this.serie.slice(0, this.middleIndex)).median;
+      q3 = this.median(this.serie.slice(this.middleIndex)).median;
+    } else {
+      // odd - include the median
+      q1 = this.median(this.serie.slice(0, medianIndex + 1)).median;
+      q3 = this.median(this.serie.slice(medianIndex)).median;
+    }
+
+    return {
+      '25%': q1,
+      '50%': median,
+      '75%': q3,
+    };
+  }
+
+  describe() {
+    return {
+      count: this.serie.length,
+      mean: 0,
+      std: 0,
+      min: 0,
+      '25%': 0,
+      '50%': 0,
+      '75%': 0,
+      max: 0,
+    };
+  }
+}
+
+module.exports = Stats;

src/data-structures/hash-maps/hashmap.perf.js

@@ -0,0 +1,41 @@
+const Serie = require('./stats');
+
+describe('Stats', () => {
+  describe('#median', () => {
+    it('should work with odd array', () => {
+      const s = new Serie([1, 3, 3, 6, 7, 8, 9]); // 7
+      expect(s.median()).toEqual({
+        median: 6,
+        medianIndex: 3,
+      });
+    });
+
+    it('should work with even array', () => {
+      const s = new Serie([1, 2, 3, 4, 5, 6, 8, 9]); // 8
+      expect(s.median()).toEqual({
+        median: 4.5,
+        medianIndex: null,
+      });
+    });
+  });
+
+  xdescribe('#quartile', () => {
+    it('should get quartile with odd dataset', () => {
+      const s = new Serie([7, 15, 36, 39, 40, 41]);
+      expect(s.quartile()).toEqual({
+        '25%': 15,
+        '50%': 37.5,
+        '75%': 40,
+      });
+    });
+
+    it('should get quartile with even data set', () => {
+      const s = new Serie([7, 15, 36, 39, 40, 41]);
+      expect(s.quartile()).toEqual({
+        '25%': 25.5,
+        '50%': 50,
+        '75%': 42.5,
+      });
+    });
+  });
+});