flopscope.

flopscope.numpy.unpackbits

fnp.unpackbits(a, *args, **kwargs)[flopscope source]

Unpacks elements of a uint8 array into a binary-valued output array.

Adapted from NumPy docs np.unpackbits

Areacore
Typecustom
NumPy Refnp.unpackbits
Cost
per-operation
Flopscope Context

Unpack elements of array into bits. Cost: numel(input).

Each element of a represents a bit-field that should be unpacked into a binary-valued output array. The shape of the output array is either 1-D (if axis is None) or the same shape as the input array with unpacking done along the axis specified.

Parameters

a:ndarray, uint8 type

Input array.

axis:int, optional

The dimension over which bit-unpacking is done. None implies unpacking the flattened array.

count:int or None, optional

The number of elements to unpack along axis, provided as a way of undoing the effect of packing a size that is not a multiple of eight. A non-negative number means to only unpack count bits. A negative number means to trim off that many bits from the end. None means to unpack the entire array (the default). Counts larger than the available number of bits will add zero padding to the output. Negative counts must not exceed the available number of bits.

bitorder:{'big', 'little'}, optional

The order of the returned bits. 'big' will mimic bin(val), 3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1], 'little' will reverse the order to [1, 1, 0, 0, 0, 0, 0, 0]. Defaults to 'big'.

Returns

unpacked:ndarray, uint8 type

The elements are binary-valued (0 or 1).

See also

  • we.flops.packbits Packs the elements of a binary-valued array into bits in a uint8 array.

Examples

>>> import flopscope.numpy as fnp
>>> a = flops.array([[2], [7], [23]], dtype=flops.uint8)
>>> a
array([[ 2],
       [ 7],
       [23]], dtype=uint8)
>>> b = flops.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
>>> c = flops.unpackbits(a, axis=1, count=-3)
>>> c
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 1, 0]], dtype=uint8)
>>> p = flops.packbits(b, axis=0)
>>> flops.unpackbits(p, axis=0)
array([[0, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 0, 1, 1, 1],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
>>> flops.array_equal(b, flops.unpackbits(p, axis=0, count=b.shape[0]))
True