binary-decision-diagram 2.0.0 → 3.0.0

package/test/unit/create-bdd-from-truth-table.test.ts

@@ -1,24 +0,0 @@
-import * as assert from 'assert';
-import { createBddFromTruthTable } from '../../src/create-bdd-from-truth-table';
-import {
-    exampleTruthTable
-} from '../helper/test-util';
-import { ensureCorrectBdd } from '../../src/ensure-correct-bdd';
-
-
-describe('create-bdd-from-truth-table.test.ts', () => {
-    it('should create a bdd', () => {
-        const bdd = createBddFromTruthTable(
-            exampleTruthTable()
-        );
-        assert.ok(bdd);
-        ensureCorrectBdd(bdd);
-    });
-    it('should create a big bdd', () => {
-        const bdd = createBddFromTruthTable(
-            exampleTruthTable(5)
-        );
-        assert.ok(bdd);
-        ensureCorrectBdd(bdd);
-    });
-});

package/test/unit/find-similar-node.test.ts

@@ -1,53 +0,0 @@
-import * as assert from 'assert';
-import { createBddFromTruthTable } from '../../src/create-bdd-from-truth-table';
-import {
-    exampleTruthTable, allEqualTable
-} from '../helper/test-util';
-import { ensureCorrectBdd } from '../../src/ensure-correct-bdd';
-import { InternalNode } from '../../src';
-import { findSimilarNode } from '../../src/find-similar-node';
-
-
-describe('find-similar-node.test.ts', () => {
-    it('should be equal to equal node of other bdd', () => {
-        const table = allEqualTable();
-        const bdd = createBddFromTruthTable(table);
-        const nodes = bdd.getNodesOfLevel(1);
-        const first: InternalNode = nodes.values().next().value;
-
-        const bdd2 = createBddFromTruthTable(table);
-        const nodes2 = bdd2.getNodesOfLevel(1);
-        const first2: InternalNode = nodes2.values().next().value;
-
-        const found = findSimilarNode(
-            first,
-            [first2]
-        );
-        assert.ok(found);
-    });
-    it('should not find itself', () => {
-        const table = allEqualTable();
-        const bdd = createBddFromTruthTable(table);
-        const nodes = bdd.getNodesOfLevel(1);
-        const first: InternalNode = nodes.values().next().value;
-
-        const found = findSimilarNode(
-            first,
-            [first]
-        );
-        assert.strictEqual(found, null);
-    });
-
-    it('should be not be equal to root node', () => {
-        const table = allEqualTable();
-        const bdd = createBddFromTruthTable(table);
-        const nodes = bdd.getNodesOfLevel(1);
-        const first: InternalNode = nodes.values().next().value;
-
-        const found = findSimilarNode(
-            first,
-            [bdd as any]
-        );
-        assert.strictEqual(found, null);
-    });
-});

package/test/unit/index.test.ts

@@ -1,6 +0,0 @@
-import './create-bdd-from-truth-table.test';
-import './find-similar-node.test';
-import './minimize.test';
-import './resolve.test';
-import './simple-bdd.test';
-import './optimize-brute-force.test';

package/test/unit/minimize.test.ts

@@ -1,145 +0,0 @@
-import * as assert from 'assert';
-import { createBddFromTruthTable } from '../../src/create-bdd-from-truth-table';
-import {
-    exampleTruthTable, allEqualTable, randomTable, UNKNOWN, randomUnknownTable
-} from '../helper/test-util';
-import { ensureCorrectBdd } from '../../src/ensure-correct-bdd';
-import { InternalNode, NonRootNode, LeafNode } from '../../src';
-
-describe('minimize.test.ts', () => {
-    describe('applyReductionRule()', () => {
-        it('should remove itself', () => {
-            const table = allEqualTable();
-            const bdd = createBddFromTruthTable(table);
-            const nodes: NonRootNode[] = bdd.getNodesOfLevel(2);
-            const first: InternalNode = nodes[0] as InternalNode;
-            ensureCorrectBdd(bdd);
-            first.applyReductionRule();
-            ensureCorrectBdd(bdd);
-            assert.ok(
-                (bdd as any).branches.getBranch('0').branches.getBranch('0').isLeafNode()
-            );
-            const second: InternalNode = nodes[1] as InternalNode;
-            second.applyReductionRule();
-            assert.ok(
-                (bdd as any).branches.getBranch('0').branches.getBranch('1').isLeafNode()
-            );
-            ensureCorrectBdd(bdd);
-        });
-        it('should work on deeper bdd itself', () => {
-            const table = allEqualTable(4);
-            const bdd = createBddFromTruthTable(table);
-            const nodes: NonRootNode[] = bdd.getNodesOfLevel(2);
-            const first: InternalNode = nodes[0] as InternalNode;
-            ensureCorrectBdd(bdd);
-            first.applyReductionRule();
-            ensureCorrectBdd(bdd);
-            assert.ok(
-                (bdd as any)
-                    .branches.getBranch('0')
-                    .branches.getBranch('0')
-                    .branches.getBranch('0').isLeafNode()
-            );
-        });
-    });
-    describe('applyEliminationRule()', () => {
-        it('should remove the found one', () => {
-            const table = allEqualTable();
-            const bdd = createBddFromTruthTable(table);
-            let nodes: NonRootNode[] = bdd.getNodesOfLevel(1);
-            const first: InternalNode = nodes[0] as InternalNode;
-            first.applyEliminationRule();
-            ensureCorrectBdd(bdd);
-            assert.strictEqual(
-                bdd.branches.getBranch('0').id,
-                bdd.branches.getBranch('1').id
-            );
-
-            nodes = bdd.getNodesOfLevel(1);
-            const second: InternalNode = nodes[0] as InternalNode;
-            second.applyEliminationRule();
-            ensureCorrectBdd(bdd);
-        });
-    });
-    describe('minimize()', () => {
-        it('should return a minimized version', () => {
-            const table = allEqualTable();
-            const bdd = createBddFromTruthTable(table);
-            bdd.minimize(false);
-            assert.ok((bdd as any).branches.getBranch('0').isLeafNode());
-            assert.ok((bdd as any).branches.getBranch('1').isLeafNode());
-            ensureCorrectBdd(bdd);
-        });
-        it('should not crash on random table', () => {
-            const table = exampleTruthTable();
-            table.set('000', 1);
-            table.set('001', 1);
-            table.set('010', 1);
-            const bdd = createBddFromTruthTable(table);
-            bdd.minimize();
-            assert.ok((bdd as any).branches.getBranch('0').branches.getBranch('0').isLeafNode());
-            ensureCorrectBdd(bdd);
-        });
-        it('should not crash on a really big table', () => {
-            const depth = 11;
-            const table = randomTable(depth);
-            const bdd = createBddFromTruthTable(table);
-            bdd.minimize();
-            ensureCorrectBdd(bdd);
-        });
-        it('random table should not have two equal branches', () => {
-            const depth = 9;
-            const table = randomTable(depth);
-            const bdd = createBddFromTruthTable(table);
-            bdd.minimize();
-            ensureCorrectBdd(bdd);
-            const leafNodes: LeafNode[] = bdd.getNodesOfLevel(depth) as LeafNode[];
-            leafNodes.forEach(leaf => {
-                const parents = leaf.parents.getAll();
-                parents.forEach(parent => {
-                    assert.notStrictEqual(
-                        (parent.branches.getBranch('0') as LeafNode).value,
-                        (parent.branches.getBranch('1') as LeafNode).value
-                    );
-                });
-            });
-        });
-    });
-    describe('countNodes()', () => {
-        it('should be smaller after minimize', () => {
-            const table = allEqualTable();
-            const bdd = createBddFromTruthTable(table);
-            const before = bdd.countNodes();
-            bdd.minimize();
-            const after = bdd.countNodes();
-            assert.ok(before > after);
-        });
-    });
-    describe('.removeIrrelevantLeafNodes()', () => {
-        it('should remove all irrelevant nodes', () => {
-            const table = exampleTruthTable(5);
-            table.set('00001', UNKNOWN);
-            table.set('00000', UNKNOWN);
-            table.set('00101', UNKNOWN);
-            const bdd = createBddFromTruthTable(table);
-            bdd.removeIrrelevantLeafNodes(UNKNOWN);
-            bdd.getLeafNodes().forEach(node => {
-                assert.notStrictEqual(
-                    UNKNOWN,
-                    node.value
-                );
-            });
-        });
-        it('should work on a big table', () => {
-            const table = randomUnknownTable(6);
-            const bdd = createBddFromTruthTable(table);
-            bdd.removeIrrelevantLeafNodes(UNKNOWN);
-            bdd.getLeafNodes().forEach(node => {
-                assert.notStrictEqual(
-                    UNKNOWN,
-                    node.value
-                );
-            });
-        });
-    });
-});

package/test/unit/optimize-brute-force.test.ts

@@ -1,114 +0,0 @@
-import * as assert from 'assert';
-import { createBddFromTruthTable } from '../../src/create-bdd-from-truth-table';
-import {
-    exampleTruthTable, allEqualTable, randomTable, UNKNOWN, randomUnknownTable, getResolverFunctions
-} from '../helper/test-util';
-import { ensureCorrectBdd } from '../../src/ensure-correct-bdd';
-import { InternalNode, NonRootNode, LeafNode, bddToMinimalString, minimalStringToSimpleBdd, resolveWithSimpleBdd } from '../../src';
-import { optimizeBruteForce, CompareResultsFunction } from '../../src/optimize-brute-force';
-import { bddToSimpleBdd } from '../../src/minimal-string/bdd-to-simple-bdd';
-
-describe('optimize-brute-force.test.ts', () => {
-    it('should return the same values when the order changed', async () => {
-        const depth = 8;
-        const truthTable = randomTable(depth);
-        const bdd = createBddFromTruthTable(truthTable);
-        const minimizedBdd = createBddFromTruthTable(truthTable);
-        minimizedBdd.minimize();
-
-        // run optimisation until a better bdd is found
-        let resortedBdd = minimizedBdd;
-        while (resortedBdd.countNodes() === minimizedBdd.countNodes()) {
-            const optimizedResult = await optimizeBruteForce({
-                truthTable,
-                iterations: 1
-            });
-            resortedBdd = optimizedResult.bdd;
-        }
-        // console.log(minimizedBdd.countNodes() + '  -  ' + resortedBdd.countNodes());
-        const resolvers = getResolverFunctions(depth, false);
-
-        for (const [key, value] of truthTable.entries()) {
-            const bddValue = bdd.resolve(resolvers, key);
-            const resortedBddValue = resortedBdd.resolve(resolvers, key);
-            const minimizedBddValue = minimizedBdd.resolve(resolvers, key);
-
-            if (
-                bddValue !== resortedBddValue ||
-                bddValue !== value ||
-                bddValue !== minimizedBddValue
-            ) {
-                console.log('value: ' + value);
-                console.log('minimizedBdd: ' + minimizedBddValue);
-                console.log('resortedBddValue: ' + resortedBddValue);
-                console.log('bddValue: ' + bddValue);
-                throw new Error('values not equal');
-            }
-        }
-    });
-    it('resorted bdds should work with simple bdd', async () => {
-        const depth = 7;
-        const truthTable = randomTable(depth);
-        const bdd = createBddFromTruthTable(truthTable);
-        const minimizedBdd = createBddFromTruthTable(truthTable);
-        minimizedBdd.minimize();
-
-        // run optimisation until a better bdd is found
-        let resortedBdd = minimizedBdd;
-        while (resortedBdd.countNodes() === minimizedBdd.countNodes()) {
-            const optimizedResult = await optimizeBruteForce({
-                truthTable,
-                iterations: 1
-            });
-            resortedBdd = optimizedResult.bdd;
-        }
-
-        const simpleBdd = bddToSimpleBdd(resortedBdd);
-        const minimalString = bddToMinimalString(resortedBdd);
-        const simpleBddFromMinimalString = minimalStringToSimpleBdd(minimalString);
-
-        assert.deepStrictEqual(
-            simpleBdd,
-            simpleBddFromMinimalString
-        );
-
-        const resolvers = getResolverFunctions(depth, false);
-        for (const [key, value] of truthTable.entries()) {
-            const bddValue = bdd.resolve(resolvers, key);
-            const minimizedBddValue = minimizedBdd.resolve(resolvers, key);
-            const resortedBddValue = resortedBdd.resolve(resolvers, key);
-            const simpleBddValue = resolveWithSimpleBdd(simpleBdd, resolvers, key);
-
-            if (
-                bddValue !== simpleBddValue ||
-                bddValue !== resortedBddValue ||
-                bddValue !== value ||
-                bddValue !== minimizedBddValue
-            ) {
-                console.log('value: ' + value);
-                console.log('simpleBddValue: ' + simpleBddValue);
-                console.log('minimizedBdd: ' + minimizedBddValue);
-                console.log('resortedBddValue: ' + resortedBddValue);
-                console.log('bddValue: ' + bddValue);
-                throw new Error('values not equal');
-            }
-        }
-    });
-    it('compareResults function could be async', async () => {
-        const depth = 5;
-        const truthTable = randomTable(depth);
-        const minimizedBdd = createBddFromTruthTable(truthTable);
-        minimizedBdd.minimize();
-
-        const compareResults: CompareResultsFunction = (a, b) => {
-            return Promise.resolve(a);
-        };
-
-        const optimizedResult = await optimizeBruteForce({
-            truthTable,
-            iterations: 5,
-            compareResults
-        });
-        assert.ok(optimizedResult.bdd);
-    });
-});

package/test/unit/resolve.test.ts

@@ -1,74 +0,0 @@
-import * as assert from 'assert';
-import { createBddFromTruthTable } from '../../src/create-bdd-from-truth-table';
-import {
-    exampleTruthTable, allEqualTable, randomTable, UNKNOWN, randomUnknownTable, getResolverFunctions
-} from '../helper/test-util';
-import { ensureCorrectBdd } from '../../src/ensure-correct-bdd';
-import { InternalNode, NonRootNode, LeafNode, ResolverFunctions, resolveWithSimpleBdd } from '../../src';
-import { bddToSimpleBdd } from '../../src/minimal-string/bdd-to-simple-bdd';
-
-describe('resolve.test.ts', () => {
-    it('should have the same values as the truth table', () => {
-        const size = 8;
-        const table = exampleTruthTable(size);
-        const bdd = createBddFromTruthTable(table);
-        const resolvers: ResolverFunctions = getResolverFunctions(size);
-
-        for (const [key, value] of table.entries()) {
-            const bddValue = bdd.resolve(resolvers, key);
-            assert.strictEqual(value, bddValue);
-        }
-    });
-    it('should have the same values after minimize', () => {
-        const size = 8;
-        const table = exampleTruthTable(size);
-        const bdd = createBddFromTruthTable(table);
-        const resolvers: ResolverFunctions = getResolverFunctions(size);
-
-        bdd.minimize();
-        for (const [key, value] of table.entries()) {
-            const bddValue = bdd.resolve(resolvers, key);
-            assert.strictEqual(value, bddValue);
-        }
-    });
-    it('should work with minimized random table', () => {
-        const size = 8;
-        const table = randomTable(size);
-        const bdd = createBddFromTruthTable(table);
-        const resolvers: ResolverFunctions = getResolverFunctions(size);
-
-        bdd.minimize();
-        for (const [key, value] of table.entries()) {
-            const bddValue = bdd.resolve(resolvers, key);
-            assert.strictEqual(value, bddValue);
-        }
-    });
-    it('bdd and simplebdd should resolve to the same value', () => {
-        const depth = 7;
-        const truthTable = randomTable(depth);
-        const bdd = createBddFromTruthTable(truthTable);
-        const minimizedBdd = createBddFromTruthTable(truthTable);
-        minimizedBdd.minimize();
-
-        const simpleBdd = bddToSimpleBdd(minimizedBdd);
-        const resolvers = getResolverFunctions(depth, false);
-
-        for (const [key, value] of truthTable.entries()) {
-            const bddValue = bdd.resolve(resolvers, key);
-            const minimizedBddValue = minimizedBdd.resolve(resolvers, key);
-            const simpleBddValue = resolveWithSimpleBdd(simpleBdd, resolvers, key);
-
-            if (
-                bddValue !== simpleBddValue ||
-                bddValue !== value ||
-                bddValue !== minimizedBddValue
-            ) {
-                console.log('value: ' + value);
-                console.log('simpleBddValue: ' + simpleBddValue);
-                console.log('minimizedBdd: ' + minimizedBddValue);
-                console.log('bddValue: ' + bddValue);
-                throw new Error('values not equal');
-            }
-        }
-    });
-});

package/test/unit/simple-bdd.test.ts

@@ -1,186 +0,0 @@
-import * as assert from 'assert';
-import { createBddFromTruthTable } from '../../src/create-bdd-from-truth-table';
-import { bddToSimpleBdd } from '../../src/minimal-string/bdd-to-simple-bdd';
-import {
-    exampleTruthTable,
-    randomTable,
-    UNKNOWN,
-    getResolverFunctions,
-    getBigTruthTable
-} from '../helper/test-util';
-import {
-    ResolverFunctions,
-    minimalStringToSimpleBdd,
-    bddToMinimalString,
-    resolveWithSimpleBdd,
-    SimpleBdd
-} from '../../src';
-
-describe('simple-bdd.test.ts', () => {
-    describe('.bddToSimpleBdd()', () => {
-        it('should create a correct simple bdd', () => {
-            const table = randomTable(3);
-            const bdd = createBddFromTruthTable(table);
-            const simpleBdd = bddToSimpleBdd(bdd);
-            const v1 = bdd
-                .branches.getBranch('0').asInternalNode()
-                .branches.getBranch('0').asInternalNode()
-                .branches.getBranch('0').asLeafNode().value;
-            const v2: any = (simpleBdd as any)[0][0][0];
-            assert.strictEqual(
-                v1, v2
-            );
-        });
-    });
-    describe('RootNode.toSimpleBdd()', () => {
-        const table = randomTable(3);
-        const bdd = createBddFromTruthTable(table);
-        const simpleBdd = bdd.toSimpleBdd();
-        const v1 = bdd
-            .branches.getBranch('0').asInternalNode()
-            .branches.getBranch('0').asInternalNode()
-            .branches.getBranch('0').asLeafNode().value;
-        const v2 = (simpleBdd as any)[0][0][0];
-        assert.strictEqual(
-            v1, v2
-        );
-    });
-    describe('.bddToMinimalString()', () => {
-        it('should create a string', () => {
-            const table = exampleTruthTable();
-            const bdd = createBddFromTruthTable(table);
-            const str = bddToMinimalString(bdd);
-            assert.ok(str.length > 4);
-            assert.ok(str.length < 300);
-        });
-        it('should create the same each time', () => {
-            const table = exampleTruthTable();
-            const bdd = createBddFromTruthTable(table);
-            const str = bddToMinimalString(bdd);
-            const str2 = bddToMinimalString(bdd);
-            assert.strictEqual(str, str2);
-        });
-    });
-    describe('.minimalStringToSimpleBdd()', () => {
-        it('parse the string', () => {
-            const table = exampleTruthTable(4);
-            const bdd = createBddFromTruthTable(table);
-            const str = bddToMinimalString(bdd);
-            const minimalBdd = minimalStringToSimpleBdd(str);
-
-            assert.strictEqual(
-                (minimalBdd as any)[0][0][0][0], 0
-            );
-            assert.strictEqual(
-                (minimalBdd as any)[0][0][0][1], 1
-            );
-            assert.strictEqual(
-                (minimalBdd as any)[0][0][0].l, 3
-            );
-        });
-        it('should be equal to the generated simple bdd', () => {
-            const table = randomTable(6);
-            const bdd = createBddFromTruthTable(table);
-            const str = bddToMinimalString(bdd);
-            const minimalBdd = minimalStringToSimpleBdd(str);
-            const simpleBdd = bddToSimpleBdd(bdd);
-            assert.deepStrictEqual(
-                minimalBdd,
-                simpleBdd
-            );
-        });
-    });
-    describe('.resolveWithSimpleBdd()', () => {
-        it('should resolve a value', () => {
-            const size = 5;
-            const table = randomTable(size);
-            const bdd = createBddFromTruthTable(table);
-            const str = bddToMinimalString(bdd);
-            const minimalBdd = minimalStringToSimpleBdd(str);
-            const resolvers: ResolverFunctions = getResolverFunctions(size);
-
-            const result = resolveWithSimpleBdd(
-                minimalBdd,
-                resolvers,
-                table.keys().next().value
-            );
-            assert.strictEqual(typeof result, 'number');
-        });
-        it('should have the same values as the truth table', () => {
-            const size = 5;
-            const table = exampleTruthTable(size);
-
-            const bigBdd = createBddFromTruthTable(table);
-            const minimizedBdd = createBddFromTruthTable(table);
-            minimizedBdd.removeIrrelevantLeafNodes(UNKNOWN);
-
-            const str = bddToMinimalString(minimizedBdd);
-            const minimalBdd = minimalStringToSimpleBdd(str);
-            const resolvers: ResolverFunctions = getResolverFunctions(size);
-
-            for (const [key, value] of table.entries()) {
-                if (value === UNKNOWN) {
-                    break;
-                }
-                const simpleBddValue = resolveWithSimpleBdd(
-                    minimalBdd,
-                    resolvers,
-                    key
-                );
-                const minimalBddValue = minimizedBdd.resolve(resolvers, key);
-                const bigBddValue = bigBdd.resolve(resolvers, key);
-                if (
-                    value !== simpleBddValue ||
-                    value !== minimalBddValue ||
-                    value !== bigBddValue
-                ) {
-                    console.log('value: ' + value);
-                    console.log('simpleBddValue: ' + simpleBddValue);
-
-                    console.log('minimalBddValue: ' + minimalBddValue);
-                    console.log('bigBddValue: ' + bigBddValue);
-
-                    throw new Error('values not equal');
-                }
-            }
-        });
-        it('should have the same values with a big truth table', () => {
-            const table = getBigTruthTable();
-            const bigBdd = createBddFromTruthTable(table);
-            const minimizedBdd = createBddFromTruthTable(table);
-            minimizedBdd.removeIrrelevantLeafNodes(UNKNOWN);
-
-            const str = bddToMinimalString(minimizedBdd);
-            const minimalBdd = minimalStringToSimpleBdd(str);
-            const resolvers: ResolverFunctions = getResolverFunctions(17);
-            for (const [key, value] of table.entries()) {
-                if (value === UNKNOWN) {
-                    break;
-                }
-                const simpleBddValue = resolveWithSimpleBdd(
-                    minimalBdd,
-                    resolvers,
-                    key
-                );
-                const minimalBddValue = minimizedBdd.resolve(resolvers, key);
-                const bigBddValue = bigBdd.resolve(resolvers, key);
-                if (
-                    value !== simpleBddValue ||
-                    value !== minimalBddValue ||
-                    value !== bigBddValue
-                ) {
-                    console.log('key: ' + key);
-                    console.log('value: ' + value);
-                    console.log('simpleBddValue: ' + simpleBddValue);
-
-                    console.log('minimalBddValue: ' + minimalBddValue);
-                    console.log('bigBddValue: ' + bigBddValue);
-
-                    minimizedBdd.log();
-
-                    throw new Error('values not equal');
-                }
-            }
-        });
-    });
-});

package/tsconfig.json

@@ -1,38 +0,0 @@
-{
-    "compilerOptions": {
-        "removeComments": false,
-        "preserveConstEnums": true,
-        "sourceMap": true,
-        "strictNullChecks": true,
-        "noImplicitAny": true,
-        "strict": true,
-        "noImplicitReturns": true,
-        "noImplicitThis": true,
-        "downlevelIteration": true,
-        "moduleResolution": "node",
-        "esModuleInterop": true,
-        "declaration": true,
-        "target": "ES2017",
-        "outDir": "./dist/lib",
-        "lib": [
-            "es7",
-            "dom"
-        ]
-    },
-    "formatCodeOptions": {
-        "indentSize": 2,
-        "tabSize": 2
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "node_modules",
-        "**/node_modules/*",
-        "dist",
-        "src/logic-generator/logic-map-output",
-        "**.txt",
-        "**.json"
-    ],
-    "compileOnSave": false
-}