enumset32-benchmarks/lib/tags.js

Benchmarks for enumset32 vs other set implementations

/*!
 * Copyright (c) 2019 Justin Johansson
 */
import * as assert from 'assert';
import * as bench from 'benchmark';
import { set as fpset, setoid as fpsetoid } from 'fp-ts';
import * as _ from 'lodash';
import { UniversalEnumset32 } from 'enumset32';
var Tag;
(function (Tag) {
    Tag[Tag["A"] = 0] = "A";
    Tag[Tag["B"] = 1] = "B";
    Tag[Tag["C"] = 2] = "C";
    Tag[Tag["D"] = 3] = "D";
    Tag[Tag["E"] = 4] = "E";
})(Tag || (Tag = {}));
const tags = UniversalEnumset32(Tag);
const NLOOPS = 1000;
function A_ES2015$Set_set_creation() {
    let s1 = new Set([Tag.E, Tag.A, Tag.E]);
    assert.equal(s1.size, 2);
    assert.equal(s1.has(Tag.A), true);
    assert.equal(s1.has(Tag.B), false);
    assert.equal(s1.has(Tag.C), false);
    assert.equal(s1.has(Tag.D), false);
    assert.equal(s1.has(Tag.E), true);
    let sets = new Array(NLOOPS);
    for (let i = 0; i < NLOOPS; ++i) {
        sets[i] = new Set([Tag.E, Tag.A, Tag.E]);
    }
}
function B_Enumset32_set_creation() {
    let s1 = tags.set(Tag.E, Tag.A, Tag.E);
    assert.equal(tags.count(s1), 2);
    assert.equal(tags.includes(s1, Tag.A), true);
    assert.equal(tags.includes(s1, Tag.B), false);
    assert.equal(tags.includes(s1, Tag.C), false);
    assert.equal(tags.includes(s1, Tag.D), false);
    assert.equal(tags.includes(s1, Tag.E), true);
    let sets = new Array(NLOOPS);
    for (let i = 0; i < NLOOPS; ++i) {
        sets[i] = tags.set(Tag.E, Tag.A, Tag.E);
    }
}
function D_Lodash_set_creation() {
    let s1 = _.sortBy(_.uniq([Tag.E, Tag.A, Tag.E]));
    assert.equal(_.size(s1), 2);
    assert.equal(_.includes(s1, Tag.A), true);
    assert.equal(_.includes(s1, Tag.B), false);
    assert.equal(_.includes(s1, Tag.C), false);
    assert.equal(_.includes(s1, Tag.D), false);
    assert.equal(_.includes(s1, Tag.E), true);
    let sets = new Array(NLOOPS);
    for (let i = 0; i < NLOOPS; ++i) {
        sets[i] = _.sortBy(_.uniq([Tag.E, Tag.A, Tag.E]));
    }
}
function A_ES2015$Set_set_membership() {
    let s1 = new Set([Tag.A, Tag.E]);
    assert.equal(s1.size, 2);
    assert.equal(s1.has(Tag.A), true);
    assert.equal(s1.has(Tag.B), false);
    assert.equal(s1.has(Tag.C), false);
    assert.equal(s1.has(Tag.D), false);
    assert.equal(s1.has(Tag.E), true);
    for (let i = 0; i < NLOOPS; ++i) {
        s1.has(Tag.E);
    }
}
function B_Enumset32_set_membership() {
    let s1 = tags.set(Tag.A, Tag.E);
    assert.equal(tags.count(s1), 2);
    assert.equal(tags.includes(s1, Tag.A), true);
    assert.equal(tags.includes(s1, Tag.B), false);
    assert.equal(tags.includes(s1, Tag.C), false);
    assert.equal(tags.includes(s1, Tag.D), false);
    assert.equal(tags.includes(s1, Tag.E), true);
    for (let i = 0; i < NLOOPS; ++i) {
        tags.includes(s1, Tag.E);
    }
}
function D_Lodash_set_membership() {
    let s1 = _.sortBy(_.uniq([Tag.A, Tag.E]));
    assert.equal(_.size(s1), 2);
    assert.equal(_.includes(s1, Tag.A), true);
    assert.equal(_.includes(s1, Tag.B), false);
    assert.equal(_.includes(s1, Tag.C), false);
    assert.equal(_.includes(s1, Tag.D), false);
    assert.equal(_.includes(s1, Tag.E), true);
    for (let i = 0; i < NLOOPS; ++i) {
        _.includes(s1, Tag.E);
    }
}
function eqES2015Set(s1, s2) {
    if (s1.size !== s2.size) {
        return false;
    }
    for (let a of s1) {
        if (!s2.has(a)) {
            return false;
        }
    }
    return true;
}
function A_ES2015$Set_set_equality() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.C, Tag.A, Tag.B]);
    let s3 = new Set([Tag.B, Tag.C, Tag.D]);
    assert.equal(eqES2015Set(s1, s2), true);
    assert.equal(eqES2015Set(s1, s3), false);
    for (let i = 0; i < NLOOPS; ++i) {
        eqES2015Set(s1, s3);
    }
}
function B_Enumset32_set_equality() {
    let s1 = tags.set(Tag.A, Tag.B, Tag.C);
    let s2 = tags.set(Tag.C, Tag.A, Tag.B);
    let s3 = tags.set(Tag.B, Tag.C, Tag.D);
    assert.equal(tags.equal(s1, s2), true);
    assert.equal(tags.equal(s2, s3), false);
    for (let i = 0; i < NLOOPS; ++i) {
        tags.equal(s2, s3);
    }
}
function D_Lodash_set_equality() {
    let s1 = _.sortBy(_.uniq([Tag.A, Tag.B, Tag.C]));
    let s2 = _.sortBy(_.uniq([Tag.C, Tag.A, Tag.B]));
    let s3 = _.sortBy(_.uniq([Tag.B, Tag.C, Tag.D]));
    assert.equal(_.isEqual(s1, s2), true);
    assert.equal(_.isEqual(s1, s3), false);
    for (let i = 0; i < NLOOPS; ++i) {
        _.isEqual(s1, s3);
    }
}
function A_ES2015$Set_set_complement() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let univ = [Tag.A, Tag.B, Tag.C, Tag.D, Tag.E];
    let s2 = new Set(univ.filter((x) => !s1.has(x)));
    assert.equal(s2.size, 2);
    assert.equal(s2.has(Tag.A), false);
    assert.equal(s2.has(Tag.B), false);
    assert.equal(s2.has(Tag.C), false);
    assert.equal(s2.has(Tag.D), true);
    assert.equal(s2.has(Tag.E), true);
    for (let i = 0; i < NLOOPS; ++i) {
        new Set(univ.filter((x) => !s1.has(x)));
    }
}
function B_Enumset32_set_complement() {
    let s1 = tags.set(Tag.A, Tag.B, Tag.C);
    let s2 = tags.complement(s1);
    assert.equal(tags.count(s2), 2);
    assert.equal(tags.includes(s2, Tag.A), false);
    assert.equal(tags.includes(s2, Tag.B), false);
    assert.equal(tags.includes(s2, Tag.C), false);
    assert.equal(tags.includes(s2, Tag.D), true);
    assert.equal(tags.includes(s2, Tag.E), true);
    for (let i = 0; i < NLOOPS; ++i) {
        tags.complement(s1);
    }
}
function C_fp$ts_set_complement() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let univ = new Set([Tag.A, Tag.B, Tag.C, Tag.D, Tag.E]);
    let s2 = fpset.difference2v(fpsetoid.setoidNumber)(univ, s1);
    assert.equal(s2.size, 2);
    assert.equal(s2.has(Tag.A), false);
    assert.equal(s2.has(Tag.B), false);
    assert.equal(s2.has(Tag.C), false);
    assert.equal(s2.has(Tag.D), true);
    assert.equal(s2.has(Tag.E), true);
    for (let i = 0; i < NLOOPS; ++i) {
        fpset.difference2v(fpsetoid.setoidNumber)(univ, s1);
    }
}
function D_Lodash_set_complement() {
    let s1 = _.sortBy(_.uniq([Tag.A, Tag.B, Tag.C]));
    let univ = [Tag.A, Tag.B, Tag.C, Tag.D, Tag.E];
    let s2 = _.sortBy(_.difference(univ, s1));
    assert.equal(_.size(s2), 2);
    assert.equal(_.includes(s2, Tag.A), false);
    assert.equal(_.includes(s2, Tag.B), false);
    assert.equal(_.includes(s2, Tag.C), false);
    assert.equal(_.includes(s2, Tag.D), true);
    assert.equal(_.includes(s2, Tag.E), true);
    for (let i = 0; i < NLOOPS; ++i) {
        _.sortBy(_.difference(univ, s1));
    }
}
function A_ES2015$Set_set_union() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.D, Tag.C, Tag.B]);
    let s3 = new Set([...s1, ...s2]);
    assert.equal(s3.size, 4);
    assert.equal(s3.has(Tag.A), true);
    assert.equal(s3.has(Tag.B), true);
    assert.equal(s3.has(Tag.C), true);
    assert.equal(s3.has(Tag.D), true);
    assert.equal(s3.has(Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        new Set([...s1, ...s2]);
    }
}
function B_Enumset32_set_union() {
    let s1 = tags.set(Tag.A, Tag.B, Tag.C);
    let s2 = tags.set(Tag.D, Tag.C, Tag.B);
    let s3 = tags.addAll(s1, s2);
    assert.equal(tags.count(s3), 4);
    assert.equal(tags.includes(s3, Tag.A), true);
    assert.equal(tags.includes(s3, Tag.B), true);
    assert.equal(tags.includes(s3, Tag.C), true);
    assert.equal(tags.includes(s3, Tag.D), true);
    assert.equal(tags.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        tags.addAll(s1, s2);
    }
}
function C_fp$ts_set_union() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.D, Tag.C, Tag.B]);
    let s3 = fpset.union(fpsetoid.setoidNumber)(s1, s2);
    assert.equal(s3.size, 4);
    assert.equal(s3.has(Tag.A), true);
    assert.equal(s3.has(Tag.B), true);
    assert.equal(s3.has(Tag.C), true);
    assert.equal(s3.has(Tag.D), true);
    assert.equal(s3.has(Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        fpset.union(fpsetoid.setoidNumber)(s1, s2);
    }
}
function D_Lodash_set_union() {
    let s1 = _.sortBy(_.uniq([Tag.A, Tag.B, Tag.C]));
    let s2 = _.sortBy(_.uniq([Tag.D, Tag.C, Tag.B]));
    let s3 = _.union(s1, s2);
    assert.equal(_.size(s3), 4);
    assert.equal(_.includes(s3, Tag.A), true);
    assert.equal(_.includes(s3, Tag.B), true);
    assert.equal(_.includes(s3, Tag.C), true);
    assert.equal(_.includes(s3, Tag.D), true);
    assert.equal(_.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        _.union(s1, s2);
    }
}
function A_ES2015$Set_set_intersection() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.D, Tag.C, Tag.B]);
    let s3 = new Set([...s1].filter((x) => s2.has(x)));
    assert.equal(s3.size, 2);
    assert.equal(s3.has(Tag.A), false);
    assert.equal(s3.has(Tag.B), true);
    assert.equal(s3.has(Tag.C), true);
    assert.equal(s3.has(Tag.D), false);
    assert.equal(s3.has(Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        new Set([...s1].filter((x) => s2.has(x)));
    }
}
function B_Enumset32_set_intersection() {
    let s1 = tags.set(Tag.A, Tag.B, Tag.C);
    let s2 = tags.set(Tag.D, Tag.C, Tag.B);
    let s3 = tags.retainAll(s1, s2);
    assert.equal(tags.count(s3), 2);
    assert.equal(tags.includes(s3, Tag.A), false);
    assert.equal(tags.includes(s3, Tag.B), true);
    assert.equal(tags.includes(s3, Tag.C), true);
    assert.equal(tags.includes(s3, Tag.D), false);
    assert.equal(tags.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        tags.retainAll(s1, s2);
    }
}
function C_fp$ts_set_intersection() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.D, Tag.C, Tag.B]);
    let s3 = fpset.intersection(fpsetoid.setoidNumber)(s1, s2);
    assert.equal(s3.size, 2);
    assert.equal(s3.has(Tag.A), false);
    assert.equal(s3.has(Tag.B), true);
    assert.equal(s3.has(Tag.C), true);
    assert.equal(s3.has(Tag.D), false);
    assert.equal(s3.has(Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        fpset.intersection(fpsetoid.setoidNumber)(s1, s2);
    }
}
function D_Lodash_set_intersection() {
    let s1 = _.sortBy(_.uniq([Tag.A, Tag.B, Tag.C]));
    let s2 = _.sortBy(_.uniq([Tag.D, Tag.C, Tag.B]));
    let s3 = _.intersection(s1, s2);
    assert.equal(_.size(s3), 2);
    assert.equal(_.includes(s3, Tag.A), false);
    assert.equal(_.includes(s3, Tag.B), true);
    assert.equal(_.includes(s3, Tag.C), true);
    assert.equal(_.includes(s3, Tag.D), false);
    assert.equal(_.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        _.intersection(s1, s2);
    }
}
function A_ES2015$Set_set_difference() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.D, Tag.C, Tag.B]);
    let s3 = new Set([...s1].filter((x) => !s2.has(x)));
    assert.equal(s3.size, 1);
    assert.equal(s3.has(Tag.A), true);
    assert.equal(s3.has(Tag.B), false);
    assert.equal(s3.has(Tag.C), false);
    assert.equal(s3.has(Tag.D), false);
    assert.equal(s3.has(Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        new Set([...s1].filter((x) => !s2.has(x)));
    }
}
function B_Enumset32_set_difference() {
    let s1 = tags.set(Tag.A, Tag.B, Tag.C);
    let s2 = tags.set(Tag.D, Tag.C, Tag.B);
    let s3 = tags.removeAll(s1, s2);
    assert.equal(tags.count(s3), 1);
    assert.equal(tags.includes(s3, Tag.A), true);
    assert.equal(tags.includes(s3, Tag.B), false);
    assert.equal(tags.includes(s3, Tag.C), false);
    assert.equal(tags.includes(s3, Tag.D), false);
    assert.equal(tags.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        tags.removeAll(s1, s2);
    }
}
function C_fp$ts_set_difference() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.D, Tag.C, Tag.B]);
    let s3 = fpset.difference2v(fpsetoid.setoidNumber)(s1, s2);
    assert.equal(s3.size, 1);
    assert.equal(s3.has(Tag.A), true);
    assert.equal(s3.has(Tag.B), false);
    assert.equal(s3.has(Tag.C), false);
    assert.equal(s3.has(Tag.D), false);
    assert.equal(s3.has(Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        fpset.difference2v(fpsetoid.setoidNumber)(s1, s2);
    }
}
function D_Lodash_set_difference() {
    let s1 = _.sortBy(_.uniq([Tag.A, Tag.B, Tag.C]));
    let s2 = _.sortBy(_.uniq([Tag.D, Tag.C, Tag.B]));
    let s3 = _.difference(s1, s2);
    assert.equal(_.size(s3), 1);
    assert.equal(_.includes(s3, Tag.A), true);
    assert.equal(_.includes(s3, Tag.B), false);
    assert.equal(_.includes(s3, Tag.C), false);
    assert.equal(_.includes(s3, Tag.D), false);
    assert.equal(_.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        _.difference(s1, s2);
    }
}
function A_ES2015$Set_set_symmetric_difference() {
    let s1 = new Set([Tag.A, Tag.B, Tag.C]);
    let s2 = new Set([Tag.D, Tag.C, Tag.B]);
    let s3 = new Set([...[...s1].filter((x) => !s2.has(x)), ...[...s2].filter((x) => !s1.has(x))]);
    assert.equal(s3.size, 2);
    assert.equal(s3.has(Tag.A), true);
    assert.equal(s3.has(Tag.B), false);
    assert.equal(s3.has(Tag.C), false);
    assert.equal(s3.has(Tag.D), true);
    assert.equal(s3.has(Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        new Set([...[...s1].filter((x) => !s2.has(x)), ...[...s2].filter((x) => !s1.has(x))]);
    }
}
function B_Enumset32_set_symmetric_difference() {
    let s1 = tags.set(Tag.A, Tag.B, Tag.C);
    let s2 = tags.set(Tag.D, Tag.C, Tag.B);
    let s3 = tags.toggleAll(s1, s2);
    assert.equal(tags.count(s3), 2);
    assert.equal(tags.includes(s3, Tag.A), true);
    assert.equal(tags.includes(s3, Tag.B), false);
    assert.equal(tags.includes(s3, Tag.C), false);
    assert.equal(tags.includes(s3, Tag.D), true);
    assert.equal(tags.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        tags.toggleAll(s1, s2);
    }
}
function D_Lodash_set_symmetric_difference() {
    let s1 = _.sortBy(_.uniq([Tag.A, Tag.B, Tag.C]));
    let s2 = _.sortBy(_.uniq([Tag.D, Tag.C, Tag.B]));
    let s3 = _.xor(s1, s2);
    assert.equal(_.size(s3), 2);
    assert.equal(_.includes(s3, Tag.A), true);
    assert.equal(_.includes(s3, Tag.B), false);
    assert.equal(_.includes(s3, Tag.C), false);
    assert.equal(_.includes(s3, Tag.D), true);
    assert.equal(_.includes(s3, Tag.E), false);
    for (let i = 0; i < NLOOPS; ++i) {
        _.xor(s1, s2);
    }
}
const testgroups = [
    [
        'Set creation',
        [
            A_ES2015$Set_set_creation,
            B_Enumset32_set_creation,
            D_Lodash_set_creation
        ]
    ],
    [
        'Set membership',
        [
            A_ES2015$Set_set_membership,
            B_Enumset32_set_membership,
            D_Lodash_set_membership
        ]
    ],
    [
        'Set equality',
        [
            A_ES2015$Set_set_equality,
            B_Enumset32_set_equality,
            D_Lodash_set_equality
        ]
    ],
    [
        'Set complement',
        [
            A_ES2015$Set_set_complement,
            B_Enumset32_set_complement,
            C_fp$ts_set_complement,
            D_Lodash_set_complement
        ]
    ],
    [
        'Set union',
        [A_ES2015$Set_set_union, B_Enumset32_set_union, C_fp$ts_set_union, D_Lodash_set_union]
    ],
    [
        'Set intersection',
        [
            A_ES2015$Set_set_intersection,
            B_Enumset32_set_intersection,
            C_fp$ts_set_intersection,
            D_Lodash_set_intersection
        ]
    ],
    [
        'Set difference',
        [
            A_ES2015$Set_set_difference,
            B_Enumset32_set_difference,
            C_fp$ts_set_difference,
            D_Lodash_set_difference
        ]
    ],
    [
        'Set symmetric difference',
        [
            A_ES2015$Set_set_symmetric_difference,
            B_Enumset32_set_symmetric_difference,
            D_Lodash_set_symmetric_difference
        ]
    ]
];
export function getSuites() {
    let suites = [];
    for (let i = 0; i < testgroups.length; ++i) {
        let testgroup = testgroups[i];
        let suiteName = testgroup[0];
        let tests = testgroup[1];
        let suite = new bench.Suite(suiteName);
        for (let j = 0; j < tests.length; ++j) {
            let testFn = tests[j];
            let testName = testFn.name;
            suite.add(testName, testFn);
        }
        suites.push(suite);
    }
    return suites;
}