I am a very very creative app but it seems to have work hard and it doesn't even open. (written using predictive text)
function getConjugacyClasses(arity) {
let seen = new BitSet(2 ** (2 ** arity));
let classes = [];
for (let code = 0; code < 2 ** (2 ** arity); code++) {
if (seen.has(code)) {
continue;
}
let cls = new Set([code]);
for (let invMap of _.range(2 ** arity)) {
let fn = withInvMap(arity, code, invMap);
for (let invFn of [fn, inverseFn(arity, fn)]) {
for (let perm of permutations(_.range(arity))) {
let permedFn = getPermed(arity, invFn, perm);
cls.add(permedFn);
seen.add(permedFn);
}
}
}
classes.push(cls);
}
return classes;
}
function* permutations(list) {
if (list.length === 0) {
} else if (list.length === 1) {
yield list;
} else {
for (let [index, item] of list.entries()) {
let copy = [...list];
copy.splice(index, 1);
for (let perm of permutations(copy)) {
yield [item, ...perm];
}
}
}
}
function* combinations(list, n) {
if (n === 0) {
yield [];
} else if (list.length === n) {
yield list;
} else {
let [head, ...tail] = list;
for (let item of combinations(tail, n - 1)) {
yield [head, ...item];
}
yield* combinations(tail, n);
}
}
[...combinationsWithRepeats([1, 2, 3, 4], 3)]
function* combinationsWithRepeats(list, n) {
if (n === 0) {
yield [];
} else if (list.length === 0) {
} else if (n === 1) {
yield* list.map((l) => [l]);
} else {
let [head, ...tail] = list;
for (let item of combinationsWithRepeats(list, n - 1)) {
yield [head, ...item];
}
yield* combinationsWithRepeats(tail, n);
}
}
function inverseFn(arity, code) {
return (~code % 2 ** (2 ** arity)) + 2 ** (2 ** arity);
}
// Get the code of the function represented by `code` but with the arguments
function withInvMap(arity, code, invMap) {
let newCode = 0;
for (let i of _.range(2 ** arity - 1, -1, -1)) {
newCode <<= 1;
let inverted = i ^ invMap;
newCode |= getIndex(code, inverted);
}
return newCode;
}
function getPermed(arity, code, perm) {
let newCode = 0;
for (let i of _.range(2 ** arity - 1, -1, -1)) {
newCode <<= 1;
let permed = permuteBits(arity, i, perm);
newCode |= getIndex(code, permed);
}
return newCode;
}
function permuteBits(arity, digits, permutation) {
let newBits = 0;
for (let i of _.range(arity)) {
newBits |= getIndex(digits, permutation[i]) << i;
}
return newBits;
}
function getIndex(code, index) {
return (code >> index) % 2;
}
class BitSet {
constructor(length) {
this.set = new Uint32Array(Math.floor(length / 32) + 1);
}
add(uint) {
let index = Math.floor(uint / 32);
let pos = uint % 32;
this.set[index] |= 1 << pos;
}
has(uint) {
let index = Math.floor(uint / 32);
let pos = uint % 32;
return !!((this.set[index] >> pos) % 2);
}
}
function getCode(arity, f) {
let code = 0;
for (let i = 0; i < 2 ** arity; i++) {
let args = _.range(arity).map((j) => getIndex(i, j));
code |= f(...args) << i;
}
return code;
}
trueFn = withFormat(
() => true,
() => "true"
)
falseFn = withFormat(
() => false,
() => "false"
)
idFn = withFormat(
(a) => a,
(a) => `${a}`
)
notFn = withFormat(
(a) => !a,
(a) => `!${a}`
)
andFn = withFormat(
(...args) => args.every((x) => x),
(...args) => args.join(" & ")
)
orFn = withFormat(
(...args) => args.some((x) => x),
(...args) => args.join(" | ")
)
xor2 = withFormat(
(a, b) => !!a !== !!b,
(a, b) => `${a} ^ ${b}`
)
eq2 = withFormat(
(a, b) => !!a === !!b,
(a, b) => `${a} = ${b}`
)
oddFn = withFormat(
(...args) => _.sum(args) % 2 === 1,
(...args) => args.join(" ^ ")
)
evenFn = withFormat(
(...args) => _.sum(args) % 2 === 0,
(...args) => `!(${args.join(" ^ ")})`
)
eqFn = withFormat(
(...args) => args.every((arg) => !!arg === !!args[0]),
(...args) => args.join(" == ")
)
neqFn = negateFn(eqFn)
function widen(fn, arity, indices) {
if (typeof indices === "number") {
indices = [indices];
}
return withFormat(
(...args) => fn(...getIndices(args, indices)),
(...args) => fn.format(...getIndices(args, indices))
);
}
function negateFn(fn) {
return withFormat(
(...args) => !fn(...args),
(...args) => `!(${fn.format(...args)})`
);
}
function permuteFn(fn, order) {
return withFormat(
(...args) => fn(...order.map((i) => args[i])),
(...args) => fn.format(...order.map((i) => args[i]))
);
}
function applyNegations(fn, code) {
return withFormat(
(...args) => fn(...args.map((arg, i) => (getIndex(code, i) ? !arg : arg))),
(...args) =>
fn.format(...args.map((arg, i) => (getIndex(code, i) ? `!${arg}` : arg)))
);
}
function getIndices(array, indices) {
return indices.map((i) => array[i]);
}
function withFormat(fn, format) {
fn.format = format;
return fn;
}
function countBits(bits) {
let sum = 0;
while (bits) {
sum += bits % 2;
bits >>= 1;
}
return sum;
}
Var = {
let result = (a) => a;
result.format = (a) => `${a}`;
result.arity = 1;
return result;
}
And = makeCombinationFunction((els) => els.every((x) => !!x), "&")
Or = makeCombinationFunction((els) => els.some((x) => !!x), "|")
Odd = makeCombinationFunction((els) => _.sum(els) % 2 === 1, "^")
Even = makeCombinationFunction((els) => _.sum(els) % 2 === 0, "_")
Xor = Odd
Eq = makeCombinationFunction((els) => els.every((el) => el == els[0]), "==")
Neq = makeCombinationFunction((els) => els.some((el) => el != els[0]), "!=")
function CountEq(...n) {
let nFormat = n.length === 1 ? `${n}` : `{${n.join(",")}}`;
return makeCombinationFunction(
(args) => n.some((i) => _.sum(args) === i),
(args) => `[${args.join(",")}] = ${nFormat}`
);
}
function CountNeq(...n) {
let nFormat = n.length === 1 ? `${n}` : `{${n.join(",")}}`;
return makeCombinationFunction(
(args) => n.every((i) => _.sum(args) !== i),
(args) => `[${args.join(",")}] != ${nFormat}`
);
}
function CountGeq(n) {
return makeCombinationFunction(
(args) => _.sum(args) >= n,
(args) => `[${args.join(",")}] >= ${n}`
);
}
function CountLeq(n) {
return makeCombinationFunction(
(args) => _.sum(args) <= n,
(args) => `[${args.join(",")}] <= ${n}`
);
}
function makeCombinationFunction(combiner, format) {
let formatFn =
typeof format === "string"
? (subFormats) => subFormats.join(` ${format} `)
: format;
function Combiner(...subFns) {
let arities = subFns.map((fn) => fn.arity);
// apply each of the sub functions to the appropriate number of arguments
// and then pass the result to the combiner
let fn = (...args) => {
let chunked = chunkArray(args, arities);
return combiner(subFns.map((fn, i) => fn(...chunked[i])));
};
fn.format = (...args) => {
let chunked = chunkArray(args, arities);
return formatFn(
subFns.map((fn, i) => {
let base = fn.format(...chunked[i]);
if (fn.wrapParen) {
base = `(${base})`;
}
return base;
})
);
};
fn.arity = _.sum(arities);
fn.wrapParen = true;
return fn;
}
return Combiner;
}
function makeNegated(Base) {
function Negated(...args) {
let orig = Base(...args);
let fn = (...args) => !orig(...args);
fn.format = (...args) =>
orig.wrapParen
? `!(${orig.format(...args)})`
: `!${orig.format(...args)}`;
fn.arity = orig.arity;
return fn;
}
return Negated;
}
function chunkArray(array, segments) {
if (array.length !== _.sum(segments)) {
throw new Error(
`Expected ${_.sum(segments)} elements but got ${array.length}`
);
}
let result = [];
for (let index of segments) {
let [head, tail] = splitAt(array, index);
result.push(head);
array = tail;
}
return result;
}
function splitAt(list, index) {
return [list.slice(0, index), list.slice(index, list.length)];
}
function* cycle(list) {
for (let i = 0; i < list.length; i++) {
let head = list.slice(0, i);
let tail = list.slice(i);
yield [...tail, ...head];
}
}
n-ary fill functions
function populateNullary(setAsRepr, setList) {
setAsRepr(trueFn);
setList(trueFn);
setList(falseFn);
}
function populateUnary(setAsRepr, setList, arity) {
setAsRepr(idFn);
for (let i = 0; i < arity; i++) {
setList(widen(idFn, arity, i));
setList(widen(notFn, arity, i));
}
}
function fillBinary(setList) {
setList(xor2);
setList(eq2);
for (let inv of _.range(2 ** 2)) {
setList(applyNegations(andFn, inv));
setList(applyNegations(orFn, inv));
}
}
function setRepsBinary(setAsRepr) {
setAsRepr(andFn);
setAsRepr(xor2);
}
function getWidenedFn(setRepsFn, fillFn, origArity) {
return (setAsRepr, setList, arity) => {
setRepsFn((fn) => {
setAsRepr(widen(fn, arity, _.range(origArity)));
});
for (let idxCombo of combinations(_.range(arity), origArity)) {
fillFn((fn) => {
setList(widen(fn, arity, idxCombo));
});
}
};
}
populateBinary = getWidenedFn(setRepsBinary, fillBinary, 2)
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
