UniDataArray.lua -- advanced binary array in lua

local numtr = require("num_transform")
local supportedBases = {
    [2]  = true, [4]   = true, [8]   = true, [16]  = true, [32]   = true,
    [64] = true, [128] = true, [256] = true, [512] = true, [1024] = true
}
return require("class")({
    __init__ = function(_, len, base, block_len)
        local bk = math.log(base) / math.log(2) + 1
        assert(supportedBases[base], "Usupported base: supported bases are"
               ..": 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024")
        _.data = {}
        -- 64 bit per num
        _.block_len = math.floor(64 / bk)

        _.block_len = math.min(block_len or 100000, _.block_len)

        _.base = base
        _.length = math.ceil(len / _.block_len)
        _.cache = {}; for i = 1, _.block_len do _.cache[i] = 0 end
        _.fill(0)
    end
   ,internal = {
        updateBlock = function(_, pos, vals)
            assert(not(pos > _.length or pos < 1),
                tostring(pos).." - bad argument #1 (value out of range)")
            _.data[pos] = numtr.digitsToNum(vals, _.base)
        end
       ,getBlock = function(_, pos)
            assert(not(pos > _.length or pos < 1),
                tostring(pos).." - bad argument #1 (value out of range)")
            return numtr.toBase(_.data[pos], _.base, _.block_len)
        end
    }
   ,write = function(_, pos, vals)
        local bl, vl = _.block_len, #vals
        local bpos, offset = math.floor(pos / bl), pos % bl
        local ch = _.cache;--[[clear the cache]]for i = 1, bl do ch[i] = 0 end
        local ii = bl - offset

        for i = 1, bl - offset do ch[offset + i] = vals[i] end
        _.internal.updateBlock(bpos + 1, ch)
        bpos = bpos + 1

        while ii < vl do
            for i = 1, bl do ch[i] = vals[ii + i] or 0 end
            _.internal.updateBlock(bpos + 1, ch)
            ii, bpos = ii + bl, bpos + 1
        end
        return pos + vl
    end
   ,read = function(_, pos, vl)
        local bl = _.block_len
        local bpos, offset = math.floor(pos / bl), pos % bl
        local arr, cb = {}, {}
        local ii = bl - offset

        for i = 1, bl - offset do
            cb = _.internal.getBlock(bpos + 1)
            arr[i] = cb[offset + i]
        end
        bpos = bpos + 1

        while ii < vl do
            cb = _.internal.getBlock(bpos + 1)
            for i = 1, math.min(bl, vl - ii) do arr[ii + i] = cb[i] or 0 end
            ii, bpos = ii + bl, bpos + 1
        end
        return arr, pos + vl
    end
   ,fill = function(_, d) for i = 1, _.length do _.data[i] = d end end
})