# set-utilities

1.5.6 • Public • Published

This library is a collection of high performance utilities from Set Theory, which operate on an arbitrary number of Sets by each accepting variable arguments.

Each utility function operates with the principals of immutability: none of the input sets are modified in the process or result of calculation.

## Set Operations:

### difference: `A ∖ B`

The difference of sets contains all the elements of the first set, not contained in other sets.

```import { difference } from 'set-utilities';

const differenceAB = difference(setA, setB);
const differenceABC = difference(setA, setB, setC);```

### intersection: `A ∩ B`

The intersection of sets contains all the elements each contained in every set.

```import { intersection } from 'set-utilities';

const intersectionAB = intersection(setA, setB);
const intersectionABC = intersection(setA, setB, setC);```

### union: `A ∪ B`

The union of sets contains all the elements each contained in any set.

```import { union } from 'set-utilities';

const unionAB = union(setA, setB);
const unionABC = union(setA, setB, setC);```

### symmetric difference (xor): `A ∆ B`

The symmetric difference of sets contains only the unique elements of each set.

```import { xor } from 'set-utilities';

const xorAB = xor(setA, setB);
const xorABC = xor(setA, setB, setC);```

## Set Comparisons:

### equivalence: `A ∼ B`

Sets are equivalent if they have the same cardinality, and there is a bijection between the elements contained in each set.

```import { equivalence } from 'set-utilities';

const isEquivalentAB = equivalence(setA, setB);
const isEquivalentABC = equivalence(setA, setB, setC);```

### disjoint: `A ∩ B = ∅`

Sets are disjoint if they have no elements in common.

```import { disjoint } from 'set-utilities';

const isDisjointAB = disjoint(setA, setB);
const isDisjointABC = disjoint(setA, setB, setC);```

### pairwise disjoint: `A ∩ B ∩ C = ∅`

A family of sets are pairwise disjoint if none of the sets share any elements in common.

```import { pairwiseDisjoint } from 'set-utilities';

const isPairwiseDisjointAB = pairwiseDisjoint(setA, setB);
const isPairwiseDisjointABC = pairwiseDisjoint(setA, setB, setC);```

### subset: `A ⊆ B`

A set is a subset of another if all of its elements are contained in the other set.

```import { subset } from 'set-utilities';

const isSubsetAB = subset(setA, setB);
const isSubsetABC = subset(setA, setB, setC);```

### proper subset: `A ⊂ B`

A set is a proper subset of another if all of its elements are contained in the other set, and it has a lower cardinality than the other set.

```import { properSubset } from 'set-utilities';

const isProperSubsetAB = properSubset(setA, setB);
const isProperSubsetABC = properSubset(setA, setB, setC);```

### superset: `A ⊇ B`

A set is a superset of another if it contains all the elements contained in the other set.

```import { superset } from 'set-utilities';

const isSupersetAB = superset(setA, setB);
const isSupersetABC = superset(setA, setB, setC);```

### proper superset: `A ⊃ B`

A set is a proper superset of another if it contains all the elements contained in the other set, and it has a greater cardinality than the other set.

```import { properSuperset } from 'set-utilities';

const isProperSupersetAB = properSuperset(setA, setB);
const isProperSupersetABC = properSuperset(setA, setB, setC);```

## Set Ordering:

### sort: `A ⇅`

An immutable sorting operation for sets.

```import { sort } from 'set-utilities';

const sortedA = sort(setA);
const sortedB = sort(setB, compareFunction);```

## Package Sidebar

### Install

`npm i set-utilities`

### Repository

github.com/kubikowski/set-utilities

### Homepage

github.com/kubikowski/set-utilities

572

1.5.6

MIT

21.7 kB

29