rootslab/toni

/*
 * Toni, a simple and efficient bitmap implementation for positive integer sets
 * (max 32 bits), with no element repetition, using bitwise operations and a Buffer.
 * Modifying a single bit instead of an entire byte, obviously saves 87.5% of Buffer
 * space, but it also implies a gain greater than 200% in performances, when it was
 * used with big integer ranges.
 *
 * http://en.wikipedia.org/wiki/Bit_array
 *
 * Copyright(c) 2014-present Guglielmo Ferri <44gatti@gmail.com>
 * MIT Licensed
 */

exports.Toni = ( function () {
    var log = console.log
        , abs = Math.abs
        , ceil = Math.ceil
        , max = Math.max
        , min = Math.min
        // table of powers
        , bpower = new Buffer( [ 128, 64, 32, 16, 8, 4, 2, 1 ] )
        // count the number of bits set to 1 for every 1-byte number
        , cbits = function ( b ) {
           // divide et impera method for 8 bits
            var v = b - ( ( b >>> 1 ) & 0x55 );
            v = ( v & 0x33 ) + ( ( v >>> 2 ) & 0x33 );
            return v + ( v >>> 4 ) & 0x0f;
        }
        , bctable = ( function () {
            var i = 0
                , table = new Buffer( 256 )
                , v = -1
                ;
            for ( ; i < 256; ++i ) table[ i ] = cbits( i );
            return table;
        } )()
        , Toni = function ( range ) {
            var me = this
                , is = me instanceof Toni
                ;
            if ( ! is ) return new Toni( range );
            // limit range to 4 bytes, (32 bits numbers) using >>> 0
            var r = ( abs( + range ) >>> 0 ) || 1
                , bytes = max( ceil( r / 8 ), 1 )
                , bitmap = new Buffer( bytes )
                ;
                bitmap.fill( 0x00 );
                me.bitmap = bitmap;
                // bytes needed
                me.bmlen = bytes << 3 >>> 0;
                me.items = 0;
                me.range = r;
                // bit count table for 1 byte
                me.bctable = bctable;
        }
        , tproto = Toni.prototype
        ;

    tproto.clear = function () {
        var me = this
            ;
        me.bitmap.fill( 0x00 );
        me.items = 0;
        return me;
    };

    tproto.add = function ( value ) {
        var me = this
            , v = abs( value )
            , bitmap = me.bitmap
            , range = me.range
            ;
        // check value range
        if ( ( v >= me.bmlen ) || ( v >= range ) ) return -1;
        /*
         * generally, bucket and mask could be calculated respectively as floor( v / 8 )
         * and bpower[ v % 8 ], but seen that values > 2^32 are not allowed, then we can
         * speed up things using bitwise shiftings.
         */
        var buck = v >>> 3
            , mask = bpower[ v & 7 ]
            , up = mask & bitmap[ buck ]
            ;
        return up ? -1 : ++me.items | ( bitmap[ buck ] |= mask );
    };

    // get/access the bit at a given index i, b = B[i]
    tproto.chk = function ( value ) {
        var me = this
            , v = abs( value )
            , range = me.range
            ;
        // check value range
        if ( ( me.bmlen <= v ) || ( v >= range ) ) return 0;
        // see #add
        return bpower[ v & 7 ] & me.bitmap[ v >>> 3 ] ? 1 : 0;
    };

    tproto.del = function ( value ) {
        var me = this
            , v = value
            , range = me.range
            , bitmap = me.bitmap
            ;
        // check value range
        if ( ( me.bmlen <= v ) || ( v >= range ) ) return -1;

        var buck = v >>> 3
            , mask = bpower[ v & 7 ]
            , up = mask & bitmap[ buck ]
            ;
        return up ? --me.items | ( bitmap[ buck ] ^= mask ) : -1;
    };

    // it returns the occurrences of bit 1 until index i
    tproto.rank = function ( i ) {
        var me = this
            , bitmap = me.bitmap
            , bmlen = me.bmlen
            , buck = null 
            , boff = -1
            , bshift = -1
            , b = 0
            , bcnt = 0
            , index = min( i >>> 0, me.bmlen )
            ;
        if ( index > bmlen ) return -1;
            // last bucket to count with btable
            buck = index >>> 3;
            // bits remaining to count
            boff = 1 + ( index - ( buck << 3 ) );
            bshift = 8 - boff;

        if ( buck ) {
            // log( ' - bytes to count: %d', buck );
            for ( b = 0; b < buck ; ++b )
                bcnt += bctable[ bitmap[ b ] ];
        }
        bcnt += bctable[ bitmap[ b ] >>> bshift ];
        return bcnt;    
    };

    // it returns the position of the i-th occurrence of bit 1
    // tproto.select = function ( index ) {
    //    var me = this
    //        ;
    //    return;
    // };

    return Toni;

} )();