extra-set
Version:
A pack of functions for working with Sets.<br>
683 lines • 59.5 kB
JavaScript
import { IDENTITY, COMPARE } from "@nodef/extra-function";
import { chunk as arrayChunk, subsequences as arraySubsequences, randomValue as arrayRandomValue, randomSubsequence as arrayRandomSubsequence } from "@nodef/extra-array";
// METHODS
// =======
// ABOUT
// -----
/**
* Check if value is a set.
* @param v a value
* @returns v is a set?
*/ export function is(v) {
return v instanceof Set;
}
/**
* List all values.
* @param x a set
* @returns v₀, v₁, ... | vᵢ ∈ x
*/ export function values(x) {
return x.values();
}
export { values as keys };
/**
* List all value-value pairs.
* @param x a set
* @returns [v₀, v₀], [v₁, v₁], ... | vᵢ ∈ x
*/ export function entries(x) {
return x.entries();
}
// GENERATE
// --------
/**
* Convert an iterable to set.
* @param x an iterable
* @param fm map function (v, i, x)
* @returns x as set
*/ export function from(x, fm = null) {
if (!fm) return new Set(x);
const a = new Set();
let i = -1;
for (const v of x)a.add(fm(v, ++i, x));
return a;
}
/**
* Convert an iterable to set.
* @param x an iterable (updatable if set!)
* @returns x as set
*/ export function from$(x) {
return x instanceof Set ? x : new Set(x);
}
// COMPARE
// -------
/**
* Compare two sets.
* @param x a set
* @param y another set
* @returns x=y: 0, otherwise: -ve/+ve
*/ export function compare(x, y) {
for (const v of x)if (!y.has(v)) return 1;
for (const v of y)if (!x.has(v)) return -1;
return 0;
}
/**
* Check if two sets are equal.
* @param x a set
* @param y another set
* @returns x = y?
*/ export function isEqual(x, y) {
return x.size === y.size && compare(x, y) === 0;
}
// SIZE
// ----
/**
* Find the size of a set.
* @param x a set
* @returns |x|
*/ export function size(x) {
return x.size;
}
export { size as length };
/**
* Check if a set is empty.
* @param x a set
* @returns |x| = 0?
*/ export function isEmpty(x) {
return x.size === 0;
}
// ADD/REMOVE
// ----------
/**
* Add a value to set.
* @param x a set
* @param v value
* @returns x ∪ \{v\}
*/ export function add(x, v) {
return new Set(x).add(v);
}
/**
* Add a value to set.
* @param x a set (updated)
* @param v value
* @returns x = x ∪ \{v\}
*/ export function add$(x, v) {
return x.add(v);
}
/**
* Delete a value from set.
* @param x a set
* @param v value
* @returns x \\ \{v\}
*/ export function remove(x, v) {
return remove$(new Set(x), v);
}
/**
* Delete a value from set.
* @param x a set (updated)
* @param v value
* @returns x = x \\ \{v\}
*/ export function remove$(x, v) {
x.delete(v);
return x;
}
// PROPERTY
// --------
/**
* Count values which satisfy a test.
* @param x a set
* @param ft test function (v, v, x)
* @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x
*/ export function count(x, ft) {
let a = 0;
for (const v of x)if (ft(v, v, x)) ++a;
return a;
}
/**
* Count occurrences of values.
* @param x a set
* @param fm map function (v, v, x)
* @returns Map \{value ⇒ count\}
*/ export function countAs(x, fm) {
fm = fm || IDENTITY;
const a = new Map();
for (const v of x){
const w = fm(v, v, x);
const n = a.get(w) || 0;
a.set(w, n + 1);
}
return a;
}
/**
* Find smallest value.
* @param x a set
* @param fc compare function (a, b)
* @param fm map function (v, v, x)
* @returns v | v ≤ vᵢ; vᵢ ∈ x
*/ export function min(x, fc = null, fm = null) {
return range(x, fc, fm)[0];
}
/**
* Find largest value.
* @param x a set
* @param fc compare function (a, b)
* @param fm map function (v, v, x)
* @returns v | v ≥ vᵢ; vᵢ ∈ x
*/ export function max(x, fc = null, fm = null) {
return range(x, fc, fm)[1];
}
/**
* Find smallest and largest entries.
* @param x a set
* @param fc compare function (a, b)
* @param fm map function (v, v, x)
* @returns [min_value, max_value]
*/ export function range(x, fc = null, fm = null) {
fc = fc || COMPARE;
fm = fm || IDENTITY;
let mu, mv;
let nu, nv;
let i = 0;
for (const u of x){
const v = fm(u, u, x);
if (i === 0 || fc(v, mv) < 0) {
mu = u;
mv = v;
}
if (i === 0 || fc(v, nv) > 0) {
nu = u;
nv = v;
}
i++;
}
return [
mu,
nu
];
}
// PART
// ----
/**
* Get first value from set (default order).
* @param x a set
* @param vd default value
* @returns v₀ if x ≠ Φ else vd | v₀ ∈ x
*/ export function head(x, vd) {
for (const v of x)return v;
return vd;
}
/**
* Get a set without its first value (default order).
* @param x a set
* @returns x \\ \{v₀\} if x ≠ Φ else x | v₀ ∈ x
*/ export function tail(x) {
return drop(x, 1);
}
/**
* Keep first n values only (default order).
* @param x a set
* @param n number of values [1]
* @returns \{v₀, v₁, ...\} | vᵢ ∈ x and |\{v₀, v₁, ...\}| ≤ n
*/ export function take(x, n = 1) {
const a = new Set();
let i = -1;
for (const v of x){
if (++i >= n) break;
a.add(v);
}
return a;
}
/**
* Keep first n values only (default order).
* @param x a set (updated)
* @param n number of values [1]
* @returns x = \{v₀, v₁, ...\} | vᵢ ∈ x and |\{v₀, v₁, ...\}| ≤ n
*/ export function take$(x, n = 1) {
let i = -1;
for (const v of x)if (++i >= n) x.delete(v);
return x;
}
/**
* Remove first n values (default order).
* @param x a set
* @param n number of values [1]
* @returns \{vₙ, vₙ₊₁, ...\} | vᵢ ∈ x and |\{vₙ, vₙ₊₁, ...\}| ≤ max(|x| - n, 0)
*/ export function drop(x, n = 1) {
const a = new Set();
let i = -1;
for (const v of x)if (++i >= n) a.add(v);
return a;
}
/**
* Remove first n values (default order).
* @param x a set (updated)
* @param n number of values [1]
* @returns x = \{vₙ, vₙ₊₁, ...\} | vᵢ ∈ x and |\{vₙ, vₙ₊₁, ...\}| ≤ max(|x| - n, 0)
*/ export function drop$(x, n = 1) {
let i = -1;
for (const v of x){
if (++i >= n) break;
x.delete(v);
}
return x;
}
// ARRANGEMENTS
// ------------
/**
* List all possible subsets.
* @param x a set
* @param n number of values [-1 ⇒ any]
* @returns elements selected by bit from 0..2^|x| if n<0; only of length n otherwise
*/ export function* subsets(x, n = -1) {
for (const vs of arraySubsequences([
...x
], n))yield new Set(vs);
}
/**
* Pick an arbitrary value.
* @param x a set
* @param fr random number generator ([0, 1))
* @returns vᵢ | vᵢ ∈ x
*/ export function randomValue(x, fr = Math.random) {
return arrayRandomValue([
...x
], fr);
}
export { randomValue as randomKey };
export { randomValue as value };
export { randomValue as key };
/**
* Pick an arbitrary entry.
* @param x a set
* @param fr random number generator ([0, 1))
* @returns [vᵢ, vᵢ] | vᵢ ∈ x
*/ export function randomEntry(x, fr = Math.random) {
return arrayRandomValue([
...x.entries()
], fr);
}
export { randomEntry as entry };
/**
* Pick an arbitrary subset.
* @param x a set
* @param n number of values [-1 ⇒ any]
* @param fr random number generator ([0, 1))
* @returns \{vᵢ, vⱼ, ...\} | vᵢ, vⱼ, ... ∈ x; |\{vᵢ, vⱼ, ...\}| = |x| if n<0 else n
*/ export function randomSubset(x, n = -1, fr = Math.random) {
const vs = arrayRandomSubsequence([
...x
], n, fr);
return new Set(vs);
}
/**
* Checks if set has a subset.
* @param x a set
* @param y search subset
* @returns y ⊆ x?
*/ export function hasSubset(x, y) {
for (const v of y)if (!x.has(v)) return false;
return true;
}
// FIND
// ----
/**
* Check if set has a value.
* @param x a set
* @param v search value
* @returns v ∈ x?
*/ export function has(x, v) {
return x.has(v);
}
/**
* Find first value passing a test (default order).
* @param x a set
* @param ft test function (v, v, x)
* @returns first v | ft(v) = true; v ∈ x
*/ export function find(x, ft) {
for (const v of x)if (ft(v, v, x)) return v;
}
export { find as search };
/**
* Find all values passing a test.
* @param x a set
* @param ft test function (v, v, x)
* @returns [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x
*/ export function findAll(x, ft) {
const a = [];
for (const v of x)if (ft(v, v, x)) a.push(v);
return a;
}
export { findAll as searchAll };
// FUNCTIONAL
// ----------
/**
* Call a function for each value.
* @param x a set
* @param fp process function (v, v, x)
*/ export function forEach(x, fp) {
for (const v of x)fp(v, v, x);
}
/**
* Check if any value satisfies a test.
* @param x a set
* @param ft test function (v, v, x)
* @returns true if ft(vᵢ) = true for some vᵢ ∈ x
*/ export function some(x, ft = null) {
ft = ft || IDENTITY;
for (const v of x)if (ft(v, v, x)) return true;
return false;
}
/**
* Check if all values satisfy a test.
* @param x a set
* @param ft test function (v, v, x)
* @returns true if ft(vᵢ) = true for all vᵢ ∈ x
*/ export function every(x, ft = null) {
ft = ft || IDENTITY;
for (const v of x)if (!ft(v, v, x)) return false;
return true;
}
/**
* Transform values of a set.
* @param x a set
* @param fm map function (v, v, x)
* @returns \{fm(v₀), fm(v₁), ...\} | vᵢ ∈ x
*/ export function map(x, fm) {
const a = new Set();
for (const v of x)a.add(fm(v, v, x));
return a;
}
/**
* Transform values of a set.
* @param x a set (updated)
* @param fm map function (v, v, x)
* @returns x = \{fm(v₀), fm(v₁), ...\} | vᵢ ∈ x
*/ export function map$(x, fm) {
const vs = [];
for (const v of x)vs.push(fm(v, v, x));
x.clear();
return concat$(x, vs);
}
/**
* Reduce values of set to a single value.
* @param x a set
* @param fr reduce function (acc, v, v, x)
* @param acc initial value
* @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given
*/ export function reduce(x, fr, acc) {
let init = arguments.length <= 2;
for (const v of x){
if (init) {
acc = v;
init = false;
} else acc = fr(acc, v, v, x);
}
return acc;
}
/**
* Keep values which pass a test.
* @param x a set
* @param ft test function (v, v, x)
* @returns \{v₀, v₁, ...\} | ft(vᵢ) = true; vᵢ ∈ x
*/ export function filter(x, ft) {
const a = new Set();
for (const v of x)if (ft(v, v, x)) a.add(v);
return a;
}
/**
* Keep values which pass a test.
* @param x a set (updated)
* @param ft test function (v, v, x)
* @returns x = \{v₀, v₁, ...\} | ft(vᵢ) = true; vᵢ ∈ x
*/ export function filter$(x, ft) {
for (const v of x)if (!ft(v, v, x)) x.delete(v);
return x;
}
/**
* Discard values which pass a test.
* @param x a set
* @param ft test function (v, v, x)
* @returns \{v₀, v₁, ...\} | ft(vᵢ) = false; vᵢ ∈ x
*/ export function reject(x, ft) {
const a = new Set();
for (const v of x)if (!ft(v, v, x)) a.add(v);
return a;
}
/**
* Discard values which pass a test.
* @param x a set (updated)
* @param ft test function (v, v, x)
* @returns x = \{v₀, v₁, ...\} | ft(vᵢ) = false; vᵢ ∈ x
*/ export function reject$(x, ft) {
for (const v of x)if (ft(v, v, x)) x.delete(v);
return x;
}
/**
* Flatten nested set to given depth.
* @param x a nested set
* @param n maximum depth [-1 ⇒ all]
* @param fm map function (v, v, x)
* @param ft flatten test function (v, v, x) [is]
* @returns flat set
*/ export function flat(x, n = -1, fm = null, ft = null) {
fm = fm || IDENTITY;
ft = ft || is;
return flatTo$(new Set(), x, n, fm, ft);
}
function flatTo$(a, x, n, fm, ft) {
for (const v of x){
const v1 = fm(v, v, x);
if (n !== 0 && ft(v1, v1, x)) flatTo$(a, v1, n - 1, fm, ft);
else a.add(v1);
}
return a;
}
/**
* Flatten nested set, based on map function.
* @param x a nested set
* @param fm map function (v, v, x)
* @param ft flatten test function (v, v, x) [is]
* @returns flat set
*/ export function flatMap(x, fm = null, ft = null) {
fm = fm || IDENTITY;
ft = ft || is;
const a = new Set();
for (const v of x){
const w = fm(v, v, x);
if (ft(w, w, x)) concat$(a, w);
else a.add(w);
}
return a;
}
// MANIPULATION
// ------------
/**
* Segregate values by test result.
* @param x a set
* @param ft test function (v, v, x)
* @returns [satisfies, doesnt]
*/ export function partition(x, ft) {
const t = new Set();
const f = new Set();
for (const v of x){
if (ft(v, v, x)) t.add(v);
else f.add(v);
}
return [
t,
f
];
}
/**
* Segregates values by similarity.
* @param x a set
* @param fm map function (v, v, x)
* @returns Map \{key ⇒ values\}
*/ export function partitionAs(x, fm) {
fm = fm || IDENTITY;
const a = new Map();
for (const v of x){
const v1 = fm(v, v, x);
if (!a.has(v1)) a.set(v1, new Set());
a.get(v1).add(v);
}
return a;
}
/**
* Break set into chunks of given size.
* @param x a set
* @param n chunk size [1]
* @param s chunk step [n]
* @returns [x[0..n], x[s..s+n], x[2s..2s+n], ...]
*/ export function chunk(x, n = 1, s = n) {
return arrayChunk([
...x
], n, s).map((c)=>new Set(c));
}
// COMBINE
// -------
/**
* Append values from sets.
* @param xs sets
* @returns x₀ ∪ x₁ ∪ ... | [x₀, x₁, ...] = xs
*/ export function concat(...xs) {
return concat$(new Set(), ...xs);
}
/**
* Append values from sets.
* @param x a set (updated)
* @param ys other sets
* @returns x = x ∪ y₀ ∪ y₁ ∪ ... | [y₀, y₁, ...] = ys
*/ export function concat$(x, ...ys) {
for (const y of ys){
for (const v of y)x.add(v);
}
return x;
}
/**
* Join values together into a string.
* @param x a set
* @param sep separator [,]
* @returns "$\{v₀\}$\{sep\}$\{v₁\}..." | vᵢ ∈ x
*/ export function join(x, sep = ",") {
return [
...x
].join(sep);
}
// SET OPERATIONS
// --------------
/**
* Check if sets have no value in common.
* @param x a set
* @param y another set
* @returns x ∩ y = Φ?
*/ export function isDisjoint(x, y) {
for (const v of y)if (x.has(v)) return false;
return true;
}
/**
* Obtain values present in any set.
* @param x a set
* @param y another set
* @returns x ∪ y = \{v | v ∈ x or v ∈ y\}
*/ export function union(x, y) {
return concat$(new Set(), x, y);
}
/**
* Obtain values present in any set.
* @param x a set (updated)
* @param y another set
* @returns x = x ∪ y = \{v | v ∈ x or v ∈ y\}
*/ export function union$(x, y) {
return concat$(x, y);
}
/**
* Obtain values present in both sets.
* @param x a set
* @param y another set
* @returns x ∩ y = \{v | v ∈ x, v ∈ y\}
*/ export function intersection(x, y) {
const a = new Set();
for (const v of y)if (x.has(v)) a.add(v);
return a;
}
/**
* Obtain values present in both sets.
* @param x a set (updated)
* @param y another set
* @returns x = x ∩ y = \{v | v ∈ x, v ∈ y\}
*/ export function intersection$(x, y) {
for (const v of x)if (!y.has(v)) x.delete(v);
return x;
}
/**
* Obtain values not present in another set.
* @param x a set
* @param y another set
* @returns x - y = \{v | v ∈ x, v ∉ y\}
*/ export function difference(x, y) {
const a = new Set();
for (const v of x)if (!y.has(v)) a.add(v);
return a;
}
/**
* Obtain values not present in another set.
* @param x a set (updated)
* @param y another set
* @returns x = x - y = \{v | v ∈ x, v ∉ y\}
*/ export function difference$(x, y) {
for (const v of y)x.delete(v);
return x;
}
/**
* Obtain values not present in both sets.
* @param x a set
* @param y another set
* @returns x-y ∪ y-x
*/ export function symmetricDifference(x, y) {
const a = new Set();
for (const v of x)if (!y.has(v)) a.add(v);
for (const v of y)if (!x.has(v)) a.add(v);
return a;
}
/**
* Obtain values not present in both sets.
* @param x a set (updated)
* @param y another set
* @returns x = x-y ∪ y-x
*/ export function symmetricDifference$(x, y) {
for (const v of y){
if (x.has(v)) x.delete(v);
else x.add(v);
}
return x;
}
/**
* List cartesian product of sets.
* @param xs sets
* @param fm map function (vs, vs)
* @returns x₀ × x₁ × ... = \{\{v₀, v₁, ...\} | v₀ ∈ x₀, v₁ ∈ x₁, ...]\}
*/ export function* cartesianProduct(xs, fm = null) {
fm = fm || IDENTITY;
const XS = xs.length;
const ys = xs.map((x)=>[
...x
]);
const ls = ys.map((vs)=>vs.length);
const is = ys.map((_vs)=>0);
while(true){
const a = new Set();
for(let n = 0; n < XS; ++n){
const i = is[n];
const vs = ys[n], v = vs[i];
a.add(v);
}
yield fm(a, a, null);
let r = XS - 1;
for(; r >= 0; --r){
if (++is[r] < ls[r]) break;
is[r] = 0;
}
if (r < 0) break;
}
}
export default cartesianProduct;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/extra-set/extra-set/index.ts"],"sourcesContent":["import {\n  IDENTITY,\n  COMPARE,\n} from \"@nodef/extra-function\";\nimport {\n  chunk             as arrayChunk,\n  subsequences      as arraySubsequences,\n  randomValue       as arrayRandomValue,\n  randomSubsequence as arrayRandomSubsequence,\n} from \"@nodef/extra-array\";\nimport type {\n  MapFunction as IterableMapFunction,\n} from \"@nodef/extra-iterable\";\n\n\n\n// TYPES\n// =====\n\n/**\n * Handle reading of a single value.\n * @returns value\n */\nexport type ReadFunction<T> = () => T;\n\n\n/**\n * Handle combining of two values.\n * @param a a value\n * @param b another value\n * @returns combined value\n */\nexport type CombineFunction<T> = (a: T, b: T) => T;\n\n\n/**\n * Handle comparison of two values.\n * @param a a value\n * @param b another value\n * @returns a<b: -ve, a=b: 0, a>b: +ve\n */\nexport type CompareFunction<T> = (a: T, b: T) => number;\n\n\n/**\n * Handle processing of values in a set.\n * @param v value in set\n * @param k key of value in set (= value)\n * @param x set containing the value\n */\nexport type ProcessFunction<T> = (v: T, k: T, x: Set<T>) => void;\n\n\n/**\n * Handle selection of values in a set.\n * @param v value in set\n * @param k key of value in set (= value)\n * @param x set containing the value\n * @returns selected?\n */\nexport type TestFunction<T> = (v: T, k: T, x: Set<T>) => boolean;\n\n\n/**\n * Handle transformation of a value to another.\n * @param v value in set\n * @param k key of value in set (= value)\n * @param x set containing the value\n * @returns transformed value\n */\nexport type MapFunction<T, U> = (v: T, k: T, x: Set<T> | null) => U;\n\n\n/**\n * Handle reduction of multiple values into a single value.\n * @param acc accumulator (temporary result)\n * @param v value in set\n * @param k key of value in set (= value)\n * @param x set containing the value\n * @returns reduced value\n */\nexport type ReduceFunction<T, U> = (acc: U, v: T, k: T, x: Set<T>) => U;\n\n\n/**\n * Handle ending of a combined set.\n * @param dones iᵗʰ set done?\n * @returns combined set done?\n */\nexport type EndFunction = (dones: boolean[]) => boolean;\n\n\n\n\n// METHODS\n// =======\n\n// ABOUT\n// -----\n\n/**\n * Check if value is a set.\n * @param v a value\n * @returns v is a set?\n */\nexport function is(v: unknown): v is Set<unknown> {\n  return v instanceof Set;\n}\n\n\n/**\n * List all values.\n * @param x a set\n * @returns v₀, v₁, ... | vᵢ ∈ x\n */\nexport function values<T>(x: Set<T>): IterableIterator<T> {\n  return x.values();\n}\nexport {values as keys};\n\n\n/**\n * List all value-value pairs.\n * @param x a set\n * @returns [v₀, v₀], [v₁, v₁], ... | vᵢ ∈ x\n */\nexport function entries<T>(x: Set<T>): IterableIterator<[T, T]> {\n  return x.entries();\n}\n\n\n\n\n// GENERATE\n// --------\n\n/**\n * Convert an iterable to set.\n * @param x an iterable\n * @param fm map function (v, i, x)\n * @returns x as set\n */\nexport function from<T, U=T>(x: Iterable<T>, fm: IterableMapFunction<T, U> | null=null): Set<T|U> {\n  if (!fm) return new Set(x);\n  const a = new Set<U>(); let i = -1;\n  for (const v of x)\n    a.add(fm(v, ++i, x));\n  return a;\n}\n\n\n/**\n * Convert an iterable to set.\n * @param x an iterable (updatable if set!)\n * @returns x as set\n */\nexport function from$<T>(x: Iterable<T>): Set<T> {\n  return x instanceof Set? x : new Set(x);\n}\n\n\n\n\n// COMPARE\n// -------\n\n/**\n * Compare two sets.\n * @param x a set\n * @param y another set\n * @returns x=y: 0, otherwise: -ve/+ve\n */\nexport function compare<T>(x: Set<T>, y: Set<T>): number {\n  for (const v of x)\n    if (!y.has(v)) return 1;\n  for (const v of y)\n    if (!x.has(v)) return -1;\n  return 0;\n}\n\n\n/**\n * Check if two sets are equal.\n * @param x a set\n * @param y another set\n * @returns x = y?\n */\nexport function isEqual<T>(x: Set<T>, y: Set<T>): boolean {\n  return x.size===y.size && compare(x, y)===0;\n}\n\n\n\n\n// SIZE\n// ----\n\n/**\n * Find the size of a set.\n * @param x a set\n * @returns |x|\n */\nexport function size<T>(x: Set<T>): number {\n  return x.size;\n}\nexport {size as length};\n\n\n/**\n * Check if a set is empty.\n * @param x a set\n * @returns |x| = 0?\n */\nexport function isEmpty<T>(x: Set<T>): boolean {\n  return x.size===0;\n}\n\n\n\n\n// ADD/REMOVE\n// ----------\n\n/**\n * Add a value to set.\n * @param x a set\n * @param v value\n * @returns x ∪ \\{v\\}\n */\nexport function add<T>(x: Set<T>, v: T): Set<T> {\n  return new Set(x).add(v);\n}\n\n\n/**\n * Add a value to set.\n * @param x a set (updated)\n * @param v value\n * @returns x = x ∪ \\{v\\}\n */\nexport function add$<T>(x: Set<T>, v: T): Set<T> {\n  return x.add(v);\n}\n\n\n/**\n * Delete a value from set.\n * @param x a set\n * @param v value\n * @returns x \\\\ \\{v\\}\n */\nexport function remove<T>(x: Set<T>, v: T): Set<T> {\n  return remove$(new Set(x), v);\n}\n\n\n/**\n * Delete a value from set.\n * @param x a set (updated)\n * @param v value\n * @returns x = x \\\\ \\{v\\}\n */\nexport function remove$<T>(x: Set<T>, v: T): Set<T> {\n  x.delete(v);\n  return x;\n}\n\n\n\n\n// PROPERTY\n// --------\n\n/**\n * Count values which satisfy a test.\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x\n */\nexport function count<T>(x: Set<T>, ft: TestFunction<T>): number {\n  let a = 0;\n  for (const v of x)\n    if (ft(v, v, x)) ++a;\n  return a;\n}\n\n\n/**\n * Count occurrences of values.\n * @param x a set\n * @param fm map function (v, v, x)\n * @returns Map \\{value ⇒ count\\}\n */\nexport function countAs<T, U=T>(x: Set<T>, fm: MapFunction<T, T|U>): Map<T|U, number> {\n  fm = fm || IDENTITY;\n  const a  = new Map();\n  for (const v of x) {\n    const w = fm(v, v, x);\n    const n = a.get(w) || 0;\n    a.set(w, n+1);\n  }\n  return a;\n}\n\n\n/**\n * Find smallest value.\n * @param x a set\n * @param fc compare function (a, b)\n * @param fm map function (v, v, x)\n * @returns v | v ≤ vᵢ; vᵢ ∈ x\n */\nexport function min<T, U=T>(x: Set<T>, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T | undefined {\n  return range(x, fc, fm)[0];\n}\n\n\n/**\n * Find largest value.\n * @param x a set\n * @param fc compare function (a, b)\n * @param fm map function (v, v, x)\n * @returns v | v ≥ vᵢ; vᵢ ∈ x\n */\nexport function max<T, U=T>(x: Set<T>, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T | undefined {\n  return range(x, fc, fm)[1];\n}\n\n\n/**\n * Find smallest and largest entries.\n * @param x a set\n * @param fc compare function (a, b)\n * @param fm map function (v, v, x)\n * @returns [min_value, max_value]\n */\nexport function range<T, U=T>(x: Set<T>, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): [T | undefined, T | undefined] {\n  fc = fc || COMPARE;\n  fm = fm || IDENTITY;\n  let mu: T | undefined, mv: T|U | undefined;\n  let nu: T | undefined, nv: T|U | undefined;\n  let i = 0;\n  for (const u of x) {\n    const v = fm(u, u, x);\n    if(i===0 || fc(v, mv as T|U)<0) { mu = u; mv = v; }\n    if(i===0 || fc(v, nv as T|U)>0) { nu = u; nv = v; }\n    i++;\n  }\n  return [mu, nu];\n}\n\n\n\n\n// PART\n// ----\n\n/**\n * Get first value from set (default order).\n * @param x a set\n * @param vd default value\n * @returns v₀ if x ≠ Φ else vd | v₀ ∈ x\n */\nexport function head<T>(x: Set<T>, vd?: T): T | undefined {\n  for (const v of x)\n    return v;\n  return vd;\n}\n\n\n/**\n * Get a set without its first value (default order).\n * @param x a set\n * @returns x \\\\ \\{v₀\\} if x ≠ Φ else x | v₀ ∈ x\n */\nexport function tail<T>(x: Set<T>): Set<T> {\n  return drop(x, 1);\n}\n\n\n/**\n * Keep first n values only (default order).\n * @param x a set\n * @param n number of values [1]\n * @returns \\{v₀, v₁, ...\\} | vᵢ ∈ x and |\\{v₀, v₁, ...\\}| ≤ n\n */\nexport function take<T>(x: Iterable<T>, n: number=1): Set<T> {\n  const a = new Set<T>(); let i = -1;\n  for (const v of x) {\n    if (++i>=n) break;\n    a.add(v);\n  }\n  return a;\n}\n\n\n/**\n * Keep first n values only (default order).\n * @param x a set (updated)\n * @param n number of values [1]\n * @returns x = \\{v₀, v₁, ...\\} | vᵢ ∈ x and |\\{v₀, v₁, ...\\}| ≤ n\n */\nexport function take$<T>(x: Set<T>, n: number=1): Set<T> {\n  let i = -1;\n  for (const v of x)\n    if (++i>=n) x.delete(v);\n  return x;\n}\n\n\n/**\n * Remove first n values (default order).\n * @param x a set\n * @param n number of values [1]\n * @returns \\{vₙ, vₙ₊₁, ...\\} | vᵢ ∈ x and |\\{vₙ, vₙ₊₁, ...\\}| ≤ max(|x| - n, 0)\n */\nexport function drop<T>(x: Set<T>, n: number=1): Set<T> {\n  const a = new Set<T>(); let i = -1;\n  for (const v of x)\n    if (++i>=n) a.add(v);\n  return a;\n}\n\n\n/**\n * Remove first n values (default order).\n * @param x a set (updated)\n * @param n number of values [1]\n * @returns x = \\{vₙ, vₙ₊₁, ...\\} | vᵢ ∈ x and |\\{vₙ, vₙ₊₁, ...\\}| ≤ max(|x| - n, 0)\n */\nexport function drop$<T>(x: Set<T>, n: number=1): Set<T> {\n  let i = -1;\n  for (const v of x) {\n    if (++i>=n) break;\n    x.delete(v);\n  }\n  return x;\n}\n\n\n\n\n// ARRANGEMENTS\n// ------------\n\n/**\n * List all possible subsets.\n * @param x a set\n * @param n number of values [-1 ⇒ any]\n * @returns elements selected by bit from 0..2^|x| if n<0; only of length n otherwise\n */\nexport function* subsets<T>(x: Set<T>, n: number=-1): IterableIterator<Set<T>> {\n  for (const vs of arraySubsequences([...x], n))\n    yield new Set(vs);\n}\n\n\n/**\n * Pick an arbitrary value.\n * @param x a set\n * @param fr random number generator ([0, 1))\n * @returns vᵢ | vᵢ ∈ x\n */\nexport function randomValue<T>(x: Set<T>, fr: ReadFunction<number>=Math.random): T {\n  return arrayRandomValue([...x], fr);\n}\nexport {randomValue as randomKey};\nexport {randomValue as value};\nexport {randomValue as key};\n\n\n/**\n * Pick an arbitrary entry.\n * @param x a set\n * @param fr random number generator ([0, 1))\n * @returns [vᵢ, vᵢ] | vᵢ ∈ x\n */\nexport function randomEntry<T>(x: Set<T>, fr: ReadFunction<number>=Math.random): [T, T] {\n  return arrayRandomValue([...x.entries()], fr);\n}\nexport {randomEntry as entry};\n\n\n/**\n * Pick an arbitrary subset.\n * @param x a set\n * @param n number of values [-1 ⇒ any]\n * @param fr random number generator ([0, 1))\n * @returns \\{vᵢ, vⱼ, ...\\} | vᵢ, vⱼ, ... ∈ x; |\\{vᵢ, vⱼ, ...\\}| = |x| if n<0 else n\n */\nexport function randomSubset<T>(x: Set<T>, n: number=-1, fr: ReadFunction<number>=Math.random): Set<T> {\n  const vs = arrayRandomSubsequence([...x], n, fr);\n  return new Set(vs);\n}\n\n\n/**\n * Checks if set has a subset.\n * @param x a set\n * @param y search subset\n * @returns y ⊆ x?\n */\nexport function hasSubset<T>(x: Set<T>, y: Set<T>): boolean {\n  for (const v of y)\n    if (!x.has(v)) return false;\n  return true;\n}\n\n\n\n\n// FIND\n// ----\n\n/**\n * Check if set has a value.\n * @param x a set\n * @param v search value\n * @returns v ∈ x?\n */\nexport function has<T>(x: Set<T>, v: T): boolean {\n  return x.has(v);\n}\n\n\n/**\n * Find first value passing a test (default order).\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns first v | ft(v) = true; v ∈ x\n */\nexport function find<T>(x: Set<T>, ft: TestFunction<T>): T | undefined {\n  for (const v of x)\n    if (ft(v, v, x)) return v;\n}\nexport {find as search};\n\n\n/**\n * Find all values passing a test.\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x\n */\nexport function findAll<T>(x: Set<T>, ft: TestFunction<T>): T[] {\n  const a = [];\n  for (const v of x)\n    if (ft(v, v, x)) a.push(v);\n  return a;\n}\nexport {findAll as searchAll};\n\n\n\n\n// FUNCTIONAL\n// ----------\n\n/**\n * Call a function for each value.\n * @param x a set\n * @param fp process function (v, v, x)\n */\nexport function forEach<T>(x: Set<T>, fp: ProcessFunction<T>): void {\n  for (const v of x)\n    fp(v, v, x);\n}\n\n\n/**\n * Check if any value satisfies a test.\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns true if ft(vᵢ) = true for some vᵢ ∈ x\n */\nexport function some<T>(x: Set<T>, ft: TestFunction<T> | null=null): boolean {\n  ft = ft || IDENTITY as TestFunction<T>;\n  for (const v of x)\n    if (ft(v, v, x)) return true;\n  return false;\n}\n\n\n/**\n * Check if all values satisfy a test.\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns true if ft(vᵢ) = true for all vᵢ ∈ x\n */\nexport function every<T>(x: Set<T>, ft: TestFunction<T> | null=null): boolean {\n  ft = ft || IDENTITY as TestFunction<T>;\n  for (const v of x)\n    if (!ft(v, v, x)) return false;\n  return true;\n}\n\n\n/**\n * Transform values of a set.\n * @param x a set\n * @param fm map function (v, v, x)\n * @returns \\{fm(v₀), fm(v₁), ...\\} | vᵢ ∈ x\n */\nexport function map<T, U=T>(x: Set<T>, fm: MapFunction<T, T|U>): Set<T|U> {\n  const a = new Set<T|U>();\n  for (const v of x)\n    a.add(fm(v, v, x));\n  return a;\n}\n\n\n/**\n * Transform values of a set.\n * @param x a set (updated)\n * @param fm map function (v, v, x)\n * @returns x = \\{fm(v₀), fm(v₁), ...\\} | vᵢ ∈ x\n */\nexport function map$<T>(x: Set<T>, fm: MapFunction<T, T>): Set<T> {\n  const vs: T[] = [];\n  for (const v of x)\n    vs.push(fm(v, v, x));\n  x.clear();\n  return concat$(x, vs);\n}\n\n\n/**\n * Reduce values of set to a single value.\n * @param x a set\n * @param fr reduce function (acc, v, v, x)\n * @param acc initial value\n * @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given\n */\nexport function reduce<T, U=T>(x: Set<T>, fr: ReduceFunction<T, T|U>, acc?: T|U): T|U {\n  let init = arguments.length <= 2;\n  for (const v of x) {\n    if (init) { acc = v; init = false; }\n    else acc = fr(acc as T|U, v, v, x);\n  }\n  return acc as T|U;\n}\n\n\n/**\n * Keep values which pass a test.\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns \\{v₀, v₁, ...\\} | ft(vᵢ) = true; vᵢ ∈ x\n */\nexport function filter<T>(x: Set<T>, ft: TestFunction<T>): Set<T> {\n  const a = new Set<T>();\n  for (const v of x)\n    if (ft(v, v, x)) a.add(v);\n  return a;\n}\n\n\n/**\n * Keep values which pass a test.\n * @param x a set (updated)\n * @param ft test function (v, v, x)\n * @returns x = \\{v₀, v₁, ...\\} | ft(vᵢ) = true; vᵢ ∈ x\n */\nexport function filter$<T>(x: Set<T>, ft: TestFunction<T>): Set<T> {\n  for (const v of x)\n    if (!ft(v, v, x)) x.delete(v);\n  return x;\n}\n\n\n/**\n * Discard values which pass a test.\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns \\{v₀, v₁, ...\\} | ft(vᵢ) = false; vᵢ ∈ x\n */\nexport function reject<T>(x: Set<T>, ft: TestFunction<T>): Set<T> {\n  const a = new Set<T>();\n  for (const v of x)\n    if (!ft(v, v, x)) a.add(v);\n  return a;\n}\n\n\n/**\n * Discard values which pass a test.\n * @param x a set (updated)\n * @param ft test function (v, v, x)\n * @returns x = \\{v₀, v₁, ...\\} | ft(vᵢ) = false; vᵢ ∈ x\n */\nexport function reject$<T>(x: Set<T>, ft: TestFunction<T>): Set<T> {\n  for (const v of x)\n    if (ft(v, v, x)) x.delete(v);\n  return x;\n}\n\n\n/**\n * Flatten nested set to given depth.\n * @param x a nested set\n * @param n maximum depth [-1 ⇒ all]\n * @param fm map function (v, v, x)\n * @param ft flatten test function (v, v, x) [is]\n * @returns flat set\n */\nexport function flat<T=unknown>(x: Set<T>, n: number=-1, fm: MapFunction<T, unknown> | null=null, ft: TestFunction<T> | null=null): Set<unknown> {\n  fm = fm || IDENTITY;\n  ft = ft || is;\n  return flatTo$(new Set(), x, n, fm, ft);\n}\n\nfunction flatTo$<T=unknown>(a: Set<unknown>, x: Set<T>, n: number, fm: MapFunction<T, unknown>, ft: TestFunction<T>): Set<unknown> {\n  for (const v of x) {\n    const v1 = fm(v, v, x);\n    if (n!==0 && ft(v1 as T, v1 as T, x)) flatTo$(a, v1 as Set<T>, n-1, fm, ft);\n    else a.add(v1);\n  }\n  return a;\n}\n\n\n/**\n * Flatten nested set, based on map function.\n * @param x a nested set\n * @param fm map function (v, v, x)\n * @param ft flatten test function (v, v, x) [is]\n * @returns flat set\n */\nexport function flatMap<T=unknown>(x: Set<T>, fm: MapFunction<T, unknown> | null=null, ft: TestFunction<T> | null=null): Set<unknown> {\n  fm = fm || IDENTITY;\n  ft = ft || is;\n  const a  = new Set();\n  for (const v of x) {\n    const w = fm(v, v, x);\n    if (ft(w as T, w as T, x)) concat$(a, w as Set<unknown>);\n    else a.add(w);\n  }\n  return a;\n}\n\n\n\n\n// MANIPULATION\n// ------------\n\n/**\n * Segregate values by test result.\n * @param x a set\n * @param ft test function (v, v, x)\n * @returns [satisfies, doesnt]\n */\nexport function partition<T>(x: Set<T>, ft: TestFunction<T>): [Set<T>, Set<T>] {\n  const t = new Set<T>();\n  const f = new Set<T>();\n  for (const v of x) {\n    if (ft(v, v, x)) t.add(v);\n    else f.add(v);\n  }\n  return [t, f];\n}\n\n\n/**\n * Segregates values by similarity.\n * @param x a set\n * @param fm map function (v, v, x)\n * @returns Map \\{key ⇒ values\\}\n */\nexport function partitionAs<T, U=T>(x: Set<T>, fm: MapFunction<T, T|U>): Map<T|U, Set<T>> {\n  fm = fm || IDENTITY;\n  const a = new Map();\n  for (const v of x) {\n    const v1 = fm(v, v, x);\n    if (!a.has(v1)) a.set(v1, new Set());\n    a.get(v1).add(v);\n  }\n  return a;\n}\n\n\n/**\n * Break set into chunks of given size.\n * @param x a set\n * @param n chunk size [1]\n * @param s chunk step [n]\n * @returns [x[0..n], x[s..s+n], x[2s..2s+n], ...]\n */\nexport function chunk<T>(x: Set<T>, n: number=1, s: number=n): Set<T>[] {\n  return arrayChunk([...x], n ,s).map(c => new Set(c));\n}\n\n\n\n\n// COMBINE\n// -------\n\n/**\n * Append values from sets.\n * @param xs sets\n * @returns x₀ ∪ x₁ ∪ ... | [x₀, x₁, ...] = xs\n */\nexport function concat<T>(...xs: Set<T>[]): Set<T> {\n  return concat$(new Set(), ...xs);\n}\n\n\n/**\n * Append values from sets.\n * @param x a set (updated)\n * @param ys other sets\n * @returns x = x ∪ y₀ ∪ y₁ ∪ ... | [y₀, y₁, ...] = ys\n */\nexport function concat$<T>(x: Set<T>, ...ys: Iterable<T>[]): Set<T> {\n  for (const y of ys) {\n    for (const v of y)\n      x.add(v);\n  }\n  return x;\n}\n\n\n/**\n * Join values together into a string.\n * @param x a set\n * @param sep separator [,]\n * @returns \"$\\{v₀\\}$\\{sep\\}$\\{v₁\\}...\" | vᵢ ∈ x\n */\nexport function join<T>(x: Set<T>, sep: string=\",\"): string {\n  return [...x].join(sep);\n}\n\n\n\n\n// SET OPERATIONS\n// --------------\n\n/**\n * Check if sets have no value in common.\n * @param x a set\n * @param y another set\n * @returns x ∩ y = Φ?\n */\nexport function isDisjoint<T>(x: Set<T>, y: Iterable<T>): boolean {\n  for (const v of y)\n    if (x.has(v)) return false;\n  return true;\n}\n\n\n/**\n * Obtain values present in any set.\n * @param x a set\n * @param y another set\n * @returns x ∪ y = \\{v | v ∈ x or v ∈ y\\}\n */\nexport function union<T>(x: Iterable<T>, y: Iterable<T>): Set<T> {\n  return concat$(new Set(), x, y);\n}\n\n\n/**\n * Obtain values present in any set.\n * @param x a set (updated)\n * @param y another set\n * @returns x = x ∪ y = \\{v | v ∈ x or v ∈ y\\}\n */\nexport function union$<T>(x: Set<T>, y: Iterable<T>): Set<T> {\n  return concat$(x, y);\n}\n\n\n/**\n * Obtain values present in both sets.\n * @param x a set\n * @param y another set\n * @returns x ∩ y = \\{v | v ∈ x, v ∈ y\\}\n */\nexport function intersection<T>(x: Set<T>, y: Iterable<T>): Set<T> {\n  const a = new Set<T>();\n  for (const v of y)\n    if (x.has(v)) a.add(v);\n  return a;\n}\n\n\n/**\n * Obtain values present in both sets.\n * @param x a set (updated)\n * @param y another set\n * @returns x = x ∩ y = \\{v | v ∈ x, v ∈ y\\}\n */\nexport function intersection$<T>(x: Set<T>, y: Set<T>): Set<T> {\n  for (const v of x)\n    if (!y.has(v)) x.delete(v);\n  return x;\n}\n\n\n/**\n * Obtain values not present in another set.\n * @param x a set\n * @param y another set\n * @returns x - y = \\{v | v ∈ x, v ∉ y\\}\n */\nexport function difference<T>(x: Set<T>, y: Set<T>): Set<T> {\n  const a = new Set<T>();\n  for (const v of x)\n    if (!y.has(v)) a.add(v);\n  return a;\n}\n\n\n/**\n * Obtain values not present in another set.\n * @param x a set (updated)\n * @param y another set\n * @returns x = x - y = \\{v | v ∈ x, v ∉ y\\}\n */\nexport function difference$<T>(x: Set<T>, y: Iterable<T>): Set<T> {\n  for (const v of y)\n    x.delete(v);\n  return x;\n}\n\n\n/**\n * Obtain values not present in both sets.\n * @param x a set\n * @param y another set\n * @returns x-y ∪ y-x\n */\nexport function symmetricDifference<T>(x: Set<T>, y: Set<T>): Set<T> {\n  const a = new Set<T>();\n  for (const v of x)\n    if (!y.has(v)) a.add(v);\n  for (const v of y)\n    if (!x.has(v)) a.add(v);\n  return a;\n}\n\n\n/**\n * Obtain values not present in both sets.\n * @param x a set (updated)\n * @param y another set\n * @returns x = x-y ∪ y-x\n */\nexport function symmetricDifference$<T>(x: Set<T>, y: Iterable<T>): Set<T> {\n  for (const v of y) {\n    if (x.has(v)) x.delete(v);\n    else x.add(v);\n  }\n  return x;\n}\n\n\n/**\n * List cartesian product of sets.\n * @param xs sets\n * @param fm map function (vs, vs)\n * @returns x₀ × x₁ × ... = \\{\\{v₀, v₁, ...\\} | v₀ ∈ x₀, v₁ ∈ x₁, ...]\\}\n */\nexport function* cartesianProduct<T, U=Set<T>>(xs: Set<T>[], fm: MapFunction<Set<T>, Set<T>|U> | null=null): IterableIterator<Set<T>|U> {\n  fm = fm || IDENTITY;\n  const XS = xs.length;\n  const ys = xs.map(x => [...x]);\n  const ls = ys.map(vs => vs.length);\n  const is = ys.map(_vs => 0);\n  while (true) {\n    const a = new Set<T>();\n    for (let n=0; n<XS; ++n) {\n      const i  = is[n];\n      const vs = ys[n], v = vs[i];\n      a.add(v);\n    }\n    yield fm(a, a, null);\n    let r = XS-1;\n    for (; r>=0; --r) {\n      if (++is[r] < ls[r]) break;\n      is[r] = 0;\n    }\n    if (r<0) break;\n  }\n}\nexport default cartesianProduct;\n"],"names":[],"mappings":"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"}