Benchmark of methods to determine two sets overlap or not in JavaScript

benchmark-of-overlapping-sets.js

// License: MIT
// Original Author: YUKI "Piro" Hiroshi <yuki@clear-code.com>

// confirmed at Firefox 147

async function test(times, size) {
  function compareAndForLoop(a, b) {
    const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
    for (const state of smaller) {
      if (larger.has(state))
        return true;
    }
    return false;
  }

  function isDisjointFromOfSet(a, b) {
    return !a.isDisjointFrom(b);
  }

  function intersectionOfSet(a, b) {
    return a.intersection(b).size > 0;
  }

  function twoSets(a, b) {
    const unified = new Set([...a, ...b]);
    return unified.size < a.size + b.size;
  }

  function prepareArray(length) {
    const array = [];
    for (let i = 0; i < length; i++) {
      array.push(parseInt(Math.random() * (length / 10)));
    }
    return array;
  }

  const methods = [compareAndForLoop, isDisjointFromOfSet, intersectionOfSet, twoSets];
  const results = [];
  for (const compare of methods) {
    const a = new Set(prepareArray(size));
    const b = new Set(prepareArray(Math.ceil(size / 2)));
    const start = Date.now();
    for (let i = 0; i < times; i++) {
      const result = compare(new Set(a), new Set(b));
    }
    const delta = Date.now() - start;
    console.log(`${times}times, size=${size}, ${compare.name}`, delta);
    results.push(delta);
    await new Promise(resolve => setTimeout(resolve, 10));
  }
  return results;
}

(async () => {
  const methods = ',compareAndForLoop,isDisjointFromOfSet,intersection,twoSets';

  async function runForTimes(size, start, step) {
    const results = [methods];
    for (let i = 0, maxi = 5; i < maxi; i++) {
      const times = start + (step * i);
      results.push(times + ',' + (await test(times, size)).join(','));
    }
    console.log(results.join('\n'));
  }

  console.log('tests with small sets');
  await runForTimes(10, 100000, 100000);
  console.log('tests with middle sets');
  await runForTimes(300, 2500, 2500);
  console.log('tests with large sets');
  await runForTimes(5000, 100, 100);

  async function runForLength(times, start, step) {
    const results = [methods];
    for (let i = 0, maxi = 10; i < maxi; i++) {
      const size = start + (step * i);
      results.push(size + ',' + (await test(times, size)).join(','));
    }
    console.log(results.join('\n'));
  }
  console.log('tests with increasing size');
  await runForLength(5000, 100, 100);

  console.log('done');
})();

increasing-size.csv

large-sets.csv

middle-sets.csv

small-sets.csv