├── .bmp.yml
├── .gitignore
├── .gitignore-dist
├── Gruntfile.coffee
├── LICENSE
├── README.md
├── dev-tools
    ├── distribute
    ├── gh-pages
    └── push-to-master
├── index.coffee
├── index.js
├── package.json
├── spec
    └── lib
    │   ├── interval-tree.coffee
    │   ├── interval.coffee
    │   ├── node.coffee
    │   ├── sorted-list.coffee
    │   └── util.coffee
└── src
    ├── lib
        ├── interval-tree.coffee
        ├── interval.coffee
        ├── node.coffee
        ├── point.coffee
        ├── sorted-list.coffee
        └── util.coffee
    └── web-entry.coffee


/.bmp.yml:
--------------------------------------------------------------------------------
1 | ---
2 | version: 1.1.0
3 | files:
4 |   package.json: '"version": "%.%.%",'
5 |   Gruntfile.coffee: currentVersion = 'v%.%.%'
6 |   dev-tools/distribute: VERSION="%.%.%"
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.csv
 2 | *.dat
 3 | *.iml
 4 | *.log
 5 | *.out
 6 | *.pid
 7 | *.seed
 8 | *.sublime-*
 9 | *.swo
10 | *.swp
11 | *.tgz
12 | *.xml
13 | .DS_Store
14 | .idea
15 | .project
16 | .strong-pm
17 | coverage
18 | node_modules
19 | npm-debug.log
20 | dist
21 | bower_components
22 | doc
23 | 


--------------------------------------------------------------------------------
/.gitignore-dist:
--------------------------------------------------------------------------------
 1 | *.csv
 2 | *.dat
 3 | *.iml
 4 | *.log
 5 | *.out
 6 | *.pid
 7 | *.seed
 8 | *.sublime-*
 9 | *.swo
10 | *.swp
11 | *.tgz
12 | *.xml
13 | .DS_Store
14 | .idea
15 | .project
16 | .strong-pm
17 | coverage
18 | node_modules
19 | npm-debug.log
20 | 


--------------------------------------------------------------------------------
/Gruntfile.coffee:
--------------------------------------------------------------------------------
 1 | currentVersion = 'v1.1.0'
 2 | module.exports = (grunt) ->
 3 | 
 4 |     grunt.config.init
 5 | 
 6 |         'mocha-chai-sinon':
 7 |             spec:
 8 |                 src: [
 9 |                     'spec/lib/*.coffee'
10 |                 ]
11 |                 options:
12 |                     ui: 'bdd'
13 |                     reporter: 'spec'
14 |                     require: 'coffee-script/register'
15 | 
16 |             single:
17 |                 src: [
18 |                     grunt.option('file') ? 'spec/lib/interval-tree.coffee'
19 |                 ]
20 |                 options:
21 |                     ui: 'bdd'
22 |                     reporter: 'spec'
23 |                     require: 'coffee-script/register'
24 | 
25 | 
26 |         yuidoc:
27 |             options:
28 |                 paths: ['src']
29 |                 syntaxtype: 'coffee'
30 |                 extension: '.coffee'
31 |             master:
32 |                 options:
33 |                     outdir: 'doc'
34 | 
35 | 
36 |         coffee:
37 |             dist:
38 |                 expand: true
39 |                 cwd: 'src/lib'
40 |                 src: ['**/*.coffee']
41 |                 dest: 'dist/lib/'
42 |                 ext: '.js'
43 |                 extDot: 'first'
44 |                 options:
45 |                     bare: true
46 | 
47 | 
48 | 
49 |     grunt.registerTask 'web',  ->
50 |         done = @async()
51 |         browserify = require('browserify')
52 | 
53 |         b = browserify './src/web-entry.coffee',
54 |             extensions: '.coffee'
55 | 
56 |         b.transform('coffeeify')
57 | 
58 |         b.bundle (err, buf) ->
59 |             require('fs').writeFileSync 'dist/interval-tree.js', buf.toString()
60 |             done()
61 | 
62 | 
63 |     grunt.loadNpmTasks 'grunt-mocha-chai-sinon'
64 |     grunt.loadNpmTasks 'grunt-contrib-yuidoc'
65 |     grunt.loadNpmTasks 'grunt-contrib-coffee'
66 | 
67 |     grunt.registerTask 'default', 'mocha-chai-sinon:spec'
68 |     grunt.registerTask 'single', 'mocha-chai-sinon:single'
69 |     grunt.registerTask 'build', ['coffee:dist']
70 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | (The MIT License)
 2 | 
 3 | Copyright (c) 2015 SHIN Suzuki <shinout310@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining
 6 | a copy of this software and associated documentation files (the
 7 | 'Software'), to deal in the Software without restriction, including
 8 | without limitation the rights to use, copy, modify, merge, publish,
 9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![Circle CI](https://circleci.com/gh/shinout/interval-tree2.svg?style=svg)](https://circleci.com/gh/shinout/interval-tree2)
  2 | 
  3 | # interval-tree2
  4 | 
  5 | interval tree in JavaScript (source is written in CoffeeScript)
  6 | 
  7 | improves previous [interval-tree](https://github.com/shinout/interval-tree)
  8 | 
  9 | more maintenanceability with [CoffeeScript](http://coffeescript.org/) OOP.
 10 | 
 11 | more robustness with [mocha](http://mochajs.org), [CircleCI](https://circleci.com/gh/shinout/interval-tree2)
 12 | 
 13 | 
 14 | ## API Documentation
 15 | 
 16 | [latest API documentation Page (YUIDoc)](http://shinout.github.io/interval-tree2/doc/index.html)
 17 | 
 18 | 
 19 | ## installation
 20 | 
 21 | ```bash
 22 | $ npm install interval-tree2
 23 | ```
 24 | 
 25 | ## usage
 26 | 
 27 | ### require
 28 | 
 29 | ```js
 30 | 
 31 | var IntervalTree = require('interval-tree2');
 32 | ```
 33 | 
 34 | when using in web, use `dist/interval-tree.js` in this module.
 35 | 
 36 | ```html
 37 | <script src="dist/interval-tree.js"></scirpt>
 38 | ```
 39 | 
 40 | 
 41 | ### create
 42 | 
 43 | ```js
 44 | var itree = new IntervalTree(300); // 300 : the center of the tree
 45 | ```
 46 | 
 47 | 
 48 | ### add interval data
 49 | 
 50 | ```js
 51 | itree.add(22, 56,  'foo'); // 'foo' is the id of the interval data
 52 | itree.add(44, 199, 'bar'); // 'bar' is the id of the interval data
 53 | itree.add(1, 38); // id is automatically set when not given
 54 | ```
 55 | 
 56 | 
 57 | ### search by point: get overlapped intervals from one point
 58 | 
 59 | ```js
 60 | var intervals = itree.search(103);
 61 | ```
 62 | or 
 63 | 
 64 | ```js
 65 | var intervals = itree.pointSearch(103);
 66 | ```
 67 | 
 68 | ```js
 69 | intervals.forEach(function(interval) {
 70 |   console.log(interval.start); // overlapped interval start position
 71 |   console.log(interval.end);   // overlapped interval end position
 72 |   console.log(interval.id);    // id of the overlapped interval
 73 | });
 74 | 
 75 | ```
 76 | 
 77 | 
 78 | ### search by range: get overlapped intervals from a range
 79 | 
 80 | ```js
 81 | var intervals2 = itree.search(103, 400);
 82 | ```
 83 | 
 84 | or 
 85 | 
 86 | ```js
 87 | var intervals2 = itree.rangeSearch(103, 400);
 88 | ```
 89 | 
 90 | 
 91 | ```js
 92 | intervals2.forEach(function(interval) {
 93 |   console.log(interval.start); // overlapped interval start position
 94 |   console.log(interval.end);   // overlapped interval end position
 95 |   console.log(interval.id);    // id of the overlapped interval
 96 | });
 97 | 
 98 | ```
 99 | 
100 | ### remove an interval by id
101 | 
102 | ```js
103 | itree.remove('foo');
104 | ```
105 | 
106 | 


--------------------------------------------------------------------------------
/dev-tools/distribute:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | VERSION="1.1.0"
 4 | 
 5 | echo "prepare for distribution"
 6 | 
 7 | real_run=$1
 8 | 
 9 | git checkout -b dist${VERSION}
10 | 
11 | cp .gitignore-dist .gitignore
12 | 
13 | grunt build
14 | 
15 | 
16 | if [ "$real_run" = "run" ]; then
17 |     echo bmp -c
18 |     bmp -c
19 |     echo npm publish
20 |     npm publish
21 | else
22 |     echo "  $0 \"run\" will publish in npm and push git tag.
23 |         Instead, do the following commands.
24 | 
25 |         bmp -c
26 |         npm publish
27 |         "
28 | 
29 | fi
30 | 


--------------------------------------------------------------------------------
/dev-tools/gh-pages:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | 
 4 | echo "push to gh-pages"
 5 | 
 6 | git checkout gh-pages
 7 | git rebase master
 8 | grunt yuidoc
 9 | git add doc
10 | git commit -m 'update doc'
11 | git push -f origin gh-pages
12 | git checkout master
13 | 


--------------------------------------------------------------------------------
/dev-tools/push-to-master:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | 
 4 | echo "push to master, gh-pages"
 5 | 
 6 | 
 7 | git checkout master
 8 | 
 9 | git push origin master
10 | 
11 | ./dev-tools/gh-pages
12 | 


--------------------------------------------------------------------------------
/index.coffee:
--------------------------------------------------------------------------------
1 | module.exports = require './src/lib/interval-tree'
2 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require('./dist/lib/interval-tree');
2 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "interval-tree2",
 3 |   "version": "1.1.0",
 4 |   "description": "interval tree in javascript",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "grunt"
 8 |   },
 9 |   "repository": {
10 |     "type": "git",
11 |     "url": "https://github.com/shinout/interval-tree2.git"
12 |   },
13 |   "bugs": {
14 |     "url": "https://github.com/shinout/interval-tree2/issues"
15 |   },
16 |   "homepage": "https://github.com/shinout/interval-tree2",
17 |   "keywords": [
18 |     "tree",
19 |     "interval",
20 |     "range",
21 |     "algorithm"
22 |   ],
23 |   "author": "SHIN Suzuki <shinout310@gmail.com>",
24 |   "license": "MIT",
25 |   "dependencies": {},
26 |   "devDependencies": {
27 |     "browserify": "^11.1.0",
28 |     "coffeeify": "^1.1.0",
29 |     "grunt": "^0.4.5",
30 |     "grunt-contrib-coffee": "^0.13.0",
31 |     "grunt-contrib-yuidoc": "^0.7.0",
32 |     "grunt-mocha-chai-sinon": "0.0.9"
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/spec/lib/interval-tree.coffee:
--------------------------------------------------------------------------------
  1 | 
  2 | IntervalTree = require '../../src/lib/interval-tree'
  3 | Interval     = require '../../src/lib/interval'
  4 | Node         = require '../../src/lib/node'
  5 | 
  6 | 
  7 | describe 'IntervalTree', ->
  8 | 
  9 |     beforeEach ->
 10 | 
 11 |         @iTree = new IntervalTree(500)
 12 | 
 13 | 
 14 |     it 'throws an error when null is passed to constructor', ->
 15 | 
 16 |         expect(-> new IntervalTree(null)).to.throw 'IntervalTree: center is required.'
 17 | 
 18 | 
 19 | 
 20 |     describe 'add', ->
 21 | 
 22 |         it 'throws an error when non-number value is given to "start"', ->
 23 |             expect(-> @iTree.add('123', 39)).to.throw Error
 24 | 
 25 | 
 26 |         it 'throws an error when non-number value is given to "end"', ->
 27 |             expect(-> @iTree.add(123, '39')).to.throw Error
 28 | 
 29 | 
 30 |         it 'throws an error when duplicated id is given', ->
 31 |             @iTree.add(123, 345, 'foo')
 32 |             expect(-> @iTree.add(1234, 3457, 'foo')).to.throw Error
 33 | 
 34 | 
 35 |         it 'adds data with automatically-inserted id', ->
 36 | 
 37 |             interval = @iTree.add(12, 39)
 38 | 
 39 |             expect(interval).to.be.instanceof Interval
 40 |             expect(interval).to.have.property('id')
 41 | 
 42 |             id = interval.id
 43 | 
 44 |             expect(@iTree.intervalsById[id]).to.equal interval
 45 |             expect(@iTree.nodesById[id]).to.be.instanceof Node
 46 | 
 47 | 
 48 |         it 'adds data with custom id', ->
 49 | 
 50 |             interval = @iTree.add(-100, 10000, 'foo')
 51 | 
 52 |             expect(interval).to.be.instanceof Interval
 53 |             expect(interval).to.have.property('id', 'foo')
 54 | 
 55 |             expect(@iTree.intervalsById.foo).to.equal interval
 56 |             expect(@iTree.nodesById.foo).to.be.instanceof Node
 57 | 
 58 | 
 59 | 
 60 |     describe 'search', ->
 61 | 
 62 |         it 'throws an error when 1st argument is not a number', ->
 63 | 
 64 |             expect(-> @iTree.search('123')).to.throw Error
 65 | 
 66 | 
 67 |         it 'runs point search when one argument is given', (done) ->
 68 | 
 69 |             @iTree.pointSearch = (val) ->
 70 |                 expect(val).to.equal 100
 71 |                 done()
 72 | 
 73 |             @iTree.search(100)
 74 | 
 75 |         it 'throws an error when 2nd argument is given and not a number', ->
 76 | 
 77 |             expect(-> @iTree.search(70, '123')).to.throw Error
 78 | 
 79 | 
 80 |         it 'runs range search when two arguments are given', (done) ->
 81 | 
 82 |             @iTree.rangeSearch = (val1, val2) ->
 83 |                 expect(val1).to.equal 100
 84 |                 expect(val2).to.equal 200
 85 |                 done()
 86 | 
 87 |             @iTree.search(100, 200)
 88 | 
 89 | 
 90 | 
 91 |     describe 'pointSearch', ->
 92 | 
 93 |         it 'returns overlapping intervals ', ->
 94 | 
 95 |             @iTree.add 499, 500, '499-500'
 96 |             @iTree.add 499, 501, '499-501'
 97 |             @iTree.add 500, 501, '500-501'
 98 |             @iTree.add 501, 502, '501-502'
 99 |             @iTree.add -31, 502, '-31-502'
100 | 
101 |             results = @iTree.pointSearch(500)
102 | 
103 |             expect(results).to.be.instanceof Array
104 |             expect(results[0]).to.be.instanceof Interval
105 |             expect(results).to.have.length 4
106 | 
107 |             for interval in results
108 |                 expect(interval.start).to.be.below 501
109 |                 expect(interval.end).to.be.above 499
110 | 
111 | 
112 |         it 'returns overlapping intervals ', ->
113 | 
114 |             @iTree.add 599, 600, '599-600'
115 |             @iTree.add 599, 601, '599-601'
116 |             @iTree.add 600, 601, '600-601'
117 |             @iTree.add 601, 602, '601-602'
118 |             @iTree.add -31, 602, '-31-602'
119 | 
120 |             results = @iTree.pointSearch(600)
121 | 
122 |             expect(results).to.be.instanceof Array
123 |             expect(results[0]).to.be.instanceof Interval
124 |             expect(results).to.have.length 4
125 | 
126 | 
127 |             for interval in results
128 |                 expect(interval.start).to.be.below 601
129 |                 expect(interval.end).to.be.above 599
130 | 
131 | 
132 | 
133 | 
134 | 
135 |     describe 'rangeSearch', ->
136 | 
137 |         it 'searches intervals by range', ->
138 | 
139 |             @iTree.add 498, 499, '498-499' # x
140 |             @iTree.add 499, 500, '499-500' # o
141 |             @iTree.add 499, 501, '499-501' # o
142 |             @iTree.add 500, 501, '500-501' # o
143 |             @iTree.add 501, 502, '500-502' # o
144 |             @iTree.add 509, 510, '509-510' # o
145 |             @iTree.add 509, 511, '509-511' # o
146 |             @iTree.add 510, 511, '510-511' # o
147 |             @iTree.add 511, 512, '511-512' # x
148 |             @iTree.add -31, 999, '-31-999' # o
149 | 
150 |             results = @iTree.rangeSearch(500, 510)
151 | 
152 |             resultIds = (result.id for result in results)
153 | 
154 |             expect(results).to.be.instanceof Array
155 |             expect(results[0]).to.be.instanceof Interval
156 |             expect(results).to.have.length 8
157 | 
158 | 
159 |             for id, interval of @iTree.intervalsById
160 | 
161 |                 { start, end, id } = interval
162 | 
163 |                 if id in resultIds
164 | 
165 |                     if start < 500
166 |                         expect(end).to.be.above 499
167 | 
168 |                     else if end > 510
169 |                         expect(start).to.be.below 511
170 | 
171 |                     else
172 |                         expect(start).within 500, 510
173 |                         expect(end).within 500, 510
174 | 
175 |                 else
176 |                     expect(start > 510 or end < 500).to.be.true
177 | 
178 | 
179 | 
180 |     describe 'remove', ->
181 | 
182 |         it 'removes an interval by id', ->
183 | 
184 |             @iTree.add 498, 499, 'foo'
185 |             @iTree.add 498, 499, 'bar'
186 | 
187 |             id = 'foo'
188 | 
189 |             interval = @iTree.intervalsById[id]
190 |             node = @iTree.nodesById[id]
191 |             count = node.count()
192 | 
193 |             @iTree.remove id
194 | 
195 |             expect(@iTree.intervalsById[id]).to.not.exist
196 |             expect(@iTree.nodesById[id]).to.not.exist
197 | 
198 |             expect(node.count()).to.equal count - 1
199 |             expect(node.ends.length).to.equal count - 1
200 | 
201 |             results = @iTree.search(interval.start)
202 |             resultIds = (result.id for result in results)
203 |             expect(resultIds).to.not.contain id
204 | 
205 | 
206 | 


--------------------------------------------------------------------------------
/spec/lib/interval.coffee:
--------------------------------------------------------------------------------
 1 | 
 2 | Interval = require '../../src/lib/interval'
 3 | 
 4 | 
 5 | describe 'Interval', ->
 6 | 
 7 |     describe 'center', ->
 8 | 
 9 |         it 'returns center of the interval', ->
10 | 
11 |             expect(new Interval(-193.3, 223.3).center()).to.equal 15
12 | 


--------------------------------------------------------------------------------
/spec/lib/node.coffee:
--------------------------------------------------------------------------------
  1 | 
  2 | Node = require '../../src/lib/node'
  3 | Interval = require '../../src/lib/interval'
  4 | 
  5 | 
  6 | describe 'Node', ->
  7 | 
  8 |     beforeEach ->
  9 | 
 10 |         @node = new Node(500)
 11 | 
 12 |     describe 'insert', ->
 13 | 
 14 |         it 'adds an interval to starts and ends', ->
 15 | 
 16 |             @node.insert new Interval(300, 600, 1)
 17 |             expect(@node.starts).to.have.length 1
 18 |             expect(@node.ends).to.have.length 1
 19 | 
 20 |             @node.insert new Interval(301, 598, 2)
 21 |             expect(@node.starts).to.have.length 2
 22 |             expect(@node.ends).to.have.length 2
 23 | 
 24 | 
 25 |     describe 'count', ->
 26 | 
 27 |         it 'adds an interval to starts and ends', ->
 28 | 
 29 |             @node.insert new Interval(300, 600, 1)
 30 |             @node.insert new Interval(301, 598, 2)
 31 | 
 32 |             expect(@node.count()).to.equal 2
 33 | 
 34 | 
 35 |     describe 'startPointSearch', ->
 36 | 
 37 |         beforeEach ->
 38 | 
 39 |             @node.insert new Interval(300, 600, 1)
 40 |             @node.insert new Interval(301, 598, 2)
 41 |             @node.insert new Interval(301, 599, 3)
 42 |             @node.insert new Interval(303, 599, 4)
 43 | 
 44 | 
 45 |         it 'returns empty array when all interval starts are greater than the given value', ->
 46 | 
 47 |             val = 299
 48 | 
 49 |             expect(@node.startPointSearch(val)).to.eql []
 50 | 
 51 | 
 52 |         it 'returns array of intervals when some interval starts are less than or equal to the given value', ->
 53 | 
 54 |             expect(@node.startPointSearch(300)).to.have.length 1
 55 |             expect(@node.startPointSearch(301)).to.have.length 3
 56 |             expect(@node.startPointSearch(302)).to.have.length 3
 57 |             expect(@node.startPointSearch(303)).to.have.length 4
 58 | 
 59 |             results = @node.startPointSearch(301)
 60 | 
 61 |             for result in results
 62 |                 expect(result).to.be.instanceof Interval
 63 |                 expect(result.start).not.to.be.above 301
 64 | 
 65 | 
 66 |     describe 'endPointSearch', ->
 67 | 
 68 |         beforeEach ->
 69 | 
 70 |             @node.insert new Interval(300, 600, 1)
 71 |             @node.insert new Interval(301, 597, 2)
 72 |             @node.insert new Interval(301, 599, 3)
 73 |             @node.insert new Interval(303, 599, 4)
 74 | 
 75 | 
 76 |         it 'returns empty array when all interval starts are less than the given value', ->
 77 | 
 78 |             val = 601
 79 | 
 80 |             expect(@node.endPointSearch(val)).to.eql []
 81 | 
 82 | 
 83 |         it 'returns array of intervals when some interval starts are less than or equal to the given value', ->
 84 | 
 85 |             expect(@node.endPointSearch(600)).to.have.length 1
 86 |             expect(@node.endPointSearch(599)).to.have.length 3
 87 |             expect(@node.endPointSearch(598)).to.have.length 3
 88 |             expect(@node.endPointSearch(597)).to.have.length 4
 89 | 
 90 |             results = @node.endPointSearch(599)
 91 | 
 92 |             for result in results
 93 |                 expect(result).to.be.instanceof Interval
 94 |                 expect(result.end).not.to.be.below 599
 95 | 
 96 | 
 97 | 
 98 | 
 99 |     describe 'getAllIntervals', ->
100 |     describe 'remove', ->
101 |     describe 'removeFromList', ->
102 | 


--------------------------------------------------------------------------------
/spec/lib/sorted-list.coffee:
--------------------------------------------------------------------------------
 1 | 
 2 | SortedList = require '../../src/lib/sorted-list'
 3 | 
 4 | describe 'SortedList', ->
 5 | 
 6 |     beforeEach ->
 7 | 
 8 |         @list = new SortedList('val')
 9 | 
10 |         @list.insert(val: 300) # 0
11 |         @list.insert(val: 301) # 1
12 |         @list.insert(val: 301) # 2
13 |         @list.insert(val: 303) # 3
14 |         @list.insert(val: 304) # 4
15 |         @list.insert(val: 304) # 5
16 | 
17 | 
18 |     describe 'bsearch', ->
19 | 
20 |         it 'returns -1 when the given value is less than the least value in the list', ->
21 | 
22 |             expect(@list.bsearch(val: 0)).to.equal -1
23 |             expect(@list.bsearch(val: 299)).to.equal -1
24 | 
25 | 
26 |         it 'returns 0 when the given value is the same as the only least value in the list', ->
27 |             expect(@list.bsearch(val: 300)).to.equal 0
28 | 
29 |         it 'returns position (multiple value)', ->
30 |             expect(@list.bsearch(val: 301)).to.be.within 1, 2
31 | 
32 |         it 'returns position (no matching)', ->
33 |             expect(@list.bsearch(val: 302)).to.equal 2
34 | 
35 |         it 'returns position', ->
36 |             expect(@list.bsearch(val: 303)).to.equal 3
37 | 
38 |         it 'returns position (max)', ->
39 |             expect(@list.bsearch(val: 304)).to.be.within 4, 5
40 | 
41 |         it 'returns position (more than max)', ->
42 |             expect(@list.bsearch(val: 305)).to.equal 5
43 | 
44 | 
45 | 
46 |     describe 'firstPositionOf', ->
47 | 
48 |         it 'returns -1 when the given value is less than the least value in the list', ->
49 | 
50 |             expect(@list.firstPositionOf(val: 0)).to.equal -1
51 |             expect(@list.firstPositionOf(val: 299)).to.equal -1
52 | 
53 | 
54 |         it 'returns 0 when the given value is the same as the only least value in the list', ->
55 |             expect(@list.firstPositionOf(val: 300)).to.equal 0
56 | 
57 |         it 'returns first position (multiple value)', ->
58 |             expect(@list.firstPositionOf(val: 301)).to.equal 1
59 | 
60 |         it 'returns first position (no matching)', ->
61 |             expect(@list.firstPositionOf(val: 302)).to.equal 3
62 | 
63 |         it 'returns first position', ->
64 |             expect(@list.firstPositionOf(val: 303)).to.equal 3
65 | 
66 |         it 'returns first position (max)', ->
67 |             expect(@list.firstPositionOf(val: 304)).to.equal 4
68 | 
69 |         it 'returns first position (more than max)', ->
70 |             expect(@list.firstPositionOf(val: 305)).to.equal 6
71 | 
72 | 
73 |     describe 'lastPositionOf', ->
74 | 
75 |         it 'returns -1 when the given value is less than the least value in the list', ->
76 | 
77 |             expect(@list.lastPositionOf(val: 0)).to.equal -1
78 |             expect(@list.lastPositionOf(val: 299)).to.equal -1
79 | 
80 | 
81 |         it 'returns 0 when the given value is the same as the only least value in the list', ->
82 |             expect(@list.lastPositionOf(val: 300)).to.equal 0
83 | 
84 |         it 'returns last position (multiple value)', ->
85 |             expect(@list.lastPositionOf(val: 301)).to.equal 2
86 | 
87 |         it 'returns last position (no matching)', ->
88 |             expect(@list.lastPositionOf(val: 302)).to.equal 2
89 | 
90 |         it 'returns last position', ->
91 |             expect(@list.lastPositionOf(val: 303)).to.equal 3
92 | 
93 |         it 'returns last position (max)', ->
94 |             expect(@list.lastPositionOf(val: 304)).to.equal 5
95 | 
96 |         it 'returns first position (more than max)', ->
97 |             expect(@list.lastPositionOf(val: 305)).to.equal 6
98 | 


--------------------------------------------------------------------------------
/spec/lib/util.coffee:
--------------------------------------------------------------------------------
 1 | 
 2 | Util = require '../../src/lib/util'
 3 | 
 4 | describe 'Util', ->
 5 | 
 6 |     describe '@assertNumber', ->
 7 | 
 8 |         it 'throws an Error when null is given to 1st argument', ->
 9 | 
10 |             expect(-> Util.assertNumber(null, 'xx')).to.throw 'xx is required.'
11 | 
12 | 
13 |         it 'throws an Error when string is given to 1st argument', ->
14 | 
15 |             expect(-> Util.assertNumber('123', 'xx')).to.throw 'xx must be a number.'
16 | 
17 | 
18 |         it 'does nothing when number is given to 1st argument', ->
19 | 
20 |             expect(-> Util.assertNumber(123, 'xx')).to.not.throw Error
21 | 
22 | 
23 |     describe '@assertOrder', ->
24 | 
25 | 
26 |         it 'throws an Error when start is equal to end', ->
27 | 
28 |             expect(-> Util.assertOrder(123, 123, 'start', 'end', 'xx')).to.throw 'xx: start(123) must be smaller than end(123).'
29 | 
30 |         it 'throws an Error when start is greater than end', ->
31 | 
32 |             expect(-> Util.assertOrder(234, 123, 'start', 'end', 'xx')).to.throw 'xx: start(234) must be smaller than end(123).'
33 | 
34 | 
35 |         it 'does nothing when number is given to 1st argument', ->
36 | 
37 |             expect(-> Util.assertOrder(122, 123, 'start', 'end', 'xx')).to.not.throw Error
38 | 


--------------------------------------------------------------------------------
/src/lib/interval-tree.coffee:
--------------------------------------------------------------------------------
  1 | 
  2 | SortedList = require './sorted-list'
  3 | Node       = require './node'
  4 | Point      = require './point'
  5 | Interval   = require './interval'
  6 | Util       = require './util'
  7 | 
  8 | 
  9 | ###*
 10 | interval tree
 11 | 
 12 | @class IntervalTree
 13 | @module interval-tree2
 14 | ###
 15 | class IntervalTree
 16 | 
 17 | 
 18 |     ###*
 19 |     @constructor
 20 |     @param {Number} center center of the root node
 21 |     ###
 22 |     constructor: (center) ->
 23 | 
 24 |         Util.assertNumber center, 'IntervalTree: center'
 25 | 
 26 |         ###*
 27 |         center => node
 28 | 
 29 |         @property {Object(Node)} nodesByCenter
 30 |         ###
 31 |         @nodesByCenter = {}
 32 | 
 33 | 
 34 |         ###*
 35 |         root node
 36 | 
 37 |         @property {Node} root
 38 |         ###
 39 |         @root = @createNode(center)
 40 | 
 41 | 
 42 |         ###*
 43 |         interval id => interval
 44 | 
 45 |         @property {Object(Interval)} intervalsById
 46 |         ###
 47 |         @intervalsById = {}
 48 | 
 49 | 
 50 |         ###*
 51 |         interval id => node
 52 | 
 53 |         @property {Object(Node)} nodesById
 54 |         ###
 55 |         @nodesById = {}
 56 | 
 57 | 
 58 |         ###*
 59 |         sorted list of whole point
 60 | 
 61 |         @property {SortedList(Point)} pointTree
 62 |         ###
 63 |         @pointTree = new SortedList('val')
 64 | 
 65 | 
 66 |         ###*
 67 |         unique id candidate of interval without id to be added next time
 68 | 
 69 |         @property {Number} idCandidate
 70 |         ###
 71 |         @idCandidate = 0
 72 | 
 73 | 
 74 | 
 75 |     ###*
 76 |     add one interval
 77 | 
 78 |     @method add
 79 |     @public
 80 |     @param {Number} start start of the interval to create
 81 |     @param {Number} end   end of the interval to create
 82 |     @param {String|Number} [id] identifier to distinguish intervals. Automatically defiend when not set.
 83 |     @return {Interval}
 84 |     ###
 85 |     add: (start, end, id) ->
 86 | 
 87 |         if @intervalsById[id]?
 88 |             throw new Error('id ' + id + ' is already registered.')
 89 | 
 90 |         if not id?
 91 |             while @intervalsById[@idCandidate]?
 92 |                 @idCandidate++
 93 |             id = @idCandidate
 94 | 
 95 | 
 96 |         Util.assertNumber(start, '1st argument of IntervalTree#add()')
 97 |         Util.assertNumber(end, '2nd argument of IntervalTree#add()')
 98 | 
 99 |         if start >= end
100 |             Util.assertOrder(start, end, 'start', 'end')
101 | 
102 | 
103 |         interval = new Interval(start, end, id)
104 | 
105 |         @pointTree.insert new Point(interval.start, id)
106 |         @pointTree.insert new Point(interval.end,   id)
107 | 
108 |         @intervalsById[id] = interval
109 | 
110 |         return @insert interval, @root
111 | 
112 | 
113 |     ###*
114 |     search intervals
115 |     when only one argument is given, return intervals which contains the value
116 |     when two arguments are given, ...
117 | 
118 |     @method search
119 |     @public
120 |     @param {Number} val1
121 |     @param {Number} val2
122 |     @return {Array(Interval)} intervals
123 |     ###
124 |     search: (val1, val2) ->
125 | 
126 |         Util.assertNumber val1, '1st argument at IntervalTree#search()'
127 | 
128 |         if not val2?
129 | 
130 |             return @pointSearch val1
131 | 
132 |         else
133 | 
134 |             Util.assertNumber val2, '2nd argument at IntervalTree#search()'
135 |             Util.assertOrder val1, val2, '1st argument', '2nd argument', 'IntervalTree#search()'
136 | 
137 |             return @rangeSearch val1, val2
138 | 
139 | 
140 |     ###*
141 |     removes an interval of the given id
142 | 
143 |     @method remove
144 |     @public
145 |     @param {Number|String} id id of the interval to remove
146 |     ###
147 |     remove: (id) ->
148 | 
149 |         interval = @intervalsById[id]
150 | 
151 |         return if not interval?
152 | 
153 |         node = @nodesById[id]
154 | 
155 |         node.remove(interval)
156 | 
157 |         delete @nodesById[id]
158 |         delete @intervalsById[id]
159 | 
160 | 
161 | 
162 |     ###*
163 |     search intervals at the given node
164 | 
165 |     @method pointSearch
166 |     @public
167 |     @param {Number} val
168 |     @param {Node} [node] current node to search. default is this.root
169 |     @return {Array(Interval)}
170 |     ###
171 |     pointSearch: (val, node = @root, results = []) ->
172 | 
173 |         Util.assertNumber(val, '1st argument of IntervalTree#pointSearch()')
174 | 
175 |         if val < node.center
176 | 
177 |             results = results.concat node.startPointSearch(val)
178 | 
179 |             if node.left?
180 |                 return @pointSearch(val, node.left, results)
181 | 
182 |             else
183 |                 return results
184 | 
185 | 
186 |         if val > node.center
187 | 
188 |             results = results.concat node.endPointSearch(val)
189 | 
190 |             if node.right?
191 |                 return @pointSearch(val, node.right, results)
192 | 
193 |             else
194 |                 return results
195 | 
196 |         # if val is node.center
197 |         return results.concat node.getAllIntervals()
198 | 
199 | 
200 |     ###*
201 |     returns intervals which covers the given start-end interval
202 | 
203 |     @method rangeSearch
204 |     @public
205 |     @param {Number} start start of the interval
206 |     @param {Number} end end of the interval
207 |     @return {Array(Interval)}
208 |     ###
209 |     rangeSearch: (start, end) ->
210 | 
211 |         Util.assertNumber start, '1st argument at IntervalTree#rangeSearch()'
212 |         Util.assertNumber end, '2nd argument at IntervalTree#rangeSearch()'
213 |         Util.assertOrder start, end, '1st argument', '2nd argument', 'IntervalTree#rangeSearch()'
214 | 
215 |         resultsById = {}
216 | 
217 |         # 1. pointSearch to arbitrary point between start and end (here: point = start) 
218 |         for interval in @pointSearch(start)
219 |             resultsById[interval.id] = interval
220 | 
221 |         # 2. add intervals whose either point is included in the given range
222 |         firstPos = @pointTree.firstPositionOf new Point(start)
223 |         lastPos  = @pointTree.lastPositionOf new Point(end)
224 | 
225 |         for point in @pointTree.slice(firstPos, lastPos + 1)
226 | 
227 |             resultsById[point.id] = @intervalsById[point.id]
228 | 
229 |         return (interval for id, interval of resultsById)
230 | 
231 | 
232 | 
233 |     ###*
234 |     insert interval to the given node
235 | 
236 |     @method insert
237 |     @private
238 |     @param {Interval} interval
239 |     @param {Node} node node to insert the interval
240 |     @return {Interval} inserted interval
241 |     ###
242 |     insert: (interval, node) ->
243 | 
244 |         if interval.end < node.center
245 | 
246 |             node.left ?= @createNode(interval.end)
247 | 
248 |             return @insert(interval, node.left)
249 | 
250 |         if node.center < interval.start
251 | 
252 |             node.right ?= @createNode(interval.start)
253 | 
254 |             return @insert(interval, node.right)
255 | 
256 |         node.insert interval
257 | 
258 |         @nodesById[interval.id] = node
259 | 
260 |         return interval
261 | 
262 | 
263 | 
264 |     ###*
265 |     create node by center
266 | 
267 |     @method createNode
268 |     @private
269 |     @param {Number} center
270 |     @return {Node} node
271 |     ###
272 |     createNode: (center) ->
273 | 
274 |         node = new Node(center)
275 | 
276 |         @nodesByCenter[center] = node
277 | 
278 |         return node
279 | 
280 | 
281 | module.exports = IntervalTree
282 | 


--------------------------------------------------------------------------------
/src/lib/interval.coffee:
--------------------------------------------------------------------------------
 1 | 
 2 | ###*
 3 | interval, containing start and and
 4 | 
 5 | @class Interval
 6 | @module interval-tree2
 7 | ###
 8 | class Interval
 9 | 
10 | 
11 |     ###*
12 |     @constructor
13 |     @param {Number} start start of the interval
14 |     @param {Number} end end of the interval
15 |     @param {Number|String} id id of the interval
16 |     ###
17 |     constructor: (@start, @end, @id) ->
18 | 
19 | 
20 |     ###*
21 |     get center of the interval
22 | 
23 |     @method center
24 |     @return {Number} center
25 |     ###
26 |     center: -> ( @start + @end ) / 2
27 | 
28 | module.exports = Interval
29 | 


--------------------------------------------------------------------------------
/src/lib/node.coffee:
--------------------------------------------------------------------------------
  1 | 
  2 | SortedList = require './sorted-list'
  3 | 
  4 | ###*
  5 | node of IntervalTree, containing intervalsj
  6 | 
  7 | @class Node
  8 | @module interval-tree2
  9 | ###
 10 | class Node
 11 | 
 12 | 
 13 |     ###*
 14 |     @constructor
 15 |     @param {Number} center center of the node
 16 |     ###
 17 |     constructor: (@center) ->
 18 | 
 19 |         ###*
 20 |         another node whose center is less than this.center
 21 | 
 22 |         @property {Node} left
 23 |         ###
 24 |         @left = null
 25 | 
 26 | 
 27 |         ###*
 28 |         another node whose center is greater than this.center
 29 | 
 30 |         @property {Node} right
 31 |         ###
 32 |         @right = null
 33 | 
 34 | 
 35 |         ###*
 36 |         sorted list of Intervals, sorting them by their start property
 37 | 
 38 |         @property {SortedList(Interval)} starts
 39 |         ###
 40 |         @starts = new SortedList 'start'
 41 | 
 42 | 
 43 |         ###*
 44 |         sorted list of Intervals, sorting them by their end property
 45 | 
 46 |         @property {SortedList(Interval)} ends
 47 |         ###
 48 |         @ends = new SortedList 'end'
 49 | 
 50 | 
 51 |     ###*
 52 |     the number of intervals
 53 | 
 54 |     @method count
 55 |     @return {Number}
 56 |     ###
 57 |     count: -> @starts.length
 58 | 
 59 | 
 60 |     ###*
 61 |     insert an interval
 62 | 
 63 |     @method insert
 64 |     @param {Interval} interval
 65 |     ###
 66 |     insert: (interval) ->
 67 | 
 68 |         @starts.insert interval
 69 |         @ends.insert interval
 70 | 
 71 | 
 72 | 
 73 |     ###*
 74 |     get intervals whose start position is less than or equal to the given value
 75 | 
 76 |     @method startPointSearch
 77 |     @param {Number} val
 78 |     @return {Array(Interval)}
 79 |     ###
 80 |     startPointSearch: (val) ->
 81 | 
 82 |         index = @starts.lastPositionOf(start: val)
 83 | 
 84 |         return @starts.slice(0, index + 1)
 85 | 
 86 | 
 87 |     ###*
 88 |     get intervals whose end position is more than or equal to the given value
 89 | 
 90 |     @method endPointSearch
 91 |     @param {Number} val
 92 |     @return {Array(Interval)}
 93 |     ###
 94 |     endPointSearch: (val) ->
 95 | 
 96 |         index = @ends.firstPositionOf(end: val)
 97 | 
 98 |         return @ends.slice(index)
 99 | 
100 | 
101 |     ###*
102 |     gets all registered interval
103 | 
104 |     @method getAllIntervals
105 |     @return {Array(Interval)}
106 |     ###
107 |     getAllIntervals: ->
108 | 
109 |         return @starts.toArray()
110 | 
111 | 
112 |     ###*
113 |     remove the given interval
114 | 
115 |     @method remove
116 |     @param {Interval} interval
117 |     @param {SortedList} list
118 |     ###
119 |     remove: (interval) ->
120 | 
121 |         @removeFromList(interval, @starts)
122 |         @removeFromList(interval, @ends)
123 | 
124 | 
125 |     ###*
126 |     remove the given interval from the given list
127 | 
128 |     @method removeFromList
129 |     @private
130 |     @param {Interval} interval
131 |     @param {SortedList} list
132 |     ###
133 |     removeFromList: (interval, list) ->
134 | 
135 |         firstPos = list.firstPositionOf interval
136 | 
137 |         for idx in [firstPos...list.length]
138 | 
139 |             candidate = list[idx]
140 | 
141 |             if candidate.id is interval.id
142 |                 list.remove(idx)
143 |                 break
144 | 
145 | 
146 | 
147 | module.exports = Node
148 | 


--------------------------------------------------------------------------------
/src/lib/point.coffee:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | ###*
 4 | number with id
 5 | 
 6 | @class Point
 7 | @module interval-tree2
 8 | ###
 9 | class Point
10 | 
11 | 
12 |     ###*
13 |     @constructor
14 |     @param {Number} val number
15 |     @param {Number|String} id id
16 |     ###
17 |     constructor: (@val, @id) ->
18 | 
19 | 
20 | module.exports = Point
21 | 


--------------------------------------------------------------------------------
/src/lib/sorted-list.coffee:
--------------------------------------------------------------------------------
  1 | 
  2 | ###*
  3 | extended array of objects, always sorted
  4 | 
  5 | @class SortedList
  6 | @extends Array
  7 | @module interval-tree2
  8 | ###
  9 | class SortedList extends Array
 10 | 
 11 | 
 12 |     ###*
 13 |     @constructor
 14 |     @param {String} compareKey key name to compare objects. The value of the key must be a number.
 15 |     ###
 16 | 
 17 |     ###*
 18 |     key name to compare objects. The value of the key must be a number.
 19 |     @property {String} compareKey
 20 |     ###
 21 |     constructor: (@compareKey) ->
 22 | 
 23 | 
 24 | 
 25 |     ###*
 26 |     insert a value
 27 | 
 28 |     @method insert
 29 |     @param {any} val
 30 |     @return {Number} inserted position
 31 |     ###
 32 |     insert: (val) ->
 33 | 
 34 |         pos = @bsearch(val)
 35 | 
 36 |         @splice pos + 1, 0, val
 37 | 
 38 |         return pos + 1
 39 | 
 40 | 
 41 |     ###*
 42 |     remove the value in the given position
 43 | 
 44 |     @method remove
 45 |     @param {Number} pos position
 46 |     @return {SortedList} self
 47 |     ###
 48 |     remove: (pos) ->
 49 | 
 50 |         @splice pos, 1
 51 | 
 52 |         return @
 53 | 
 54 | 
 55 |     ###*
 56 |     get maximum value in the list
 57 | 
 58 |     @method max
 59 |     @return {Number}
 60 |     ###
 61 |     max: ->
 62 |         @[@length - 1]?[@compareKey]
 63 | 
 64 | 
 65 |     ###*
 66 |     get minimum value in the list
 67 | 
 68 |     @method min
 69 |     @return {Number}
 70 |     ###
 71 |     min: ->
 72 |         @[0]?[@compareKey]
 73 | 
 74 | 
 75 |     ###*
 76 |     binary search
 77 | 
 78 |     @method bsearch
 79 |     @param {any} val
 80 |     @return {Number} position of the value
 81 |     ###
 82 |     bsearch: (val) ->
 83 | 
 84 |         return -1 if not @length
 85 | 
 86 |         mpos = null
 87 |         mval = null
 88 |         spos = 0
 89 |         epos = @length
 90 | 
 91 |         while epos - spos > 1
 92 |             mpos = Math.floor((spos + epos) / 2)
 93 |             mval = @[mpos]
 94 |             comp = @compare(val, mval)
 95 | 
 96 |             return mpos if comp is 0
 97 | 
 98 |             if comp > 0
 99 |                 spos = mpos
100 |             else
101 |                 epos = mpos
102 | 
103 |         return if spos is 0 and @compare(@[0], val) > 0 then -1 else spos
104 | 
105 | 
106 |     ###*
107 |     leftmost position of the given val
108 | 
109 |     @method firstPositionOf
110 |     @param {any} val
111 |     @return {Number} leftmost position of the value
112 |     ###
113 |     firstPositionOf: (val) ->
114 | 
115 |         index = @bsearch val
116 | 
117 |         return -1 if index is -1
118 | 
119 |         num = val[@compareKey]
120 | 
121 |         if num is @[index]?[@compareKey]
122 | 
123 |             loop
124 |                 break if index <= 0
125 |                 break if @[index - 1][@compareKey] < num
126 |                 index--
127 |         else
128 |             index++
129 | 
130 |         return index
131 | 
132 | 
133 |     ###*
134 |     rightmost position of the given val
135 | 
136 |     @method lastPositionOf
137 |     @param {any} val
138 |     @return {Number} rightmost position of the value
139 |     ###
140 |     lastPositionOf: (val) ->
141 | 
142 |         index = @bsearch val
143 | 
144 |         return -1 if index is -1
145 | 
146 |         num = val[@compareKey]
147 | 
148 |         if index is @length - 1 and num > @max()
149 |             return index + 1
150 | 
151 |         loop
152 |             break if index + 1 >= @length
153 |             break if @[index + 1][@compareKey] > num
154 |             index++
155 | 
156 |         return index
157 | 
158 | 
159 | 
160 |     ###*
161 |     # sorted.toArray()
162 |     # get raw array
163 |     #
164 |     ###
165 |     toArray: -> @slice()
166 | 
167 | 
168 |     ###*
169 |     comparison function. Compares two objects by this.compareKey
170 | 
171 |     @method compare
172 |     @private
173 |     @param {any} a
174 |     @param {any} b
175 |     ###
176 |     compare: (a, b) ->
177 | 
178 |         return -1 if not a?
179 |         return 1  if not b?
180 | 
181 |         c = a[@compareKey] - b[@compareKey]
182 | 
183 |         if c > 0 then 1 else if c is 0 then 0 else -1
184 | 
185 | 
186 | 
187 | module.exports = SortedList
188 | 


--------------------------------------------------------------------------------
/src/lib/util.coffee:
--------------------------------------------------------------------------------
 1 | 
 2 | class Util
 3 | 
 4 |     @assertNumber: (val, desc) ->
 5 | 
 6 |         if not val?
 7 |             throw new Error(desc + ' is required.')
 8 | 
 9 |         if typeof val isnt 'number'
10 |             throw new Error(desc + ' must be a number.')
11 | 
12 | 
13 |     @assertOrder: (start, end, startName, endName, desc) ->
14 | 
15 |         if start >= end
16 |             throw new Error("#{desc}: #{startName}(#{start}) must be smaller than #{endName}(#{end}).")
17 | 
18 | module.exports = Util
19 | 


--------------------------------------------------------------------------------
/src/web-entry.coffee:
--------------------------------------------------------------------------------
1 | 
2 | window.IntervalTree = require './lib/interval-tree'
3 | 


--------------------------------------------------------------------------------