Data.Bits.Extras

Calculate a number of fiddly bit operations using fast de Bruijn multiplication tables.

Documentation

class (Num t, FiniteBits t) => Ranked t where

Minimal complete definition

nlz

Methods

lsb :: t -> Int

Calculate the least significant set bit using a debruijn multiplication table. NB: The result of this function is undefined when given 0.

rank :: t -> Int

Calculate the number of trailing 0 bits.

nlz :: t -> Int

Calculate the number of leading zeros.

Instances

Ranked Int8

Defined in Data.Bits.Extras

Methods

lsb :: Int8 -> Int

rank :: Int8 -> Int

nlz :: Int8 -> Int

Ranked Int16

Defined in Data.Bits.Extras

Methods

lsb :: Int16 -> Int

rank :: Int16 -> Int

nlz :: Int16 -> Int

Ranked Int32

Defined in Data.Bits.Extras

Methods

lsb :: Int32 -> Int

rank :: Int32 -> Int

nlz :: Int32 -> Int

Ranked Int64

Defined in Data.Bits.Extras

Methods

lsb :: Int64 -> Int

rank :: Int64 -> Int

nlz :: Int64 -> Int

Ranked Word8

Defined in Data.Bits.Extras

Methods

lsb :: Word8 -> Int

rank :: Word8 -> Int

nlz :: Word8 -> Int

Ranked Word16

Defined in Data.Bits.Extras

Methods

lsb :: Word16 -> Int

rank :: Word16 -> Int

nlz :: Word16 -> Int

Ranked Word32

Defined in Data.Bits.Extras

Methods

lsb :: Word32 -> Int

rank :: Word32 -> Int

nlz :: Word32 -> Int

Ranked Word64

Defined in Data.Bits.Extras

Methods

lsb :: Word64 -> Int

rank :: Word64 -> Int

nlz :: Word64 -> Int

log2 :: Word32 -> Int

word32Log2 :: Word32 -> Int

msb :: Ranked t => t -> Int

Calculate the most significant set bit.

w8 :: Integral a => a -> Word8

w16 :: Integral a => a -> Word16

w32 :: Integral a => a -> Word32

w64 :: Integral a => a -> Word64

assignBit :: Bits b => b -> Int -> Bool -> b

zeroBits :: Bits a => a

zeroBits is the value with all bits unset.

The following laws ought to hold (for all valid bit indices n):

• clearBit zeroBits n == zeroBits

• setBit   zeroBits n == bit n

• testBit  zeroBits n == False

• popCount zeroBits   == 0

This method uses clearBit (bit 0) 0 as its default implementation (which ought to be equivalent to zeroBits for types which possess a 0th bit).

Since: base-4.7.0.0

oneBits :: FiniteBits b => b

A more concise version of complement zeroBits.

>>> complement (zeroBits :: Word) == (oneBits :: Word)
True

>>> complement (oneBits :: Word) == (zeroBits :: Word)
True

Note

The constraint on oneBits is arguably too strong. However, as some types (such as Natural) have undefined complement, this is the only safe choice.

unsafeOneBits :: Bits b => b

A version of oneBits that weakens the context from FiniteBits to Bits. This is unsafe because there are some data types with Bits instances that have undefined complement, such as Natural. Nevertheless, it is sometimes useful to call this function on data types without FiniteBits instances (e.g., Integer), so this function is provided as a convenience.

srl :: Bits b => b -> Int -> b

Shift Right Logical (i.e., without sign extension)

NB: When used on negative Integers, hilarity may ensue.