binary-decision-diagram 4.0.0 → 5.0.0

package/dist/cjs/src/ordering/exact-ordering.d.ts

@@ -0,0 +1,89 @@
+import type { DenseTruthTable } from './dense-truth-table.js';
+export interface ExactOrderingOptions {
+    /**
+     * The search stops without a proof when more states were expanded.
+     * Default: 200000
+     */
+    maxExpansions?: number;
+    /**
+     * The search stops without a proof when the stored cofactor sets
+     * contain more entries in total (memory protection).
+     * Default: 2^25
+     */
+    maxCofactorEntries?: number;
+    /**
+     * A known good ordering. Its size is used as upper bound to prune the search,
+     * which makes the search much faster when the ordering is already close to optimal.
+     */
+    upperBoundOrdering?: ArrayLike<number>;
+    /**
+     * Only orderings with fewer internal nodes than this are searched for.
+     */
+    upperBound?: number;
+    log?: (message: string) => void;
+}
+export interface ExactOrderingResult {
+    /**
+     * true when it is proven that no ordering has fewer internal nodes
+     * than the returned one (or than the upper bound, when ordering is null)
+     */
+    solved: boolean;
+    /**
+     * The best ordering that was found. Irrelevant boolean functions
+     * are always at the bottom. null when no ordering below the numeric
+     * upper bound exists and the upperBoundOrdering (if given) is not
+     * below it either.
+     */
+    ordering: number[] | null;
+    /** amount of internal (non-leaf) nodes of `ordering`, -1 when ordering is null */
+    internalNodeCount: number;
+    /** amount of expanded states */
+    expansions: number;
+    /** amount of generated states */
+    generated: number;
+}
+/**
+ * The number of nodes on a level of a reduced BDD only depends on the SET of
+ * variables above that level, not on their order (Friedman & Supowit, 1990):
+ * it is the amount of distinct cofactors with respect to that set that still
+ * depend on the level's variable.
+ *
+ * Therefore the optimal ordering is a shortest path through the lattice of
+ * variable subsets, from the empty set to the full set, where the edge
+ * S -> S + {x} costs the amount of nodes that test x when exactly the
+ * variables of S are above it.
+ *
+ * This class finds that shortest path with an A* search. Each subset S is
+ * represented by the set of its distinct non-constant cofactors, which are
+ * nodes of one shared hash-consed diagram in the natural variable order
+ * (so equal functions always have equal ids). The admissible estimate for the
+ * remaining cost of a subset is the amount of its distinct non-constant
+ * cofactors: each of them needs its own node below.
+ *
+ * With a good upper bound (from the local search) the search typically only
+ * has to look at a tiny fraction of the 2^n subsets.
+ */
+export declare class ExactOrderingSearch {
+    private readonly table;
+    private readonly diagram;
+    private readonly n;
+    private readonly terminalCount;
+    constructor(table: DenseTruthTable, options?: {
+        maxDiagramNodes?: number;
+    });
+    /**
+     * Moves the boolean functions the truth table does not depend on
+     * to the bottom. This never changes the amount of internal nodes
+     * but ensures the root node tests a relevant boolean function.
+     */
+    normalizeOrdering(ordering: ArrayLike<number>): number[];
+    run(options?: ExactOrderingOptions): ExactOrderingResult;
+    /**
+     * lower bound for the amount of nodes below the given subset
+     */
+    private estimate;
+    /**
+     * the distinct non-constant cofactors after additionally fixing `variable`
+     */
+    private cofactorsAfter;
+}

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

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExactOrderingSearch = void 0;
+const dense_truth_table_js_1 = require("./dense-truth-table.js");
+const ordering_evaluator_js_1 = require("./ordering-evaluator.js");
+const shared_diagram_js_1 = require("./shared-diagram.js");
+/**
+ * The number of nodes on a level of a reduced BDD only depends on the SET of
+ * variables above that level, not on their order (Friedman & Supowit, 1990):
+ * it is the amount of distinct cofactors with respect to that set that still
+ * depend on the level's variable.
+ *
+ * Therefore the optimal ordering is a shortest path through the lattice of
+ * variable subsets, from the empty set to the full set, where the edge
+ * S -> S + {x} costs the amount of nodes that test x when exactly the
+ * variables of S are above it.
+ *
+ * This class finds that shortest path with an A* search. Each subset S is
+ * represented by the set of its distinct non-constant cofactors, which are
+ * nodes of one shared hash-consed diagram in the natural variable order
+ * (so equal functions always have equal ids). The admissible estimate for the
+ * remaining cost of a subset is the amount of its distinct non-constant
+ * cofactors: each of them needs its own node below.
+ *
+ * With a good upper bound (from the local search) the search typically only
+ * has to look at a tiny fraction of the 2^n subsets.
+ */
+class ExactOrderingSearch {
+    table;
+    diagram;
+    n;
+    terminalCount;
+    constructor(table, options = {}) {
+        this.table = table;
+        if (table.dontCareTerminal >= 0) {
+            throw new Error('the exact search needs a truth table without don\'t-care rows, resolve them with OrderingEvaluator.complete() first');
+        }
+        this.diagram = new shared_diagram_js_1.SharedDiagram(table, options.maxDiagramNodes === undefined ? shared_diagram_js_1.DEFAULT_MAX_DIAGRAM_NODES : options.maxDiagramNodes);
+        this.n = table.variableCount;
+        this.terminalCount = table.terminalValues.length;
+    }
+    /**
+     * Moves the boolean functions the truth table does not depend on
+     * to the bottom. This never changes the amount of internal nodes
+     * but ensures the root node tests a relevant boolean function.
+     */
+    normalizeOrdering(ordering) {
+        return this.diagram.normalizeOrdering(ordering);
+    }
+    run(options = {}) {
+        const log = options.log ? options.log : () => null;
+        const maxExpansions = options.maxExpansions === undefined ? 200000 : options.maxExpansions;
+        const maxCofactorEntries = options.maxCofactorEntries === undefined ? Math.pow(2, 25) : options.maxCofactorEntries;
+        const diagram = this.diagram;
+        const relevant = diagram.relevant;
+        const m = relevant.length;
+        const irrelevant = diagram.irrelevantVariables();
+        // upper bound
+        let upperBound = options.upperBound === undefined ? Infinity : options.upperBound;
+        let incumbent = null;
+        if (options.upperBoundOrdering) {
+            incumbent = this.normalizeOrdering(options.upperBoundOrdering);
+            const incumbentCount = new ordering_evaluator_js_1.OrderingEvaluator(this.table).evaluate(incumbent).internalNodeCount;
+            if (incumbentCount >= upperBound) {
+                // the numeric bound is at least as good, the incumbent cannot be the answer
+                incumbent = null;
+            }
+            else {
+                upperBound = incumbentCount;
+            }
+        }
+        const giveUp = (reason, expansionCount, generatedCount) => {
+            log('exact search: ' + reason);
+            return {
+                solved: false,
+                ordering: incumbent,
+                internalNodeCount: incumbent ? upperBound : -1,
+                expansions: expansionCount,
+                generated: generatedCount
+            };
+        };
+        if (diagram.overBudget) {
+            return giveUp('diagram budget exceeded', 0, 0);
+        }
+        if (m === 0) {
+            // constant function: every ordering has 0 internal nodes
+            const constantOrdering = upperBound > 0 ? (0, dense_truth_table_js_1.naturalOrdering)(this.n) : incumbent;
+            return {
+                solved: true,
+                ordering: constantOrdering,
+                internalNodeCount: constantOrdering ? 0 : -1,
+                expansions: 0,
+                generated: 0
+            };
+        }
+        const full = (1 << m) - 1;
+        const cofactors = new Map();
+        const bestCost = new Map();
+        const parentVariable = new Map();
+        const closed = new Set();
+        const heap = new shared_diagram_js_1.StateHeap();
+        const startSet = new Int32Array(1);
+        startSet[0] = diagram.rootId;
+        cofactors.set(0, startSet);
+        bestCost.set(0, 0);
+        heap.push(this.estimate(0, startSet), 0, 0);
+        let expansions = 0;
+        let generated = 1;
+        let storedEntries = 1;
+        let solvedSet = -1;
+        let solvedCost = -1;
+        try {
+            while (heap.size > 0) {
+                const state = heap.pop();
+                const currentCost = state.cost;
+                const subset = state.subset;
+                if (currentCost !== bestCost.get(subset) || closed.has(subset)) {
+                    // stale heap entry
+                    continue;
+                }
+                if (state.estimate >= upperBound) {
+                    // nothing left that can beat the upper bound
+                    break;
+                }
+                if (subset === full) {
+                    solvedSet = subset;
+                    solvedCost = currentCost;
+                    break;
+                }
+                closed.add(subset);
+                expansions++;
+                if (expansions > maxExpansions) {
+                    return giveUp('expansion budget exceeded', expansions, generated);
+                }
+                if (storedEntries > maxCofactorEntries) {
+                    return giveUp('memory budget exceeded', expansions, generated);
+                }
+                if (expansions % 10000 === 0) {
+                    log('exact search: ' + expansions + ' states expanded, ' + generated + ' generated, ' + heap.size + ' open');
+                }
+                const set = cofactors.get(subset);
+                for (let c = 0; c < m; c++) {
+                    const bit = 1 << c;
+                    if ((subset & bit) !== 0) {
+                        continue;
+                    }
+                    const variable = relevant[c];
+                    let edgeCost = 0;
+                    for (let i = 0; i < set.length; i++) {
+                        if ((diagram.supportOf(set[i]) & bit) !== 0) {
+                            edgeCost++;
+                        }
+                    }
+                    const nextCost = currentCost + edgeCost;
+                    const nextSubset = subset | bit;
+                    const knownCost = bestCost.get(nextSubset);
+                    if (knownCost !== undefined && knownCost <= nextCost) {
+                        continue;
+                    }
+                    let nextSet = cofactors.get(nextSubset);
+                    if (nextSet === undefined) {
+                        nextSet = this.cofactorsAfter(set, variable);
+                        cofactors.set(nextSubset, nextSet);
+                        generated++;
+                        storedEntries += nextSet.length;
+                    }
+                    const estimate = nextCost + this.estimate(nextSubset, nextSet);
+                    if (estimate >= upperBound) {
+                        continue;
+                    }
+                    bestCost.set(nextSubset, nextCost);
+                    parentVariable.set(nextSubset, variable);
+                    closed.delete(nextSubset);
+                    heap.push(estimate, nextCost, nextSubset);
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof shared_diagram_js_1.DiagramBudgetExceededError) {
+                return giveUp('diagram budget exceeded', expansions, generated);
+            }
+            throw err;
+        }
+        if (solvedSet === -1) {
+            // no ordering below the upper bound exists: the incumbent (if any) is optimal
+            return {
+                solved: true,
+                ordering: incumbent,
+                internalNodeCount: incumbent ? upperBound : -1,
+                expansions,
+                generated
+            };
+        }
+        // reconstruct the path
+        const reversed = [];
+        let remainingSubset = solvedSet;
+        while (remainingSubset !== 0) {
+            const variable = parentVariable.get(remainingSubset);
+            reversed.push(variable);
+            remainingSubset = remainingSubset & ~(1 << diagram.compactOf[variable]);
+        }
+        const ordering = reversed.reverse().concat(irrelevant);
+        return {
+            solved: true,
+            ordering,
+            internalNodeCount: solvedCost,
+            expansions,
+            generated
+        };
+    }
+    /**
+     * lower bound for the amount of nodes below the given subset
+     */
+    estimate(subset, set) {
+        let union = 0;
+        for (let i = 0; i < set.length; i++) {
+            union |= this.diagram.supportOf(set[i]);
+        }
+        const remaining = union & ~subset;
+        let remainingCount = 0;
+        for (let x = remaining; x !== 0; x &= x - 1) {
+            remainingCount++;
+        }
+        return Math.max(set.length, remainingCount);
+    }
+    /**
+     * the distinct non-constant cofactors after additionally fixing `variable`
+     */
+    cofactorsAfter(set, variable) {
+        const diagram = this.diagram;
+        const bit = 1 << diagram.compactOf[variable];
+        const candidates = new Int32Array(set.length * 2);
+        let count = 0;
+        for (let i = 0; i < set.length; i++) {
+            const g = set[i];
+            if ((diagram.supportOf(g) & bit) === 0) {
+                candidates[count++] = g;
+                continue;
+            }
+            const lo = diagram.restrict(g, variable, 0);
+            if (lo >= this.terminalCount) {
+                candidates[count++] = lo;
+            }
+            const hi = diagram.restrict(g, variable, 1);
+            if (hi >= this.terminalCount) {
+                candidates[count++] = hi;
+            }
+        }
+        const sorted = candidates.subarray(0, count).sort();
+        let unique = 0;
+        for (let i = 0; i < sorted.length; i++) {
+            if (i === 0 || sorted[i] !== sorted[i - 1]) {
+                sorted[unique++] = sorted[i];
+            }
+        }
+        return sorted.slice(0, unique);
+    }
+}
+exports.ExactOrderingSearch = ExactOrderingSearch;
+//# sourceMappingURL=exact-ordering.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exact-ordering.js","sourceRoot":"","sources":["../../../../src/ordering/exact-ordering.ts"],"names":[],"mappings":"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"}

package/dist/cjs/src/ordering/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Public API of the variable ordering optimizer, see docs/variable-ordering.md.
+ *
+ * - optimize-ordering.ts: optimizeOrdering(), findOrdering(), createBddWithOrdering()
+ * - ordering-evaluator.ts: counts the nodes (and the expected cost) of any ordering in O(2^n)
+ * - local-search.ts: deterministic seeds, sifting and window permutation
+ * - exact-ordering.ts, exact-cost-ordering.ts: A* searches that prove optimality
+ * - shared-diagram.ts: the shared function diagram the exact searches work on
+ * - dense-truth-table.ts, build-bdd.ts, int-pair-map.ts: data structures and helpers
+ */
+export { optimizeOrdering, findOrdering, createBddWithOrdering, buildCostModel, DEFAULT_MAX_EXACT_VARIABLES, DEFAULT_MAX_EXACT_NODE_COUNT } from './optimize-ordering.js';
+export type { FindOrderingInput, FindOrderingResult, OptimizeOrderingInput, OptimizeOrderingResult, OptimizeOrderingStats } from './optimize-ordering.js';
+export { OrderingEvaluator, OrderingCursor } from './ordering-evaluator.js';
+export type { CostModel, OrderingEvaluation, ReducedDiagram } from './ordering-evaluator.js';
+export { LocalOrderingSearch, DEFAULT_WINDOW_SIZE, DEFAULT_MAX_ROUNDS, MAX_WINDOW_SIZE } from './local-search.js';
+export type { LocalSearchOptions, OrderingSearchResult, OrderingProgress, OrderingProgressCallback } from './local-search.js';
+export { ExactOrderingSearch } from './exact-ordering.js';
+export type { ExactOrderingOptions, ExactOrderingResult } from './exact-ordering.js';
+export { ExactCostOrderingSearch } from './exact-cost-ordering.js';
+export type { ExactCostOrderingOptions, ExactCostOrderingResult } from './exact-cost-ordering.js';
+export { parseTruthTable, denseTruthTableToMap, naturalOrdering, MAX_VARIABLE_COUNT } from './dense-truth-table.js';
+export type { DenseTruthTable } from './dense-truth-table.js';

package/dist/cjs/src/ordering/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_VARIABLE_COUNT = exports.naturalOrdering = exports.denseTruthTableToMap = exports.parseTruthTable = exports.ExactCostOrderingSearch = exports.ExactOrderingSearch = exports.MAX_WINDOW_SIZE = exports.DEFAULT_MAX_ROUNDS = exports.DEFAULT_WINDOW_SIZE = exports.LocalOrderingSearch = exports.OrderingCursor = exports.OrderingEvaluator = exports.DEFAULT_MAX_EXACT_NODE_COUNT = exports.DEFAULT_MAX_EXACT_VARIABLES = exports.buildCostModel = exports.createBddWithOrdering = exports.findOrdering = exports.optimizeOrdering = void 0;
+/**
+ * Public API of the variable ordering optimizer, see docs/variable-ordering.md.
+ *
+ * - optimize-ordering.ts: optimizeOrdering(), findOrdering(), createBddWithOrdering()
+ * - ordering-evaluator.ts: counts the nodes (and the expected cost) of any ordering in O(2^n)
+ * - local-search.ts: deterministic seeds, sifting and window permutation
+ * - exact-ordering.ts, exact-cost-ordering.ts: A* searches that prove optimality
+ * - shared-diagram.ts: the shared function diagram the exact searches work on
+ * - dense-truth-table.ts, build-bdd.ts, int-pair-map.ts: data structures and helpers
+ */
+var optimize_ordering_js_1 = require("./optimize-ordering.js");
+Object.defineProperty(exports, "optimizeOrdering", { enumerable: true, get: function () { return optimize_ordering_js_1.optimizeOrdering; } });
+Object.defineProperty(exports, "findOrdering", { enumerable: true, get: function () { return optimize_ordering_js_1.findOrdering; } });
+Object.defineProperty(exports, "createBddWithOrdering", { enumerable: true, get: function () { return optimize_ordering_js_1.createBddWithOrdering; } });
+Object.defineProperty(exports, "buildCostModel", { enumerable: true, get: function () { return optimize_ordering_js_1.buildCostModel; } });
+Object.defineProperty(exports, "DEFAULT_MAX_EXACT_VARIABLES", { enumerable: true, get: function () { return optimize_ordering_js_1.DEFAULT_MAX_EXACT_VARIABLES; } });
+Object.defineProperty(exports, "DEFAULT_MAX_EXACT_NODE_COUNT", { enumerable: true, get: function () { return optimize_ordering_js_1.DEFAULT_MAX_EXACT_NODE_COUNT; } });
+var ordering_evaluator_js_1 = require("./ordering-evaluator.js");
+Object.defineProperty(exports, "OrderingEvaluator", { enumerable: true, get: function () { return ordering_evaluator_js_1.OrderingEvaluator; } });
+Object.defineProperty(exports, "OrderingCursor", { enumerable: true, get: function () { return ordering_evaluator_js_1.OrderingCursor; } });
+var local_search_js_1 = require("./local-search.js");
+Object.defineProperty(exports, "LocalOrderingSearch", { enumerable: true, get: function () { return local_search_js_1.LocalOrderingSearch; } });
+Object.defineProperty(exports, "DEFAULT_WINDOW_SIZE", { enumerable: true, get: function () { return local_search_js_1.DEFAULT_WINDOW_SIZE; } });
+Object.defineProperty(exports, "DEFAULT_MAX_ROUNDS", { enumerable: true, get: function () { return local_search_js_1.DEFAULT_MAX_ROUNDS; } });
+Object.defineProperty(exports, "MAX_WINDOW_SIZE", { enumerable: true, get: function () { return local_search_js_1.MAX_WINDOW_SIZE; } });
+var exact_ordering_js_1 = require("./exact-ordering.js");
+Object.defineProperty(exports, "ExactOrderingSearch", { enumerable: true, get: function () { return exact_ordering_js_1.ExactOrderingSearch; } });
+var exact_cost_ordering_js_1 = require("./exact-cost-ordering.js");
+Object.defineProperty(exports, "ExactCostOrderingSearch", { enumerable: true, get: function () { return exact_cost_ordering_js_1.ExactCostOrderingSearch; } });
+var dense_truth_table_js_1 = require("./dense-truth-table.js");
+Object.defineProperty(exports, "parseTruthTable", { enumerable: true, get: function () { return dense_truth_table_js_1.parseTruthTable; } });
+Object.defineProperty(exports, "denseTruthTableToMap", { enumerable: true, get: function () { return dense_truth_table_js_1.denseTruthTableToMap; } });
+Object.defineProperty(exports, "naturalOrdering", { enumerable: true, get: function () { return dense_truth_table_js_1.naturalOrdering; } });
+Object.defineProperty(exports, "MAX_VARIABLE_COUNT", { enumerable: true, get: function () { return dense_truth_table_js_1.MAX_VARIABLE_COUNT; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/src/ordering/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/ordering/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACH,+DAOgC;AAN5B,wHAAA,gBAAgB,OAAA;AAChB,oHAAA,YAAY,OAAA;AACZ,6HAAA,qBAAqB,OAAA;AACrB,sHAAA,cAAc,OAAA;AACd,mIAAA,2BAA2B,OAAA;AAC3B,oIAAA,4BAA4B,OAAA;AAShC,iEAGiC;AAF7B,0HAAA,iBAAiB,OAAA;AACjB,uHAAA,cAAc,OAAA;AAOlB,qDAK2B;AAJvB,sHAAA,mBAAmB,OAAA;AACnB,sHAAA,mBAAmB,OAAA;AACnB,qHAAA,kBAAkB,OAAA;AAClB,kHAAA,eAAe,OAAA;AAQnB,yDAA0D;AAAjD,wHAAA,mBAAmB,OAAA;AAE5B,mEAAmE;AAA1D,iIAAA,uBAAuB,OAAA;AAEhC,+DAKgC;AAJ5B,uHAAA,eAAe,OAAA;AACf,4HAAA,oBAAoB,OAAA;AACpB,uHAAA,eAAe,OAAA;AACf,0HAAA,kBAAkB,OAAA"}

package/dist/cjs/src/ordering/int-pair-map.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Open addressing hash map from a pair of non-negative 32 bit integers
+ * to a non-negative 32 bit integer. Used in the hot paths of the exact search
+ * where a Map with string keys would be far too slow.
+ */
+export declare class IntPairMap {
+    size: number;
+    private keysA;
+    private keysB;
+    private values;
+    private mask;
+    constructor(initialCapacity?: number);
+    /**
+     * @returns the stored value or -1
+     */
+    get(a: number, b: number): number;
+    set(a: number, b: number, value: number): void;
+    private hash;
+    private grow;
+}

package/dist/cjs/src/ordering/int-pair-map.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntPairMap = void 0;
+/**
+ * Open addressing hash map from a pair of non-negative 32 bit integers
+ * to a non-negative 32 bit integer. Used in the hot paths of the exact search
+ * where a Map with string keys would be far too slow.
+ */
+class IntPairMap {
+    size = 0;
+    keysA;
+    keysB;
+    values;
+    mask;
+    constructor(initialCapacity = 1024) {
+        let capacity = 16;
+        while (capacity < initialCapacity) {
+            capacity *= 2;
+        }
+        this.keysA = new Int32Array(capacity).fill(-1);
+        this.keysB = new Int32Array(capacity);
+        this.values = new Int32Array(capacity);
+        this.mask = capacity - 1;
+    }
+    /**
+     * @returns the stored value or -1
+     */
+    get(a, b) {
+        let h = this.hash(a, b);
+        while (true) {
+            const storedA = this.keysA[h];
+            if (storedA === -1) {
+                return -1;
+            }
+            if (storedA === a && this.keysB[h] === b) {
+                return this.values[h];
+            }
+            h = (h + 1) & this.mask;
+        }
+    }
+    set(a, b, value) {
+        if ((this.size + 1) * 2 > this.keysA.length) {
+            this.grow();
+        }
+        let h = this.hash(a, b);
+        while (true) {
+            const storedA = this.keysA[h];
+            if (storedA === -1) {
+                this.keysA[h] = a;
+                this.keysB[h] = b;
+                this.values[h] = value;
+                this.size++;
+                return;
+            }
+            if (storedA === a && this.keysB[h] === b) {
+                this.values[h] = value;
+                return;
+            }
+            h = (h + 1) & this.mask;
+        }
+    }
+    hash(a, b) {
+        let h = (Math.imul(a, 0x9E3779B1) ^ Math.imul(b + 0x7F4A7C15, 0x85EBCA77)) >>> 0;
+        h ^= h >>> 15;
+        return h & this.mask;
+    }
+    grow() {
+        const oldA = this.keysA;
+        const oldB = this.keysB;
+        const oldValues = this.values;
+        const capacity = oldA.length * 2;
+        this.keysA = new Int32Array(capacity).fill(-1);
+        this.keysB = new Int32Array(capacity);
+        this.values = new Int32Array(capacity);
+        this.mask = capacity - 1;
+        this.size = 0;
+        for (let i = 0; i < oldA.length; i++) {
+            if (oldA[i] !== -1) {
+                this.set(oldA[i], oldB[i], oldValues[i]);
+            }
+        }
+    }
+}
+exports.IntPairMap = IntPairMap;
+//# sourceMappingURL=int-pair-map.js.map

package/dist/cjs/src/ordering/int-pair-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"int-pair-map.js","sourceRoot":"","sources":["../../../../src/ordering/int-pair-map.ts"],"names":[],"mappings":"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"}

package/dist/cjs/src/ordering/local-search.d.ts

@@ -0,0 +1,114 @@
+import { OrderingEvaluator, OrderingEvaluation } from './ordering-evaluator.js';
+export interface OrderingProgress {
+    ordering: number[];
+    nodeCount: number;
+    /** 0 without cost model */
+    expectedCost: number;
+    phase: string;
+}
+export type OrderingProgressCallback = (progress: OrderingProgress) => void;
+export interface LocalSearchOptions {
+    /**
+     * Size of the windows whose variables are permuted exhaustively.
+     * 0 or 1 disables window permutation. The work grows with windowSize!,
+     * so at most MAX_WINDOW_SIZE (8) is allowed.
+     * Default: 3
+     */
+    windowSize?: number;
+    /**
+     * Maximum amount of sifting rounds.
+     * Default: 50
+     */
+    maxRounds?: number;
+    onImprovement?: OrderingProgressCallback;
+    log?: (message: string) => void;
+}
+export interface OrderingSearchResult {
+    ordering: number[];
+    nodeCount: number;
+    expectedCost: number;
+    nodesPerLevel: number[];
+    evaluation: OrderingEvaluation;
+}
+/**
+ * Deterministic greedy construction:
+ * fills the levels from the top, at each level the boolean function
+ * that leads to the best BDD (with the other functions in their index order)
+ * is picked.
+ */
+export declare function greedyTopDownOrdering(evaluator: OrderingEvaluator): number[];
+/**
+ * Deterministic greedy construction from the bottom:
+ * at each step the boolean function that is best as the lowest
+ * remaining level is picked.
+ */
+export declare function greedyBottomUpOrdering(evaluator: OrderingEvaluator): number[];
+export declare const DEFAULT_WINDOW_SIZE = 3;
+export declare const DEFAULT_MAX_ROUNDS = 50;
+/**
+ * Window permutation tries all w! orderings of every window of w levels,
+ * larger windows take too long.
+ */
+export declare const MAX_WINDOW_SIZE = 8;
+export declare function ensureNonNegativeInteger(value: number, name: string): void;
+export declare function ensureWindowSize(windowSize: number): void;
+/**
+ * Improves an ordering by sifting (moving each variable through all positions
+ * and keeping the best one) and exhaustive window permutation until no
+ * strict improvement is found anymore. "Better" is decided by
+ * OrderingEvaluator.isBetter(): fewer nodes, or with a cost model a lower
+ * expected cost. Everything is deterministic: the same input always gives
+ * the same output.
+ */
+export declare class LocalOrderingSearch {
+    private readonly evaluator;
+    best: OrderingEvaluation;
+    private readonly cursor;
+    private readonly n;
+    private readonly windowPermutations;
+    private readonly windowSize;
+    private readonly maxRounds;
+    private readonly onImprovement;
+    private readonly log;
+    constructor(evaluator: OrderingEvaluator, initialOrdering: ArrayLike<number>, options?: LocalSearchOptions);
+    /**
+     * ordering[level] = boolean function tested on that level
+     */
+    get ordering(): number[];
+    result(): OrderingSearchResult;
+    /**
+     * Runs sifting rounds and window permutation rounds
+     * until a full cycle gives no improvement.
+     */
+    run(): OrderingSearchResult;
+    /**
+     * One sifting round: each variable, largest level first,
+     * is moved to the position where the BDD is best.
+     * @returns true if the ordering improved
+     */
+    siftRound(): boolean;
+    /**
+     * One window permutation round: for each window of adjacent levels
+     * all permutations of its variables are tried.
+     * @returns true if the ordering improved
+     */
+    windowRound(): boolean;
+    private progress;
+    private describe;
+    /**
+     * swaps the variables of level and level+1
+     */
+    private swapAdjacent;
+    private swapLevels;
+    /**
+     * Arranges the window so that level (windowStart + i) holds original[permutation[i]].
+     */
+    private setWindow;
+}
+/**
+ * Deterministic start orderings for the local search.
+ */
+export declare function seedOrderings(evaluator: OrderingEvaluator): {
+    name: string;
+    ordering: number[];
+}[];