Bio.Base

Common data types used everywhere. This module is a collection of very basic "bioinformatics" data types that are simple, but don't make sense to define over and over.

Documentation

newtype Nucleotide

A nucleotide base. We only represent A,C,G,T. The contained Word8 ist guaranteed to be 0..3.

Constructors

N

Fields

• unN :: Word8

Instances

Bounded Nucleotide

Methods

minBound :: Nucleotide

maxBound :: Nucleotide

Enum Nucleotide

Methods

succ :: Nucleotide -> Nucleotide

pred :: Nucleotide -> Nucleotide

toEnum :: Int -> Nucleotide

fromEnum :: Nucleotide -> Int

enumFrom :: Nucleotide -> [Nucleotide]

enumFromThen :: Nucleotide -> Nucleotide -> [Nucleotide]

enumFromTo :: Nucleotide -> Nucleotide -> [Nucleotide]

enumFromThenTo :: Nucleotide -> Nucleotide -> Nucleotide -> [Nucleotide]

Eq Nucleotide

Methods

(==) :: Nucleotide -> Nucleotide -> Bool

(/=) :: Nucleotide -> Nucleotide -> Bool

Ord Nucleotide

Methods

compare :: Nucleotide -> Nucleotide -> Ordering

(<) :: Nucleotide -> Nucleotide -> Bool

(<=) :: Nucleotide -> Nucleotide -> Bool

(>) :: Nucleotide -> Nucleotide -> Bool

(>=) :: Nucleotide -> Nucleotide -> Bool

max :: Nucleotide -> Nucleotide -> Nucleotide

min :: Nucleotide -> Nucleotide -> Nucleotide

Read Nucleotide

Methods

readsPrec :: Int -> ReadS Nucleotide

readList :: ReadS [Nucleotide]

readPrec :: ReadPrec Nucleotide

readListPrec :: ReadPrec [Nucleotide]

Show Nucleotide

Methods

showsPrec :: Int -> Nucleotide -> ShowS

show :: Nucleotide -> String

showList :: [Nucleotide] -> ShowS

Ix Nucleotide

Methods

range :: (Nucleotide, Nucleotide) -> [Nucleotide]

index :: (Nucleotide, Nucleotide) -> Nucleotide -> Int

unsafeIndex :: (Nucleotide, Nucleotide) -> Nucleotide -> Int

inRange :: (Nucleotide, Nucleotide) -> Nucleotide -> Bool

rangeSize :: (Nucleotide, Nucleotide) -> Int

unsafeRangeSize :: (Nucleotide, Nucleotide) -> Int

Storable Nucleotide

Methods

sizeOf :: Nucleotide -> Int

alignment :: Nucleotide -> Int

peekElemOff :: Ptr Nucleotide -> Int -> IO Nucleotide

pokeElemOff :: Ptr Nucleotide -> Int -> Nucleotide -> IO ()

peekByteOff :: Ptr b -> Int -> IO Nucleotide

pokeByteOff :: Ptr b -> Int -> Nucleotide -> IO ()

peek :: Ptr Nucleotide -> IO Nucleotide

poke :: Ptr Nucleotide -> Nucleotide -> IO ()

Unbox Nucleotide

Vector Vector Nucleotide

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Nucleotide -> m (Vector Nucleotide)

basicUnsafeThaw :: PrimMonad m => Vector Nucleotide -> m (Mutable Vector (PrimState m) Nucleotide)

basicLength :: Vector Nucleotide -> Int

basicUnsafeSlice :: Int -> Int -> Vector Nucleotide -> Vector Nucleotide

basicUnsafeIndexM :: Monad m => Vector Nucleotide -> Int -> m Nucleotide

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Nucleotide -> Vector Nucleotide -> m ()

elemseq :: Vector Nucleotide -> Nucleotide -> b -> b

MVector MVector Nucleotide

Methods

basicLength :: MVector s Nucleotide -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Nucleotide -> MVector s Nucleotide

basicOverlaps :: MVector s Nucleotide -> MVector s Nucleotide -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Nucleotide)

basicInitialize :: PrimMonad m => MVector (PrimState m) Nucleotide -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Nucleotide -> m (MVector (PrimState m) Nucleotide)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Nucleotide -> Int -> m Nucleotide

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Nucleotide -> Int -> Nucleotide -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Nucleotide -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Nucleotide -> Nucleotide -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Nucleotide -> MVector (PrimState m) Nucleotide -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Nucleotide -> MVector (PrimState m) Nucleotide -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Nucleotide -> Int -> m (MVector (PrimState m) Nucleotide)

data Vector Nucleotide

data Vector Nucleotide = V_Nucleotide (Vector Word8)

data MVector s Nucleotide

data MVector s Nucleotide = MV_Nucleotide (MVector s Word8)

newtype Nucleotides

A nucleotide base in an alignment. Experience says we're dealing with Ns and gaps all the type, so purity be damned, they are included as if they were real bases.

To allow Nucleotidess to be unpacked and incorporated into containers, we choose to represent them the same way as the BAM file format: as a 4 bit wide field. Gaps are encoded as 0 where they make sense, N is 15. The contained Word8 is guaranteed to be 0..15.

Constructors

Ns

Fields

• unNs :: Word8

Instances

Bounded Nucleotides

Methods

minBound :: Nucleotides

maxBound :: Nucleotides

Enum Nucleotides

Methods

succ :: Nucleotides -> Nucleotides

pred :: Nucleotides -> Nucleotides

toEnum :: Int -> Nucleotides

fromEnum :: Nucleotides -> Int

enumFrom :: Nucleotides -> [Nucleotides]

enumFromThen :: Nucleotides -> Nucleotides -> [Nucleotides]

enumFromTo :: Nucleotides -> Nucleotides -> [Nucleotides]

enumFromThenTo :: Nucleotides -> Nucleotides -> Nucleotides -> [Nucleotides]

Eq Nucleotides

Methods

(==) :: Nucleotides -> Nucleotides -> Bool

(/=) :: Nucleotides -> Nucleotides -> Bool

Ord Nucleotides

Methods

compare :: Nucleotides -> Nucleotides -> Ordering

(<) :: Nucleotides -> Nucleotides -> Bool

(<=) :: Nucleotides -> Nucleotides -> Bool

(>) :: Nucleotides -> Nucleotides -> Bool

(>=) :: Nucleotides -> Nucleotides -> Bool

max :: Nucleotides -> Nucleotides -> Nucleotides

min :: Nucleotides -> Nucleotides -> Nucleotides

Read Nucleotides

Methods

readsPrec :: Int -> ReadS Nucleotides

readList :: ReadS [Nucleotides]

readPrec :: ReadPrec Nucleotides

readListPrec :: ReadPrec [Nucleotides]

Show Nucleotides

Methods

showsPrec :: Int -> Nucleotides -> ShowS

show :: Nucleotides -> String

showList :: [Nucleotides] -> ShowS

Ix Nucleotides

Methods

range :: (Nucleotides, Nucleotides) -> [Nucleotides]

index :: (Nucleotides, Nucleotides) -> Nucleotides -> Int

unsafeIndex :: (Nucleotides, Nucleotides) -> Nucleotides -> Int

inRange :: (Nucleotides, Nucleotides) -> Nucleotides -> Bool

rangeSize :: (Nucleotides, Nucleotides) -> Int

unsafeRangeSize :: (Nucleotides, Nucleotides) -> Int

Storable Nucleotides

Methods

sizeOf :: Nucleotides -> Int

alignment :: Nucleotides -> Int

peekElemOff :: Ptr Nucleotides -> Int -> IO Nucleotides

pokeElemOff :: Ptr Nucleotides -> Int -> Nucleotides -> IO ()

peekByteOff :: Ptr b -> Int -> IO Nucleotides

pokeByteOff :: Ptr b -> Int -> Nucleotides -> IO ()

peek :: Ptr Nucleotides -> IO Nucleotides

poke :: Ptr Nucleotides -> Nucleotides -> IO ()

Unbox Nucleotides

Vector Vector Nucleotides

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Nucleotides -> m (Vector Nucleotides)

basicUnsafeThaw :: PrimMonad m => Vector Nucleotides -> m (Mutable Vector (PrimState m) Nucleotides)

basicLength :: Vector Nucleotides -> Int

basicUnsafeSlice :: Int -> Int -> Vector Nucleotides -> Vector Nucleotides

basicUnsafeIndexM :: Monad m => Vector Nucleotides -> Int -> m Nucleotides

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Nucleotides -> Vector Nucleotides -> m ()

elemseq :: Vector Nucleotides -> Nucleotides -> b -> b

Vector Vector_Nucs_half Nucleotides

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector_Nucs_half (PrimState m) Nucleotides -> m (Vector_Nucs_half Nucleotides)

basicUnsafeThaw :: PrimMonad m => Vector_Nucs_half Nucleotides -> m (Mutable Vector_Nucs_half (PrimState m) Nucleotides)

basicLength :: Vector_Nucs_half Nucleotides -> Int

basicUnsafeSlice :: Int -> Int -> Vector_Nucs_half Nucleotides -> Vector_Nucs_half Nucleotides

basicUnsafeIndexM :: Monad m => Vector_Nucs_half Nucleotides -> Int -> m Nucleotides

basicUnsafeCopy :: PrimMonad m => Mutable Vector_Nucs_half (PrimState m) Nucleotides -> Vector_Nucs_half Nucleotides -> m ()

elemseq :: Vector_Nucs_half Nucleotides -> Nucleotides -> b -> b

MVector MVector Nucleotides

Methods

basicLength :: MVector s Nucleotides -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Nucleotides -> MVector s Nucleotides

basicOverlaps :: MVector s Nucleotides -> MVector s Nucleotides -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Nucleotides)

basicInitialize :: PrimMonad m => MVector (PrimState m) Nucleotides -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Nucleotides -> m (MVector (PrimState m) Nucleotides)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Nucleotides -> Int -> m Nucleotides

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Nucleotides -> Int -> Nucleotides -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Nucleotides -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Nucleotides -> Nucleotides -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Nucleotides -> MVector (PrimState m) Nucleotides -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Nucleotides -> MVector (PrimState m) Nucleotides -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Nucleotides -> Int -> m (MVector (PrimState m) Nucleotides)

Show (Vector_Nucs_half Nucleotides)

Methods

showsPrec :: Int -> Vector_Nucs_half Nucleotides -> ShowS

show :: Vector_Nucs_half Nucleotides -> String

showList :: [Vector_Nucs_half Nucleotides] -> ShowS

data Vector Nucleotides

data Vector Nucleotides = V_Nucleotides (Vector Word8)

data MVector s Nucleotides

data MVector s Nucleotides = MV_Nucleotides (MVector s Word8)

newtype Qual

Qualities are stored in deciban, also known as the Phred scale. To represent a value p, we store -10 * log_10 p. Operations work directly on the "Phred" value, as the name suggests. The same goes for the Ord instance: greater quality means higher "Phred" score, meand lower error probability.

Constructors

Q

Fields

• unQ :: Word8

Instances

Bounded Qual

Methods

minBound :: Qual

maxBound :: Qual

Eq Qual

Methods

(==) :: Qual -> Qual -> Bool

(/=) :: Qual -> Qual -> Bool

Ord Qual

Methods

compare :: Qual -> Qual -> Ordering

(<) :: Qual -> Qual -> Bool

(<=) :: Qual -> Qual -> Bool

(>) :: Qual -> Qual -> Bool

(>=) :: Qual -> Qual -> Bool

max :: Qual -> Qual -> Qual

min :: Qual -> Qual -> Qual

Show Qual

Methods

showsPrec :: Int -> Qual -> ShowS

show :: Qual -> String

showList :: [Qual] -> ShowS

Storable Qual

Methods

sizeOf :: Qual -> Int

alignment :: Qual -> Int

peekElemOff :: Ptr Qual -> Int -> IO Qual

pokeElemOff :: Ptr Qual -> Int -> Qual -> IO ()

peekByteOff :: Ptr b -> Int -> IO Qual

pokeByteOff :: Ptr b -> Int -> Qual -> IO ()

peek :: Ptr Qual -> IO Qual

poke :: Ptr Qual -> Qual -> IO ()

Unbox Qual

Vector Vector Qual

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Qual -> m (Vector Qual)

basicUnsafeThaw :: PrimMonad m => Vector Qual -> m (Mutable Vector (PrimState m) Qual)

basicLength :: Vector Qual -> Int

basicUnsafeSlice :: Int -> Int -> Vector Qual -> Vector Qual

basicUnsafeIndexM :: Monad m => Vector Qual -> Int -> m Qual

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Qual -> Vector Qual -> m ()

elemseq :: Vector Qual -> Qual -> b -> b

MVector MVector Qual

Methods

basicLength :: MVector s Qual -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Qual -> MVector s Qual

basicOverlaps :: MVector s Qual -> MVector s Qual -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Qual)

basicInitialize :: PrimMonad m => MVector (PrimState m) Qual -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Qual -> m (MVector (PrimState m) Qual)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Qual -> Int -> m Qual

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Qual -> Int -> Qual -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Qual -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Qual -> Qual -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Qual -> MVector (PrimState m) Qual -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Qual -> MVector (PrimState m) Qual -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Qual -> Int -> m (MVector (PrimState m) Qual)

data Vector Qual

data Vector Qual = V_Qual (Vector Word8)

data MVector s Qual

data MVector s Qual = MV_Qual (MVector s Word8)

toQual :: (Floating a, RealFrac a) => a -> Qual

fromQual :: Qual -> Double

fromQualRaised :: Double -> Qual -> Double

probToQual :: (Floating a, RealFrac a) => Prob' a -> Qual

newtype Prob' a

A positive floating point value stored in log domain. We store the natural logarithm (makes computation easier), but allow conversions to the familiar "Phred" scale used for Qual values.

Constructors

Pr

Fields

• unPr :: a

Instances

Unbox a => Vector Vector (Prob' a)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Prob' a) -> m (Vector (Prob' a))

basicUnsafeThaw :: PrimMonad m => Vector (Prob' a) -> m (Mutable Vector (PrimState m) (Prob' a))

basicLength :: Vector (Prob' a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Prob' a) -> Vector (Prob' a)

basicUnsafeIndexM :: Monad m => Vector (Prob' a) -> Int -> m (Prob' a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Prob' a) -> Vector (Prob' a) -> m ()

elemseq :: Vector (Prob' a) -> Prob' a -> b -> b

Unbox a => MVector MVector (Prob' a)

Methods

basicLength :: MVector s (Prob' a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Prob' a) -> MVector s (Prob' a)

basicOverlaps :: MVector s (Prob' a) -> MVector s (Prob' a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Prob' a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Prob' a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Prob' a -> m (MVector (PrimState m) (Prob' a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Prob' a) -> Int -> m (Prob' a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Prob' a) -> Int -> Prob' a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Prob' a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Prob' a) -> Prob' a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Prob' a) -> MVector (PrimState m) (Prob' a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Prob' a) -> MVector (PrimState m) (Prob' a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Prob' a) -> Int -> m (MVector (PrimState m) (Prob' a))

Eq a => Eq (Prob' a)

Methods

(==) :: Prob' a -> Prob' a -> Bool

(/=) :: Prob' a -> Prob' a -> Bool

(Floating a, Fractional a, Ord a) => Fractional (Prob' a)

Methods

(/) :: Prob' a -> Prob' a -> Prob' a

recip :: Prob' a -> Prob' a

fromRational :: Rational -> Prob' a

(Floating a, Ord a) => Num (Prob' a)

Methods

(+) :: Prob' a -> Prob' a -> Prob' a

(-) :: Prob' a -> Prob' a -> Prob' a

(*) :: Prob' a -> Prob' a -> Prob' a

negate :: Prob' a -> Prob' a

abs :: Prob' a -> Prob' a

signum :: Prob' a -> Prob' a

fromInteger :: Integer -> Prob' a

Ord a => Ord (Prob' a)

Methods

compare :: Prob' a -> Prob' a -> Ordering

(<) :: Prob' a -> Prob' a -> Bool

(<=) :: Prob' a -> Prob' a -> Bool

(>) :: Prob' a -> Prob' a -> Bool

(>=) :: Prob' a -> Prob' a -> Bool

max :: Prob' a -> Prob' a -> Prob' a

min :: Prob' a -> Prob' a -> Prob' a

RealFloat a => Show (Prob' a)

Methods

showsPrec :: Int -> Prob' a -> ShowS

show :: Prob' a -> String

showList :: [Prob' a] -> ShowS

Storable a => Storable (Prob' a)

Methods

sizeOf :: Prob' a -> Int

alignment :: Prob' a -> Int

peekElemOff :: Ptr (Prob' a) -> Int -> IO (Prob' a)

pokeElemOff :: Ptr (Prob' a) -> Int -> Prob' a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Prob' a)

pokeByteOff :: Ptr b -> Int -> Prob' a -> IO ()

peek :: Ptr (Prob' a) -> IO (Prob' a)

poke :: Ptr (Prob' a) -> Prob' a -> IO ()

Unbox a => Unbox (Prob' a)

data MVector s (Prob' a)

data MVector s (Prob' a) = MV_Prob' (MVector s a)

data Vector (Prob' a)

data Vector (Prob' a) = V_Prob' (Vector a)

type Prob = Prob' Double

Common way of using Prob'.

toProb :: Floating a => a -> Prob' a

fromProb :: Floating a => Prob' a -> a

qualToProb :: Floating a => Qual -> Prob' a

pow :: Num a => Prob' a -> a -> Prob' a infixr 8

data Word8

8-bit unsigned integer type

Instances

Bounded Word8

Since: 2.1

Methods

minBound :: Word8

maxBound :: Word8

Enum Word8

Since: 2.1

Methods

succ :: Word8 -> Word8

pred :: Word8 -> Word8

toEnum :: Int -> Word8

fromEnum :: Word8 -> Int

enumFrom :: Word8 -> [Word8]

enumFromThen :: Word8 -> Word8 -> [Word8]

enumFromTo :: Word8 -> Word8 -> [Word8]

enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8]

Eq Word8

Since: 2.1

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Integral Word8

Since: 2.1

Methods

quot :: Word8 -> Word8 -> Word8

rem :: Word8 -> Word8 -> Word8

div :: Word8 -> Word8 -> Word8

mod :: Word8 -> Word8 -> Word8

quotRem :: Word8 -> Word8 -> (Word8, Word8)

divMod :: Word8 -> Word8 -> (Word8, Word8)

toInteger :: Word8 -> Integer

Data Word8

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8

toConstr :: Word8 -> Constr

dataTypeOf :: Word8 -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8)

gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r

gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8

Num Word8

Since: 2.1

Methods

(+) :: Word8 -> Word8 -> Word8

(-) :: Word8 -> Word8 -> Word8

(*) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Ord Word8

Since: 2.1

Methods

compare :: Word8 -> Word8 -> Ordering

(<) :: Word8 -> Word8 -> Bool

(<=) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(>=) :: Word8 -> Word8 -> Bool

max :: Word8 -> Word8 -> Word8

min :: Word8 -> Word8 -> Word8

Read Word8

Since: 2.1

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Real Word8

Since: 2.1

Methods

toRational :: Word8 -> Rational

Show Word8

Since: 2.1

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Ix Word8

Since: 2.1

Methods

range :: (Word8, Word8) -> [Word8]

index :: (Word8, Word8) -> Word8 -> Int

unsafeIndex :: (Word8, Word8) -> Word8 -> Int

inRange :: (Word8, Word8) -> Word8 -> Bool

rangeSize :: (Word8, Word8) -> Int

unsafeRangeSize :: (Word8, Word8) -> Int

Lift Word8

Methods

lift :: Word8 -> Q Exp

PrintfArg Word8

Since: 2.1

Methods

formatArg :: Word8 -> FieldFormatter

parseFormat :: Word8 -> ModifierParser

Storable Word8

Since: 2.1

Methods

sizeOf :: Word8 -> Int

alignment :: Word8 -> Int

peekElemOff :: Ptr Word8 -> Int -> IO Word8

pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word8

pokeByteOff :: Ptr b -> Int -> Word8 -> IO ()

peek :: Ptr Word8 -> IO Word8

poke :: Ptr Word8 -> Word8 -> IO ()

Bits Word8

Since: 2.1

Methods

(.&.) :: Word8 -> Word8 -> Word8

(.|.) :: Word8 -> Word8 -> Word8

xor :: Word8 -> Word8 -> Word8

complement :: Word8 -> Word8

shift :: Word8 -> Int -> Word8

rotate :: Word8 -> Int -> Word8

zeroBits :: Word8

bit :: Int -> Word8

setBit :: Word8 -> Int -> Word8

clearBit :: Word8 -> Int -> Word8

complementBit :: Word8 -> Int -> Word8

testBit :: Word8 -> Int -> Bool

bitSizeMaybe :: Word8 -> Maybe Int

bitSize :: Word8 -> Int

isSigned :: Word8 -> Bool

shiftL :: Word8 -> Int -> Word8

unsafeShiftL :: Word8 -> Int -> Word8

shiftR :: Word8 -> Int -> Word8

unsafeShiftR :: Word8 -> Int -> Word8

rotateL :: Word8 -> Int -> Word8

rotateR :: Word8 -> Int -> Word8

popCount :: Word8 -> Int

FiniteBits Word8

Since: 4.6.0.0

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

Unbox Word8

Prim Word8

Methods

sizeOf# :: Word8 -> Int#

alignment# :: Word8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word8#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word8

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word8#)

writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s

Hashable Word8

Methods

hashWithSalt :: Int -> Word8 -> Int

hash :: Word8 -> Int

Vector Vector Word8

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8)

basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8)

basicLength :: Vector Word8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8

basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m ()

elemseq :: Vector Word8 -> Word8 -> b -> b

MVector MVector Word8

Methods

basicLength :: MVector s Word8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8

basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8)

data Vector Word8

data Vector Word8 = V_Word8 (Vector Word8)

data MVector s Word8

data MVector s Word8 = MV_Word8 (MVector s Word8)

nucA :: Nucleotide

nucC :: Nucleotide

nucG :: Nucleotide

nucT :: Nucleotide

nucsA :: Nucleotides

nucsC :: Nucleotides

nucsG :: Nucleotides

nucsT :: Nucleotides

nucsN :: Nucleotides

gap :: Nucleotides

toNucleotide :: Char -> Nucleotide

Converts a character into a Nucleotides. The usual codes for A,C,G,T and U are understood, - and . become gaps and everything else is an N.

toNucleotides :: Char -> Nucleotides

Converts a character into a Nucleotides. The usual codes for A,C,G,T and U are understood, - and . become gaps and everything else is an N.

nucToNucs :: Nucleotide -> Nucleotides

showNucleotide :: Nucleotide -> Char

showNucleotides :: Nucleotides -> Char

isGap :: Nucleotides -> Bool

Tests if a Nucleotides is a gap. Returns true only for the gap.

isBase :: Nucleotides -> Bool

Tests if a Nucleotides is a base. Returns True for everything but gaps.

isProperBase :: Nucleotides -> Bool

Tests if a Nucleotides is a proper base. Returns True for A,C,G,T only.

properBases :: [Nucleotides]

compl :: Nucleotide -> Nucleotide

Complements a Nucleotides.

compls :: Nucleotides -> Nucleotides

Complements a Nucleotides.

type Seqid = ByteString

Sequence identifiers are ASCII strings Since we tend to store them for a while, we use strict byte strings.

data Position

Coordinates in a genome. The position is zero-based, no questions about it. Think of the position as pointing to the crack between two bases: looking forward you see the next base to the right, looking in the reverse direction you see the complement of the first base to the left.

To encode the strand, we (virtually) reverse-complement any sequence and prepend it to the normal one. That way, reversed coordinates have a negative sign and automatically make sense. Position 0 could either be the beginning of the sequence or the end on the reverse strand... that ambiguity shouldn't really matter.

Constructors

Pos

Fields

• p_seq :: !Seqid

  sequence (e.g. some chromosome)

• p_start :: !Int

  offset, zero-based

Instances

Eq Position

Methods

(==) :: Position -> Position -> Bool

(/=) :: Position -> Position -> Bool

Ord Position

Methods

compare :: Position -> Position -> Ordering

(<) :: Position -> Position -> Bool

(<=) :: Position -> Position -> Bool

(>) :: Position -> Position -> Bool

(>=) :: Position -> Position -> Bool

max :: Position -> Position -> Position

min :: Position -> Position -> Position

Show Position

Methods

showsPrec :: Int -> Position -> ShowS

show :: Position -> String

showList :: [Position] -> ShowS

shiftPosition :: Int -> Position -> Position

Moves a Position. The position is moved forward according to the strand, negative indexes move backward accordingly.

p_is_reverse :: Position -> Bool

data Range

Ranges in genomes We combine a position with a length. In 'Range pos len', pos is always the start of a stretch of length len. Positions therefore move in the opposite direction on the reverse strand. To get the same stretch on the reverse strand, shift r_pos by r_length, then reverse direction (or call reverseRange).

Constructors

Range

Fields

• r_pos :: !Position
• r_length :: !Int

Instances

Eq Range

Methods

(==) :: Range -> Range -> Bool

(/=) :: Range -> Range -> Bool

Ord Range

Methods

compare :: Range -> Range -> Ordering

(<) :: Range -> Range -> Bool

(<=) :: Range -> Range -> Bool

(>) :: Range -> Range -> Bool

(>=) :: Range -> Range -> Bool

max :: Range -> Range -> Range

min :: Range -> Range -> Range

Show Range

Methods

showsPrec :: Int -> Range -> ShowS

show :: Range -> String

showList :: [Range] -> ShowS

shiftRange :: Int -> Range -> Range

Moves a Range. This is just shiftPosition lifted.

reverseRange :: Range -> Range

Reverses a Range to give the same Range on the opposite strand.

extendRange :: Int -> Range -> Range

Extends a range. The length of the range is simply increased.

insideRange :: Range -> Range -> Range

Expands a subrange. (range1 insideRange range2) interprets range1 as a subrange of range2 and computes its absolute coordinates. The sequence name of range1 is ignored.

wrapRange :: Int -> Range -> Range

Wraps a range to a region. This simply normalizes the start position to be in the interval '[0,n)', which only makes sense if the Range is to be mapped onto a circular genome. This works on both strands and the strand information is retained.

w2c :: Word8 -> Char

Conversion between Word8 and Char. Should compile to a no-op.

c2w :: Char -> Word8

Unsafe conversion between Char and Word8. This is a no-op and silently truncates to 8 bits Chars > '\255'. It is provided as convenience for ByteString construction.

findAuxFile :: FilePath -> IO FilePath

Finds a file by searching the environment variable BIOHAZARD like a PATH.