binary-decision-diagram 4.0.0 → 5.0.0

package/dist/cjs/src/ordering/ordering-evaluator.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderingEvaluator = exports.OrderingCursor = exports.COST_EPSILON = void 0;
+exports.costTolerance = costTolerance;
+exports.costUnit = costUnit;
+const dense_truth_table_js_1 = require("./dense-truth-table.js");
+/**
+ * relative tolerance for comparing expected costs
+ */
+exports.COST_EPSILON = 1e-9;
+/**
+ * Two costs closer than this are treated as equal. The tolerance is relative
+ * to the larger of the value and the cost of one call of the most expensive
+ * boolean function (`unit`), so it does not depend on the unit the
+ * functionCosts are given in (milliseconds, seconds, ...).
+ */
+function costTolerance(value, unit) {
+    return exports.COST_EPSILON * Math.max(unit, Math.abs(value));
+}
+/**
+ * The cost of one call of the most expensive boolean function,
+ * the unit of costTolerance() for expected costs.
+ */
+function costUnit(costModel) {
+    let unit = 0;
+    for (let v = 0; v < costModel.functionCosts.length; v++) {
+        unit = Math.max(unit, costModel.functionCosts[v]);
+    }
+    return unit;
+}
+/**
+ * An ordering together with the intermediate results of its evaluation.
+ *
+ * levelIds[L] holds the ids of the 2^L blocks of level L (levelIds[n] are the
+ * rows of the truth table). Because blocks are indexed by the natural
+ * assignment to the functions above their level, swapping the functions of two
+ * levels keeps all levels below the lower one valid, only the levels from the
+ * lower one up to the root are recomputed.
+ */
+class OrderingCursor {
+    evaluator;
+    record;
+    ordering;
+    evaluation;
+    /** id of the root block, a terminal when the function is constant */
+    root = 0;
+    n;
+    levelIds = [];
+    levelWeights;
+    created;
+    payingWeights;
+    constructor(evaluator, ordering, record = null) {
+        this.evaluator = evaluator;
+        this.record = record;
+        this.n = evaluator.variableCount;
+        (0, dense_truth_table_js_1.ensureValidOrdering)(ordering, this.n);
+        this.ordering = Array.from(ordering);
+        for (let level = 0; level < this.n; level++) {
+            this.levelIds.push(new Int32Array(1 << level));
+        }
+        this.levelIds.push(evaluator.table.terminalIds);
+        if (evaluator.costModel) {
+            this.levelWeights = [];
+            for (let level = 0; level < this.n; level++) {
+                this.levelWeights.push(new Float64Array(1 << level));
+            }
+            this.levelWeights.push(evaluator.costModel.rowWeights);
+        }
+        else {
+            this.levelWeights = null;
+        }
+        this.created = new Array(this.n).fill(0);
+        this.payingWeights = new Array(this.n).fill(0);
+        this.evaluation = this.recomputeFrom(this.n - 1);
+    }
+    /**
+     * Starts over with another ordering.
+     */
+    reset(ordering) {
+        (0, dense_truth_table_js_1.ensureValidOrdering)(ordering, this.n);
+        for (let i = 0; i < this.n; i++) {
+            this.ordering[i] = ordering[i];
+        }
+        this.evaluation = this.recomputeFrom(this.n - 1);
+    }
+    /**
+     * Swaps the boolean functions of two levels and updates the evaluation.
+     */
+    swap(levelA, levelB) {
+        if (levelA === levelB) {
+            return;
+        }
+        const tmp = this.ordering[levelA];
+        this.ordering[levelA] = this.ordering[levelB];
+        this.ordering[levelB] = tmp;
+        this.evaluation = this.recomputeFrom(Math.max(levelA, levelB));
+    }
+    /**
+     * recomputes the levels top .. 0 (the levels below stay as they are)
+     */
+    recomputeFrom(top) {
+        this.evaluator.evaluations++;
+        const n = this.n;
+        const terminalCount = this.evaluator.terminalCount;
+        // ids used by the levels below `top`
+        let nextId = terminalCount;
+        for (let level = n - 1; level > top; level--) {
+            nextId += this.created[level];
+        }
+        for (let level = top; level >= 0; level--) {
+            const result = this.evaluator.computeLevel(this.ordering, level, this.levelIds[level + 1], this.levelWeights ? this.levelWeights[level + 1] : null, this.levelIds[level], this.levelWeights ? this.levelWeights[level] : null, nextId, this.record);
+            this.created[level] = result.created;
+            this.payingWeights[level] = result.payingWeight;
+            nextId += result.created;
+        }
+        this.root = this.levelIds[0][0];
+        const nodesPerLevel = this.created.slice();
+        const internalNodeCount = nextId - terminalCount;
+        const nodeCount = 1 + (internalNodeCount - nodesPerLevel[0]) + this.evaluator.table.leafCount;
+        let expectedCost = 0;
+        const costModel = this.evaluator.costModel;
+        if (costModel) {
+            const costs = costModel.functionCosts;
+            // the root node always calls its boolean function
+            expectedCost = costs[this.ordering[0]];
+            for (let level = 1; level < n; level++) {
+                expectedCost += costs[this.ordering[level]] * this.payingWeights[level] / costModel.totalWeight;
+            }
+        }
+        return {
+            nodesPerLevel,
+            internalNodeCount,
+            nodeCount,
+            expectedCost
+        };
+    }
+}
+exports.OrderingCursor = OrderingCursor;
+/**
+ * Evaluates variable orderings of a truth table without ever creating
+ * BDD node objects.
+ *
+ * The reduced BDD is built bottom-up: the rows of the truth table are the
+ * leaves, every level above merges the two children of each block into a node
+ * through a hash table (hash-consing). Equal children collapse to a single edge
+ * (reduction rule) and equal (child0, child1) pairs share one node (elimination
+ * rule), so the amount of nodes created per level is exactly the amount of
+ * nodes the reduced BDD has on that level. Everything runs in O(2^n) integer
+ * operations.
+ *
+ * A block on level L is the set of rows that agree on the boolean functions
+ * above level L. Blocks are indexed by the assignment to those functions in
+ * their natural (index) order, not in the order of the levels. That way the
+ * blocks of a level only depend on the SET of functions above it: when two
+ * levels swap their functions, nothing below them changes and OrderingCursor
+ * only recomputes the levels above.
+ *
+ * Don't-care rows are handled like RootNode.removeIrrelevantLeafNodes() does it:
+ * a node whose one branch is entirely don't-care is replaced by its other branch.
+ *
+ * With a cost model, the same pass also sums up the weight of the rows that
+ * pass through a node on each level, which gives the expected cost of a
+ * resolve() call: a row pays for the boolean function of a level exactly when
+ * its block on that level has a node. The root node always calls its boolean
+ * function, even when the function is irrelevant.
+ */
+class OrderingEvaluator {
+    table;
+    costModel;
+    variableCount;
+    rowCount;
+    terminalCount;
+    dontCare;
+    /** amount of evaluations run so far */
+    evaluations = 0;
+    hashLo;
+    hashHi;
+    hashId;
+    scratch = null;
+    costUnit = 0;
+    constructor(table, costModel = null) {
+        this.table = table;
+        this.costModel = costModel;
+        this.variableCount = table.variableCount;
+        this.rowCount = table.rowCount;
+        this.terminalCount = table.terminalValues.length;
+        this.dontCare = table.dontCareTerminal;
+        if (costModel) {
+            if (costModel.functionCosts.length !== this.variableCount || costModel.rowWeights.length !== this.rowCount) {
+                throw new Error('cost model does not fit the truth table');
+            }
+            for (let row = 0; row < this.rowCount; row++) {
+                if (costModel.rowWeights[row] !== 0 && table.terminalIds[row] === table.dontCareTerminal) {
+                    // a don't-care row is merged into the subtree of its sibling, its weight would be lost
+                    throw new Error('don\'t-care rows must have a row weight of 0');
+                }
+            }
+            this.costUnit = costUnit(costModel);
+        }
+        // at most rowCount/2 distinct nodes per level -> load factor <= 0.5
+        let hashSize = 16;
+        while (hashSize < this.rowCount) {
+            hashSize *= 2;
+        }
+        this.hashLo = new Int32Array(hashSize);
+        this.hashHi = new Int32Array(hashSize);
+        this.hashId = new Int32Array(hashSize);
+    }
+    /**
+     * Evaluates an ordering.
+     */
+    evaluate(ordering) {
+        if (!this.scratch) {
+            this.scratch = new OrderingCursor(this, ordering);
+        }
+        else {
+            this.scratch.reset(ordering);
+        }
+        return this.scratch.evaluation;
+    }
+    /**
+     * A cursor keeps the intermediate results of an ordering so that
+     * swapping two levels only recomputes the levels above them.
+     */
+    cursor(ordering) {
+        return new OrderingCursor(this, ordering);
+    }
+    /**
+     * @returns true when evaluation a is strictly better than b:
+     * fewer nodes, or with a cost model a lower expected cost
+     * (ties in the expected cost are broken by the amount of nodes)
+     */
+    isBetter(a, b) {
+        return this.compare(a, b) < 0;
+    }
+    /**
+     * negative when a is better than b, positive when b is better, 0 when equal
+     */
+    compare(a, b) {
+        if (this.costModel) {
+            const epsilon = costTolerance(Math.max(Math.abs(a.expectedCost), Math.abs(b.expectedCost)), this.costUnit);
+            if (a.expectedCost < b.expectedCost - epsilon) {
+                return -1;
+            }
+            if (a.expectedCost > b.expectedCost + epsilon) {
+                return 1;
+            }
+        }
+        return a.nodeCount - b.nodeCount;
+    }
+    /**
+     * Builds the reduced diagram of an ordering.
+     */
+    buildDiagram(ordering) {
+        const capacity = Math.max(1, this.rowCount);
+        const record = {
+            nodeLevel: new Int32Array(capacity),
+            nodeLo: new Int32Array(capacity),
+            nodeHi: new Int32Array(capacity)
+        };
+        const cursor = new OrderingCursor(this, ordering, record);
+        const count = cursor.evaluation.internalNodeCount;
+        return {
+            variableCount: this.variableCount,
+            terminalCount: this.terminalCount,
+            root: cursor.root,
+            nodeLevel: record.nodeLevel.subarray(0, count),
+            nodeLo: record.nodeLo.subarray(0, count),
+            nodeHi: record.nodeHi.subarray(0, count),
+            ordering: Array.from(ordering),
+            nodesPerLevel: cursor.evaluation.nodesPerLevel
+        };
+    }
+    /**
+     * Resolves the don't-care rows the same way the BDD of the given ordering
+     * resolves them (a don't-care branch takes the value of its sibling branch)
+     * and returns a table without don't-care rows.
+     * When the table has no don't-care rows, the same table is returned.
+     */
+    complete(ordering) {
+        if (this.dontCare < 0) {
+            return this.table;
+        }
+        const diagram = this.buildDiagram(ordering);
+        const n = this.variableCount;
+        const terminalCount = this.terminalCount;
+        const terminalIds = new Int32Array(this.rowCount);
+        let stillDontCare = false;
+        for (let row = 0; row < this.rowCount; row++) {
+            let id = diagram.root;
+            while (id >= terminalCount) {
+                const index = id - terminalCount;
+                const variable = diagram.ordering[diagram.nodeLevel[index]];
+                id = ((row >>> (n - 1 - variable)) & 1) === 0 ? diagram.nodeLo[index] : diagram.nodeHi[index];
+            }
+            terminalIds[row] = id;
+            if (id === this.dontCare) {
+                stillDontCare = true;
+            }
+        }
+        return (0, dense_truth_table_js_1.withTerminalIds)(this.table, terminalIds, stillDontCare ? this.dontCare : -1);
+    }
+    /**
+     * Computes the blocks of one level out of the blocks of the level below.
+     * @internal
+     */
+    computeLevel(ordering, level, deeperIds, deeperWeights, ids, weights, firstId, record) {
+        const dc = this.dontCare;
+        const terminalCount = this.terminalCount;
+        const hashLo = this.hashLo;
+        const hashHi = this.hashHi;
+        const hashId = this.hashId;
+        const count = 1 << level;
+        let tableSize = 16;
+        while (tableSize < count * 2) {
+            tableSize *= 2;
+        }
+        const mask = tableSize - 1;
+        hashLo.fill(-1, 0, tableSize);
+        // the position of this level's function inside the index of the level below:
+        // the functions above the level below are sorted ascending, the largest one is bit 0
+        const variable = ordering[level];
+        let position = 0;
+        for (let k = 0; k <= level; k++) {
+            if (ordering[k] > variable) {
+                position++;
+            }
+        }
+        const lowMask = (1 << position) - 1;
+        const hiBit = 1 << position;
+        let nextId = firstId;
+        let created = 0;
+        let payingWeight = 0;
+        for (let block = 0; block < count; block++) {
+            const loIndex = ((block >>> position) << (position + 1)) | (block & lowMask);
+            const hiIndex = loIndex | hiBit;
+            const lo = deeperIds[loIndex];
+            const hi = deeperIds[hiIndex];
+            let blockWeight = 0;
+            if (deeperWeights && weights) {
+                blockWeight = deeperWeights[loIndex] + deeperWeights[hiIndex];
+                weights[block] = blockWeight;
+            }
+            let id;
+            if (lo === dc) {
+                id = hi;
+            }
+            else if (hi === dc || lo === hi) {
+                id = lo;
+            }
+            else {
+                payingWeight += blockWeight;
+                let h = (Math.imul(lo, 0x9E3779B1) ^ Math.imul(hi, 0x85EBCA77)) >>> 0;
+                h = (h ^ (h >>> 15)) & mask;
+                while (true) {
+                    const storedLo = hashLo[h];
+                    if (storedLo === -1) {
+                        hashLo[h] = lo;
+                        hashHi[h] = hi;
+                        hashId[h] = nextId;
+                        id = nextId;
+                        if (record) {
+                            record.nodeLevel[nextId - terminalCount] = level;
+                            record.nodeLo[nextId - terminalCount] = lo;
+                            record.nodeHi[nextId - terminalCount] = hi;
+                        }
+                        nextId++;
+                        created++;
+                        break;
+                    }
+                    if (storedLo === lo && hashHi[h] === hi) {
+                        id = hashId[h];
+                        break;
+                    }
+                    h = (h + 1) & mask;
+                }
+            }
+            ids[block] = id;
+        }
+        return { created, payingWeight };
+    }
+}
+exports.OrderingEvaluator = OrderingEvaluator;
+//# sourceMappingURL=ordering-evaluator.js.map

package/dist/cjs/src/ordering/ordering-evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordering-evaluator.js","sourceRoot":"","sources":["../../../../src/ordering/ordering-evaluator.ts"],"names":[],"mappings":";;;AAiFA,sCAEC;AAMD,4BAMC;AA9FD,iEAA8E;AAqE9E;;GAEG;AACU,QAAA,YAAY,GAAG,IAAI,CAAC;AAEjC;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,KAAa,EAAE,IAAY;IACrD,OAAO,oBAAY,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;AAC1D,CAAC;AAED;;;GAGG;AACH,SAAgB,QAAQ,CAAC,SAAoB;IACzC,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtD,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAa,cAAc;IAaF;IAEA;IAdL,QAAQ,CAAW;IAC5B,UAAU,CAAqB;IACtC,qEAAqE;IAC9D,IAAI,GAAW,CAAC,CAAC;IAEP,CAAC,CAAS;IACV,QAAQ,GAAiB,EAAE,CAAC;IAC5B,YAAY,CAAwB;IACpC,OAAO,CAAW;IAClB,aAAa,CAAW;IAEzC,YACqB,SAA4B,EAC7C,QAA2B,EACV,SAA+B,IAAI;QAFnC,cAAS,GAAT,SAAS,CAAmB;QAE5B,WAAM,GAAN,MAAM,CAA6B;QAEpD,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,aAAa,CAAC;QACjC,IAAA,0CAAmB,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;QACnD,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAChD,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;YACvB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;gBAC1C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;YACzD,CAAC;YACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC3D,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,QAA2B;QACpC,IAAA,0CAAmB,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,IAAI,CAAC,MAAc,EAAE,MAAc;QACtC,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YACpB,OAAO;QACX,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC;QAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACK,aAAa,CAAC,GAAW;QAC7B,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACjB,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;QACnD,qCAAqC;QACrC,IAAI,MAAM,GAAG,aAAa,CAAC;QAC3B,KAAK,IAAI,KAAK,GAAG,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;YAC3C,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAClC,CAAC;QACD,KAAK,IAAI,KAAK,GAAG,GAAG,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CACtC,IAAI,CAAC,QAAQ,EACb,KAAK,EACL,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,EACxB,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EACvD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EACpB,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EACnD,MAAM,EACN,IAAI,CAAC,MAAM,CACd,CAAC;YACF,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;YACrC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC;YAChD,MAAM,IAAI,MAAM,CAAC,OAAO,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEhC,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAC3C,MAAM,iBAAiB,GAAG,MAAM,GAAG,aAAa,CAAC;QACjD,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,iBAAiB,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QAC9F,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;QAC3C,IAAI,SAAS,EAAE,CAAC;YACZ,MAAM,KAAK,GAAG,SAAS,CAAC,aAAa,CAAC;YACtC,kDAAkD;YAClD,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACvC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;gBACrC,YAAY,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC;YACpG,CAAC;QACL,CAAC;QACD,OAAO;YACH,aAAa;YACb,iBAAiB;YACjB,SAAS;YACT,YAAY;SACf,CAAC;IACN,CAAC;CACJ;AA/GD,wCA+GC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAa,iBAAiB;IAeN;IACA;IAfJ,aAAa,CAAS;IACtB,QAAQ,CAAS;IACjB,aAAa,CAAS;IACtB,QAAQ,CAAS;IACjC,uCAAuC;IAChC,WAAW,GAAW,CAAC,CAAC;IAEd,MAAM,CAAa;IACnB,MAAM,CAAa;IACnB,MAAM,CAAa;IAC5B,OAAO,GAA0B,IAAI,CAAC;IACtC,QAAQ,GAAW,CAAC,CAAC;IAE7B,YACoB,KAAsB,EACtB,YAA8B,IAAI;QADlC,UAAK,GAAL,KAAK,CAAiB;QACtB,cAAS,GAAT,SAAS,CAAyB;QAElD,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC;QACjD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,gBAAgB,CAAC;QACvC,IAAI,SAAS,EAAE,CAAC;YACZ,IAAI,SAAS,CAAC,aAAa,CAAC,MAAM,KAAK,IAAI,CAAC,aAAa,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACzG,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;YAC/D,CAAC;YACD,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC;gBAC3C,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,gBAAgB,EAAE,CAAC;oBACvF,uFAAuF;oBACvF,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;gBACpE,CAAC;YACL,CAAC;YACD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC;QACD,oEAAoE;QACpE,IAAI,QAAQ,GAAG,EAAE,CAAC;QAClB,OAAO,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9B,QAAQ,IAAI,CAAC,CAAC;QAClB,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACI,QAAQ,CAAC,QAA2B;QACvC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAChB,IAAI,CAAC,OAAO,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACjC,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;IACnC,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,QAA2B;QACrC,OAAO,IAAI,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,CAAqB,EAAE,CAAqB;QACxD,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,OAAO,CAAC,CAAqB,EAAE,CAAqB;QACvD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3G,IAAI,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC,YAAY,GAAG,OAAO,EAAE,CAAC;gBAC5C,OAAO,CAAC,CAAC,CAAC;YACd,CAAC;YACD,IAAI,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC,YAAY,GAAG,OAAO,EAAE,CAAC;gBAC5C,OAAO,CAAC,CAAC;YACb,CAAC;QACL,CAAC;QACD,OAAO,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,CAAC;IACrC,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,QAA2B;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAkB;YAC1B,SAAS,EAAE,IAAI,UAAU,CAAC,QAAQ,CAAC;YACnC,MAAM,EAAE,IAAI,UAAU,CAAC,QAAQ,CAAC;YAChC,MAAM,EAAE,IAAI,UAAU,CAAC,QAAQ,CAAC;SACnC,CAAC;QACF,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC1D,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,iBAAiB,CAAC;QAClD,OAAO;YACH,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC;YAC9C,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC;YACxC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC;YACxC,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC;YAC9B,aAAa,EAAE,MAAM,CAAC,UAAU,CAAC,aAAa;SACjD,CAAC;IACN,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,QAA2B;QACvC,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,KAAK,CAAC;QACtB,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC5C,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC;QAC7B,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,MAAM,WAAW,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClD,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC;YAC3C,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;YACtB,OAAO,EAAE,IAAI,aAAa,EAAE,CAAC;gBACzB,MAAM,KAAK,GAAG,EAAE,GAAG,aAAa,CAAC;gBACjC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC5D,EAAE,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAClG,CAAC;YACD,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;YACtB,IAAI,EAAE,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACvB,aAAa,GAAG,IAAI,CAAC;YACzB,CAAC;QACL,CAAC;QACD,OAAO,IAAA,sCAAe,EAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxF,CAAC;IAED;;;OAGG;IACI,YAAY,CACf,QAAkB,EAClB,KAAa,EACb,SAAqB,EACrB,aAAkC,EAClC,GAAe,EACf,OAA4B,EAC5B,OAAe,EACf,MAA4B;QAE5B,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QACzB,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,MAAM,KAAK,GAAG,CAAC,IAAI,KAAK,CAAC;QACzB,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,OAAO,SAAS,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC;YAC3B,SAAS,IAAI,CAAC,CAAC;QACnB,CAAC;QACD,MAAM,IAAI,GAAG,SAAS,GAAG,CAAC,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;QAE9B,6EAA6E;QAC7E,qFAAqF;QACrF,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,EAAE,CAAC;gBACzB,QAAQ,EAAE,CAAC;YACf,CAAC;QACL,CAAC;QACD,MAAM,OAAO,GAAG,CAAC,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC;QACpC,MAAM,KAAK,GAAG,CAAC,IAAI,QAAQ,CAAC;QAE5B,IAAI,MAAM,GAAG,OAAO,CAAC;QACrB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,OAAO,CAAC,CAAC;YAC7E,MAAM,OAAO,GAAG,OAAO,GAAG,KAAK,CAAC;YAChC,MAAM,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;YAC9B,MAAM,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;YAC9B,IAAI,WAAW,GAAG,CAAC,CAAC;YACpB,IAAI,aAAa,IAAI,OAAO,EAAE,CAAC;gBAC3B,WAAW,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;gBAC9D,OAAO,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC;YACjC,CAAC;YACD,IAAI,EAAU,CAAC;YACf,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;gBACZ,EAAE,GAAG,EAAE,CAAC;YACZ,CAAC;iBAAM,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;gBAChC,EAAE,GAAG,EAAE,CAAC;YACZ,CAAC;iBAAM,CAAC;gBACJ,YAAY,IAAI,WAAW,CAAC;gBAC5B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC;gBACtE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;gBAC5B,OAAO,IAAI,EAAE,CAAC;oBACV,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;oBAC3B,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC;wBAClB,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;wBACf,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;wBACf,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;wBACnB,EAAE,GAAG,MAAM,CAAC;wBACZ,IAAI,MAAM,EAAE,CAAC;4BACT,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,KAAK,CAAC;4BACjD,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;4BAC3C,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;wBAC/C,CAAC;wBACD,MAAM,EAAE,CAAC;wBACT,OAAO,EAAE,CAAC;wBACV,MAAM;oBACV,CAAC;oBACD,IAAI,QAAQ,KAAK,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;wBACtC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;wBACf,MAAM;oBACV,CAAC;oBACD,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;gBACvB,CAAC;YACL,CAAC;YACD,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QACpB,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC;IACrC,CAAC;CACJ;AAvOD,8CAuOC"}

package/dist/cjs/src/ordering/shared-diagram.d.ts

@@ -0,0 +1,85 @@
+import type { DenseTruthTable } from './dense-truth-table.js';
+/**
+ * thrown by SharedDiagram when more nodes than allowed would be created
+ */
+export declare class DiagramBudgetExceededError extends Error {
+    constructor();
+}
+export declare const DEFAULT_MAX_DIAGRAM_NODES = 4000000;
+/**
+ * A hash-consed decision diagram of a fully specified truth table in the
+ * natural variable order, with a restrict() operation.
+ *
+ * Because the variable order is fixed, two functions are equal if and only if
+ * they have the same node id. The exact searches rely on this to recognize
+ * equal cofactors.
+ */
+export declare class SharedDiagram {
+    readonly table: DenseTruthTable;
+    readonly variableCount: number;
+    readonly terminalCount: number;
+    readonly rootId: number;
+    /** the boolean functions the truth table depends on, ascending */
+    readonly relevant: number[];
+    /** bit index of each relevant boolean function inside support masks, -1 for irrelevant ones */
+    readonly compactOf: Int32Array;
+    private nodeVar;
+    private nodeLo;
+    private nodeHi;
+    private nodeSupport;
+    private nodeCount;
+    private readonly uniqueTables;
+    private readonly restrictMemo;
+    private readonly maxNodes;
+    constructor(table: DenseTruthTable, 
+    /**
+     * restrict() creates nodes for the restricted functions, which can be a lot
+     * on unstructured functions. More nodes than this throw a DiagramBudgetExceededError.
+     * Default: 4000000 (roughly 400 MB)
+     */
+    maxNodes?: number);
+    isTerminal(id: number): boolean;
+    /** amount of internal nodes created so far */
+    get size(): number;
+    /** true when the diagram of the natural ordering alone already exceeds the node budget */
+    get overBudget(): boolean;
+    /**
+     * support mask (compact bit indexes) of a node, 0 for terminals
+     */
+    supportOf(id: number): number;
+    dependsOn(id: number, variable: number): boolean;
+    /**
+     * the function with `variable` fixed to `value`
+     */
+    restrict(g: number, variable: number, value: number): number;
+    /**
+     * Moves the boolean functions the truth table does not depend on
+     * to the bottom, keeping the order of the others.
+     */
+    normalizeOrdering(ordering: ArrayLike<number>): number[];
+    irrelevantVariables(): number[];
+    private makeNode;
+    /**
+     * support in natural variable bits, only used before the compact mapping exists
+     */
+    private rawSupport;
+    private growNodes;
+}
+/**
+ * binary min-heap of search states, deterministic tie breaking:
+ * smaller estimate first, then larger cost (deeper states), then smaller subset
+ */
+export declare class StateHeap {
+    private readonly estimates;
+    private readonly costs;
+    private readonly subsets;
+    get size(): number;
+    push(estimate: number, cost: number, subset: number): void;
+    pop(): {
+        estimate: number;
+        cost: number;
+        subset: number;
+    };
+    private less;
+    private swap;
+}