@live-change/flatten-interval-tree 0.8.26

package/src/classes/node.js

@@ -0,0 +1,97 @@
+/**
+ * Created by Alex Bol on 4/1/2017.
+ */
+
+'use strict';
+
+import Interval from './interval.js';
+import {RB_TREE_COLOR_RED, RB_TREE_COLOR_BLACK} from '../utils/constants.js';
+
+function min(a,b) {
+    return a < b ? a : b
+}
+function max(a,b) {
+    return a > b ? a : b
+}
+
+class Node {
+    constructor(key = undefined, value = undefined,
+                left = null, right = null, parent = null, color = RB_TREE_COLOR_BLACK) {
+        this.left = left;                     // reference to left child node
+        this.right = right;                   // reference to right child node
+        this.parent = parent;                 // reference to parent node
+        this.color = color;
+
+        this.item = {key: key, value: value};   // key is supposed to be instance of Interval
+
+        /* If not, this should by an array of two numbers */
+        if (key && key instanceof Array && key.length == 2) {
+            this.item.key = new Interval(min(key[0], key[1]), max(key[0], key[1]));
+        }
+        this.max = this.item.key ? this.item.key.max : undefined;
+    }
+
+    isNil() {
+        return (this.item.key === undefined && this.item.value === undefined &&
+            this.left === null && this.right === null && this.color === RB_TREE_COLOR_BLACK);
+    }
+
+    less_than(other_node) {
+        if (this.item.value && other_node.item.value) {
+            let item_less_than = this.item.value.less_than ? this.item.value.less_than(other_node.item.value) :
+                this.item.value < other_node.item.value;
+            return this.item.key.less_than(other_node.item.key) ||
+                this.item.key.equal_to((other_node.item.key)) && item_less_than;
+        }
+        else {
+            return this.item.key.less_than(other_node.item.key);
+        }
+    }
+
+    equal_to(other_node) {
+        let value_equal = true;
+        if (this.item.value && other_node.item.value) {
+            value_equal = this.item.value.equal_to ? this.item.value.equal_to(other_node.item.value) :
+                this.item.value == other_node.item.value;
+        }
+        return this.item.key.equal_to(other_node.item.key) && value_equal;
+    }
+
+    intersect(other_node) {
+        return this.item.key.intersect(other_node.item.key);
+    }
+
+    copy_data(other_node) {
+        this.item.key = other_node.item.key.clone();
+        this.item.value = other_node.item.value;
+    }
+
+    update_max() {
+        // use key (Interval) max property instead of key.high
+        this.max = this.item.key ? this.item.key.max : undefined;
+        if (this.right && this.right.max) {
+            const comparable_max = this.item.key.constructor.comparable_max;  // static method
+            this.max = comparable_max(this.max, this.right.max);
+        }
+        if (this.left && this.left.max) {
+            const comparable_max = this.item.key.constructor.comparable_max;  // static method
+            this.max = comparable_max(this.max, this.left.max);
+        }
+    }
+
+    // Other_node does not intersect any node of left subtree, if this.left.max < other_node.item.key.low
+    not_intersect_left_subtree(search_node) {
+        const comparable_less_than = this.item.key.constructor.comparable_less_than;  // static method
+        let high = this.left.max.high !== undefined ? this.left.max.high : this.left.max;
+        return comparable_less_than(high, search_node.item.key.low);
+    }
+
+    // Other_node does not intersect right subtree if other_node.item.key.high < this.right.key.low
+    not_intersect_right_subtree(search_node) {
+        const comparable_less_than = this.item.key.constructor.comparable_less_than;  // static method
+        let low = this.right.max.low !== undefined ? this.right.max.low : this.right.item.key.low;
+        return comparable_less_than(search_node.item.key.high, low);
+    }
+};
+
+export default Node;

package/src/utils/constants.js

@@ -0,0 +1,16 @@
+/**
+ * Created by Alex Bol on 3/28/2017.
+ */
+
+'use strict';
+
+// module.exports = {
+//     RB_TREE_COLOR_RED: 0,
+//     RB_TREE_COLOR_BLACK: 1
+// };
+
+const RB_TREE_COLOR_RED = 0;
+const RB_TREE_COLOR_BLACK = 1;
+
+export { RB_TREE_COLOR_RED, RB_TREE_COLOR_BLACK }
+

package/test/intervalTree.js

@@ -0,0 +1,232 @@
+/**
+ * Created by Alex Bol on 3/31/2017.
+ */
+
+import { expect } from 'chai';
+import IntervalTree from '../index';
+import {Interval} from "../index";
+
+// import IntervalTree from '../dist/interval-tree.esm';
+
+describe('#IntervalTree', function() {
+    it('Create new instanse of IntervalTree ', function () {
+        let tree = new IntervalTree();
+        expect(tree).to.be.an.instanceof(IntervalTree);
+    });
+    it('Size of empty tree will be 0', function () {
+        let tree = new IntervalTree();
+        expect(tree.size).to.equal(0);
+    });
+    it('May insert one entry with key - array of numbers', function () {
+        let tree = new IntervalTree();
+        tree.insert([1,2]);
+        expect(tree.size).to.equal(1);
+    });
+    it('May insert many entries with key - array of numbers', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let int of ints) tree.insert(int);
+        expect(tree.size).to.equal(5);
+    });
+    it('May insert entries while transforming numeric pair into Interval', function () {
+        let tree = new IntervalTree();
+        let pairs = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let pair of pairs) tree.insert(new Interval(pair[0], pair[1]));
+        expect(tree.size).to.equal(5);
+        expect(tree.keys).to.deep.equal([[1,1],[1,4],[5,7],[5,12],[6,8]]);
+    });
+    it('May return array of keys sorted', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let int of ints) tree.insert(int);
+        expect(tree.keys).to.deep.equal([[1,1],[1,4],[5,7],[5,12],[6,8]]);
+    });
+    it('May test if node entry exist after insertion', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        expect(tree.keys).to.deep.equal([[1,1],[1,4],[5,7],[5,12],[6,8]]);
+        for (let i=0; i < ints.length; i++) {
+            expect(tree.exist(ints[i], "val"+i)).to.equal(true);
+        }
+    });
+    it('May not find value when key was not inserted', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        expect(tree.exist([2,4],"val")).to.be.false;        // wrong interval
+        expect(tree.exist([1,4],"val2")).to.be.false;       // wrong value
+    });
+    it('May not find entry after key was deleted', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        tree.remove([1,4],"val1");
+
+        expect(tree.size).to.equal(4);
+        expect(tree.keys).to.deep.equal([[1,1],[5,7],[5,12],[6,8]]);
+        expect(tree.exist([1,4])).to.be.false;
+    });
+    it('May become empty after all entries will be deleted', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        tree.remove([6,8],"val0");
+        tree.remove([1,4],"val1");
+        tree.remove([5,12],"val2");
+        tree.remove([1,1],"val3");
+        tree.remove([5,7],"val4");
+
+        expect(tree.size).to.equal(0);
+        expect(tree.isEmpty()).to.be.true;
+    });
+    it('May return array of items', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+
+        let items = tree.items;
+        let keys = [];
+        for (let item of items) {
+            keys.push(item)
+        }
+        expect(items.length).to.equal(5);
+        expect(keys.length).to.equal(5);
+        expect(tree.keys).to.deep.equal([[1,1],[1,4],[5,7],[5,12],[6,8]]);
+    });
+    it('May transform tree to another tree using map', function () {
+        let tree1 = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree1.insert(ints[i],"val"+i);
+
+        let tree2 = tree1.map( (value, key) => (key.high-key.low) );
+
+        expect(tree2.size).to.equal(5);
+        expect(tree2.keys).to.deep.equal([[1,1],[1,4],[5,7],[5,12],[6,8]]);
+        expect(tree2.values).to.deep.equal([0,3,2,7,2]);
+    });
+
+    it('May search interval and return array of values', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,4],[5,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        expect(tree.search([2,3])).to.deep.equal(['val1']);
+    });
+    it('May search interval and return array of custom transformed objects', function () {
+        const composers = [
+            {name: "Ludwig van Beethoven", period: [1770,1827]},
+            {name: "Johann Sebastian Bach", period: [1685, 1750]},
+            {name: "Wolfgang Amadeus Mozart", period: [1756, 1791]},
+            {name: "Johannes Brahms", period: [1833, 1897]},
+            {name: "Richard Wagner", period: [1813, 1883]},
+            {name: "Claude Debussy", period: [1862, 1918]},
+            {name: "Pyotr Ilyich Tchaikovsky", period: [1840, 1893]},
+            {name: "Frédéric Chopin", period: [1810, 1849]},
+            {name: "Joseph Haydn", period: [1732, 1809]},
+            {name: "Antonio Vivaldi", period: [1678, 1741]}
+        ];
+        const tree = new IntervalTree();
+        for (let composer of composers)
+            tree.insert(composer.period, composer.name);
+
+        const searchRes = tree.search( [1600,1700],
+            (name, period) => {return `${name} (${period.low}-${period.high})`});
+        expect(searchRes.length).to.equal(2);
+        expect(searchRes[0]).to.equal("Antonio Vivaldi (1678-1741)");
+        expect(searchRes[1]).to.equal("Johann Sebastian Bach (1685-1750)");
+    });
+    it('May return empty array when search interval does not intersect any', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,2],[7,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        expect(tree.search([3,4])).to.deep.equal([]);
+    });
+    it('Each red node has exactly two black child nodes', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,2],[7,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        expect(tree.testRedBlackProperty()).to.equal(true);
+    });
+    it('Each path from root to nil node has same black height', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,2],[7,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        let height = (tree) => {
+            return tree.testBlackHeightProperty(tree.root);
+        };
+        expect(height(tree)).to.equal(3);
+    });
+    it('Same black height property preserved while nodes deleted', function () {
+        let tree = new IntervalTree();
+        let ints = [[6,8],[1,2],[7,12],[1,1],[5,7]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        let height = (tree) => {
+            return tree.testBlackHeightProperty(tree.root);
+        };
+        let h;
+        tree.remove([1,1],"val3");
+        // h = height(tree);
+        expect(height(tree)).to.equal(3);
+        expect(tree.testRedBlackProperty()).to.equal(true);
+
+        tree.remove([5,7],"val4");
+        expect(height(tree)).to.equal(3);
+        expect(tree.testRedBlackProperty()).to.equal(true);
+
+        tree.remove([1,2],"val1");
+        expect(tree.testRedBlackProperty()).to.equal(true);
+        expect(height(tree)).to.equal(2);
+
+        tree.remove([6,8],"val0");
+        expect(tree.testRedBlackProperty()).to.equal(true);
+        expect(height(tree)).to.equal(2);
+
+        tree.remove([7,12],"val2");
+        expect(tree.testRedBlackProperty()).to.equal(true);
+    });
+    it("Fix issue #9", function() {
+        function setupTreeAndSearch(intervals, searchInterval) {
+            let tree = new IntervalTree();
+
+            for (let i=0; i < intervals.length; i++) {
+                tree.insert(intervals[i],"val"+i);
+            }
+
+            return tree.search(searchInterval);
+        }
+
+        let resp1 = setupTreeAndSearch(
+            [[1,1], [1,4], [5,6], [5.5,7], [7,8]],
+            [5.5, 5.7]
+        );
+        expect(resp1).to.be.deep.equal(["val2", "val3"]);
+
+        let resp2 = setupTreeAndSearch(
+            [[1,1], [1,4], [5,6], [6,7], [7,8]],
+            [5.5, 5.7]
+        );
+        expect(resp2).to.be.deep.equal(["val2"]);
+    });
+    it('Low or high can be 0', function () {
+        let tree = new IntervalTree();
+        let ints = [[0,0],[0,0],[1,1],[0,0]];
+        for (let i=0; i < ints.length; i++) tree.insert(ints[i],"val"+i);
+        expect(tree.search([0,0])).to.deep.equal(['val0','val1','val3']);
+    });
+    it("Fix issue #15 Unable to remove/find some of the nodes", function() {
+        const intervalTree3 = new IntervalTree();
+
+        intervalTree3.insert([2, 5], 10);
+        intervalTree3.insert([2, 5], 20);
+        intervalTree3.insert([2, 5], 30);
+        intervalTree3.insert([2, 5], 40);
+        intervalTree3.insert([2, 5], 50);
+
+        expect(intervalTree3.exist([2, 5], 10)).to.be.true;
+        expect(intervalTree3.exist([2, 5], 20)).to.be.true;
+        expect(intervalTree3.exist([2, 5], 30)).to.be.true;
+        expect(intervalTree3.exist([2, 5], 40)).to.be.true;
+        expect(intervalTree3.exist([2, 5], 50)).to.be.true;
+        expect(intervalTree3.exist([2, 5], 25)).to.be.false;
+    });
+});

package/test/node.js

@@ -0,0 +1,64 @@
+/**
+ * Created by Alex Bol on 3/30/2017.
+ */
+
+'use strict';
+
+import { expect } from 'chai';
+import Node from '../src/classes/node';
+
+describe('#RedBlackTree Node', function() {
+    it('Node class exist when required', function () {
+        expect(Node).to.exist;
+    });
+    it('Node class required without traits has default traits defined', function () {
+        expect(Node.prototype.less_than).to.be.a('function');
+        expect(Node.prototype.equal_to).to.be.a('function');
+        expect(Node.prototype.copy_data).to.be.a('function');
+        expect(Node.prototype.update_max).to.be.a('function');
+    });
+    it('May create new default instance of Node', function () {
+        let node = new Node();
+        expect(node).to.be.an.instanceof(Node);
+    });
+    it('May create new instance of Node', function () {
+        let node = new Node([1,3], "1");
+        expect(node.item).to.be.deep.equal({key:{low:1, high:3}, value:"1"});
+    });
+    it('May compare intervals: [0,1] less than [1,3]', function () {
+        let node1 = new Node([0,1]);
+        let node2 = new Node([1,3]);
+        expect(node1.less_than(node2)).to.equal(true);
+    });
+    it('May compare intervals: [0,5] less than [1,3]', function () {
+        let node1 = new Node([0,5]);
+        let node2 = new Node([1,3]);
+        expect(node1.less_than(node2)).to.equal(true);
+    });
+    it('May compare intervals: [0,2] less than [0,3]', function () {
+        let node1 = new Node([0,2]);
+        let node2 = new Node([0,3]);
+        expect(node1.less_than(node2)).to.equal(true);
+    });
+    it('May compare intervals: [1,4] is not less than [0,3]', function () {
+        let node1 = new Node([1,4]);
+        let node2 = new Node([0,3]);
+        expect(node1.less_than(node2)).to.equal(false);
+    });
+    it('May compare intervals: [1,4] is not equal to [0,3]', function () {
+        let node1 = new Node([1,4]);
+        let node2 = new Node([0,3]);
+        expect(node1.equal_to(node2)).to.equal(false);
+    });
+    it('May compare intervals: [0,3] equal to [0,3]', function () {
+        let node1 = new Node([0,3]);
+        let node2 = new Node([0,3]);
+        expect(node1.equal_to(node2)).to.equal(true);
+    });
+    it('May compare {key, value}: {[0,3], "1"} is not equal to {[0,3], "2"', function () {
+        let node1 = new Node([0,3],"1");
+        let node2 = new Node([0,3], "2");
+        expect(node1.equal_to(node2)).to.equal(false);
+    });
+});
+