Mnemonist

Set (helpers)

Since ES2015, JavaScript has a perfectly fine Set object.

However, it direly lacks of some typical helpers such as functions computing the intersection between two sets.

That’s what the mnemonist/set module provides.

const helpers = require('mnemonist/set');

Functions

Functions returning a new set

Functions returning information about sets

Functions updating a set in-place

Functions used for counting & metrics

#.intersection

Returns the intersection of the given sets.

const A = new Set([1, 2, 3]);
const B = new Set([2, 3, 4]);

helpers.intersection(A, B);
>>> Set {2, 3}

// You can intersect as many sets as you want:
const C = new Set([1, 2]);

helpers.intersection(A, B, C);
>>> Set {2}

#.union

Returns the union of the given sets.

const A = new Set([1, 2, 3]),
    B = new Set([2, 3, 4]);

helpers.union(A, B);
>>> Set {1, 2, 3, 4}

// You can unite as many sets as you want:
const C = new Set([1, 2]);

helpers.union(A, B, C);
>>> Set {1, 2, 3, 4}

#.difference

Returns the difference of the given sets.

const A = new Set([1, 2, 3]);
const B = new Set([2, 3, 4]);

helpers.difference(A, B);
>>> Set {1}

#.symmetricDifference

Returns the symmetric difference (disjunction) of the given sets.

const A = new Set([1, 2, 3]);
const B = new Set([2, 3, 4]);

helpers.symmetricDifference(A, B);
>>> Set {1, 4}

#.isSubset

Returns whether the first set is a subset of the second one.

const A = new Set([1, 2]);
const B = new Set([1, 2, 3]);
const C = new Set([1, 4]);

helpers.isSubset(A, B);
>>> true

helpers.isSubset(A, C);
>>> false

#.isSuperset

Returns whether the first set is a superset of the second one.

const A = new Set([1, 2]);
const B = new Set([1, 2, 3]);
const C = new Set([1, 4]);

helpers.isSuperset(B, A);
>>> true

helpers.isSuperset(A, C);
>>> false

#.add

Adds the items of the second set to the first one in-place.

const A = new Set([1, 2]);

helpers.add(A, new Set([2, 3]));

// A is now:
>>> Set {1, 2, 3}

#.subtract

Subtracts the items of the second set from the first one in-place.

const A = new Set([1, 2, 3, 4]);

helpers.subtract(A, new Set([1, 2]));

// A is now:
>>> Set {3, 4}

#.intersect

Mutates the first set to become the intersection of both given sets.

const A = new Set([1, 2, 3]);
const B = new Set([2, 3, 4]);

helpers.intersect(A, B);

// A is now:
>>> Set {2, 3}

#.disjunct

Mutates the first set to become the disjunction (symmetric difference) of both given sets.

const A = new Set([1, 2, 3]);
const B = new Set([2, 3, 4]);

helpers.disjunct(A, B);

// A is now:
>>> Set {1, 4}

#.intersectionSize

Returns the size of the intersection of both given sets.

const A = new Set([1, 2, 3]);
const B = new Set([2, 3, 4]);

helpers.intersectionSize(A, B);
>>> 2

// This is faster and use less memory than:
helpers.intersection(A, B).size;

#.unionSize

Returns the size of the union of both given sets.

const A = new Set([1, 2, 3]);
const B = new Set([2, 3, 4]);

helpers.unionSize(A, B);
>>> 4

// This is faster and use less memory than:
helpers.union(A, B).size;

#.jaccard

Returns the Jaccard Index or similarity (i.e. intersection divided by union) between both given sets.

const contact = new Set('contact');
const context = new Set('context');

helpers.jaccard(contact, context);
>>> 4 / 7

#.overlap

Returns the overlap coefficient (i.e. intersection divided by min size) between both given sets.

const contact = new Set('contact');
const context = new Set('context');

helpers.overlap(contact, context);
>>> 4 / 5