代表二进制数据的集合

Question

I'm working with signals in which the samples consist of Float s. Some of the algorithms I've written only require to know when the signal crosses the x-axis (ie positive value to a negative value and vice versa). When I'm doing these kinds of operations, I realized that I don't need to know the actual Float value of each sample. I just need to know whether the sample's value is positive or not.

I originally represented the signal as a Vector of Float s. After my discovery, I started representing it as a Vector of Boolean values (ie False for a negative value and True for a positive value). This turned out to be a lot more efficient and I improved the program's performance both in terms of run-time and memory consumption.

I'm still wondering if there isn't a more efficient way of representing this "collection of binary data". Something like a Bit Vector or Bit Array . I've found a BitArray on Hackage but it doesn't seem to support the same functionality that a Vector does.

Is there a more efficient way of representing the data of my use case or should I stick to a Vector of Boolean values?

Answer 1

Both one-bool-per-byte and one-bool-per-bit options are available from the vector and array packages respectively.

First, a Vector Bool from Data.Vector.Unboxed uses a byte array with one byte per Bool . This can be verified from the source in module Data.Vector.Unboxed.Base where Vector Bool is defined as:

newtype instance Vector    Bool = V_Bool  (P.Vector    Word8)

and getting and setting are mediated through the functions:

fromBool :: Bool -> Word8
toBool :: Word8 -> Bool

Alternatively, it can be verified directly by profiling the program:

import Data.Vector.Unboxed as V
main = let v = V.replicate 1000000000 True
  in print (v ! 5)

and observing that it allocates just over 1,000,000,000 bytes.

Second, a UArray Int Bool from Data.Array.Unboxed is implemented as a bit vector, with one Bool per bit. The relevant source is in Data.Array.Base , where you can see the bit manipulation used in the instance:

instance IArray UArray Bool where
    ...
    unsafeAt (UArray _ _ _ arr#) (I# i#) = isTrue#
        ((indexWordArray# arr# (bOOL_INDEX i#) `and#` bOOL_BIT i#)
        `neWord#` int2Word# 0#)

Again, this can be verified directly by profiling:

import Data.Array.Unboxed as A
main = let v = A.listArray (1,1000000000) (repeat True) :: UArray Int Bool
  in print (v ! 5)

and verifying that it allocates approximately 125,000,000 bytes.