Array of bits

[GreenArrow18]

Hello.

This packs quite well:

const schema = array({
   a: bool,
   b: bits(2),
   c: bits(5)
});
const data = [
   { a: false, b: 0, c: 0 },
   { a: true, b: 1, c: 12 },
   { a: true, b: 3, c: 31 }
];
const buf = encode(data); // buf.length = 4

Can this be packed better?

const schema = array(bits(3));
const data = [1, 2, 3, 4, 5, 6, 7];
const buf = encode(data); // buf.length = 8

[e3dio]

The packing algo works for Objects to get the smallest possible size, an Array packing algo can also be added to help but you can also simulate it for now. For example an Object with 7 3-bit fields comes out to 3 bytes total, vs the 8 bytes in your example array:

const schema = { // packs to 3 bytes
   0: bits(3),
   1: bits(3),
   2: bits(3),
   3: bits(3),
   4: bits(3),
   5: bits(3),
   6: bits(3),
};

An Array packing algo would automate this for you, this was planned to be added but did not do yet

[e3dio]

If your array of 3-bits is long and unknown you could use below schema and fill up as many Objects as needed (5 3-bit fields nicely fills up 2 bytes):

schema = array({ // 2 byte objects
   0: bits(3),
   1: bits(3),
   2: bits(3),
   3: bits(3),
   4: bits(3),
})

[GreenArrow18]

Thanks for giving me some ideas.

What is the best way to pack something like this?

const schema = array(array(bits(4));

The number of bits is known, but the array length is dynamic, like:

[
[1, 2, 3]
[1, 2, 3, 4, 5]
... etc
[5, 6, 12, 13, 14, 15] // may be very long
]

[e3dio]

4-bit array you would pack 2 fields per object to make up 1 byte:

schema = array({ // 1 byte per object
   0: bits(4),
   1: bits(4),
})

but ideally the library should do this for you so you can just do array(bits(4)) or array(array(bits(4)))

[GreenArrow18]

Got it. Thanks!

[e3dio]

Master branch now has Array packing, array(bits(x)) will give the smallest possible size #18 Also object packing got more efficient for certain cases

[GreenArrow18]

Just did a quick test, so far it is working great!

I haven't done exact data comparisons yet, but the packed sizes of my 4-bit arrays are definitely much smaller now.

Thanks!