int_set_test_

Benchmark created by Jason on March 17, 2015

Setup

Object.__typeName = 'Object';
    Object.__baseType = null;
    
    Object.clearKeys = function Object$clearKeys(d) {
        for (var n in d) {
            delete d[n];
        }
    }
    
    Object.keyExists = function Object$keyExists(d, key) {
        return d[key] !== undefined;
    }
    
    if (!Object.keys) {
        Object.keys = function Object$keys(d) {
            var keys = [];
            for (var n in d) {
                keys.push(n);
            }
            return keys;
        }
    
        Object.getKeyCount = function Object$getKeyCount(d) {
            var count = 0;
            for (var n in d) {
                count++;
            }
            return count;
        }
    }
    else {
        Object.getKeyCount = function Object$getKeyCount(d) {
            return Object.keys(d).length;
        }
    }
    
    var ArrayEnumerator = function ArrayEnumerator$(array) {
      this._array = array;
      this._index = -1;
      this.current = null;
    }
    
    ArrayEnumerator.prototype = {
      moveNext: function ArrayEnumerator$moveNext() {
        this._index++;
        this.current = this._array[this._index];
        return (this._index < this._array.length);
      },
      reset: function ArrayEnumerator$reset() {
        this._index = -1;
        this.current = null;
      }
    }
    
    var tab = {};
    
    tab.IntSetNew = function tab_IntSetNew() {
        this._set = {};
    }
    tab.IntSetNew.prototype = {
        
        get_count: function tab_IntSetNew$get_count() {
            return Object.getKeyCount(this._set);
        },
        
        get_values: function tab_IntSetNew$get_values() {
            var setKeys = Object.keys(this._set);
            var keyCount = setKeys.length;
            var values = new Array(keyCount);
            for (var i = 0; i < keyCount; i++) {
                var key = setKeys[i];
                var value = this._set[key];
                values[i] = value;
            }
            return values;
        },
        
        addAll: function tab_IntSetNew$addAll(ints) {
            var count = ints.length;
            for (var i = 0; i < count; i++) {
                var val = ints[i];
                this._set[val] = val;
            }
        },
        
        add: function tab_IntSetNew$add(i) {
            this._set[i] = i;
        },
        
        remove: function tab_IntSetNew$remove(i) {
            delete this._set[i];
        },
        
        clear: function tab_IntSetNew$clear() {
            Object.clearKeys(this._set);
        },
        
        contains: function tab_IntSetNew$contains(i) {
            return Object.keyExists(this._set, i);
        },
        
        intersect: function tab_IntSetNew$intersect(ints) {
            var intersection = new tab.IntSetNew();
            var setKeys = Object.keys(ints._set);
            var keyCount = setKeys.length;
            for (var i = 0; i < keyCount; i++) {
                var key = setKeys[i];
                var value = ints._set[key];
                if (this.contains(key)) {
                    intersection._set[key] = value;
                }
            }
            return intersection;
        }
    }
    
    tab.IntSetOld = function tab_IntSetOld() {
        this._set = {};
    }
    tab.IntSetOld.prototype = {
        
        get_count: function tab_IntSetOld$get_count() {
            return Object.getKeyCount(this._set);
        },
        
        get_values: function tab_IntSetOld$get_values() {
            var values = new Array(this.get_count());
            var i = 0;
            var $dict1 = this._set;
            for (var $key2 in $dict1) {
                var pair = { key: $key2, value: $dict1[$key2] };
                values[i] = pair.value;
                i++;
            }
            return values;
        },
        
        addAll: function tab_IntSetOld$addAll(ints) {
            var $enum1 = new ArrayEnumerator(ints);
            while ($enum1.moveNext()) {
                var i = $enum1.current;
                this._set[i] = i;
            }
        },
        
        add: function tab_IntSetOld$add(i) {
            this._set[i] = i;
        },
        
        remove: function tab_IntSetOld$remove(i) {
            delete this._set[i];
        },
        
        clear: function tab_IntSetOld$clear() {
            Object.clearKeys(this._set);
        },
        
        contains: function tab_IntSetOld$contains(i) {
            return Object.keyExists(this._set, i);
        },
        
        intersect: function tab_IntSeOld$intersect(ints) {
            var intersection = new tab.IntSetOld();
            var $dict1 = ints._set;
            for (var $key2 in $dict1) {
                var pair = { key: $key2, value: $dict1[$key2] };
                if (this.contains(pair.key)) {
                    intersection._set[pair.key] = pair.value;
                }
            }
            return intersection;
        }
    }
    
    var set1 = [];
    for (var i = 0; i < 100; i++)
    {
     set1.push(i);
    }
    
    var set2 = [];
    for (var i = 0; i < 100; i++)
    {
     set2.push(i*2);
    }
    
    var intSet1New = new tab.IntSetNew();
    intSet1New.addAll(set1);
    
    var intSet2New = new tab.IntSetNew();
    intSet2New.addAll(set2);
    
    var intSet1Old = new tab.IntSetOld();
    intSet1Old .addAll(set1);
    
    var intSet2Old = new tab.IntSetOld();
    intSet2Old .addAll(set2);

Test runner

var intersect = intSet1New.intersect(intSet2New);
var values = intersect.get_values();

var intersect = intSet1Old.intersect(intSet2Old);
var values = intersect.get_values();

Revisions

You can edit these tests or add more tests to this page by appending /edit to the URL.

• Revision 1: published by Jason on March 17, 2015
• Revision 2: published on March 17, 2015