Safe Haskell	None
Language	Haskell2010

Bio.Base

Description

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.

Synopsis

Documentation

newtype Nucleotide Source #

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 Source #
Methods minBound :: Nucleotide # maxBound :: Nucleotide #
Enum Nucleotide Source #
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 Source #
Methods (==) :: Nucleotide -> Nucleotide -> Bool # (/=) :: Nucleotide -> Nucleotide -> Bool #
Ord Nucleotide Source #
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 Source #
Methods readsPrec :: Int -> ReadS Nucleotide # readList :: ReadS [Nucleotide] # readPrec :: ReadPrec Nucleotide # readListPrec :: ReadPrec [Nucleotide] #
Show Nucleotide Source #
Methods showsPrec :: Int -> Nucleotide -> ShowS # show :: Nucleotide -> String # showList :: [Nucleotide] -> ShowS #
Ix Nucleotide Source #
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 Source #
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 Source #

Vector Vector Nucleotide Source #
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 Source #
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 Source #
data Vector Nucleotide = V_Nucleotide (Vector Word8)
data MVector s Nucleotide Source #
data MVector s Nucleotide = MV_Nucleotide (MVector s Word8)

newtype Nucleotides Source #

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 Source #
Methods minBound :: Nucleotides # maxBound :: Nucleotides #
Enum Nucleotides Source #
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 Source #
Methods (==) :: Nucleotides -> Nucleotides -> Bool # (/=) :: Nucleotides -> Nucleotides -> Bool #
Ord Nucleotides Source #
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 Source #
Methods readsPrec :: Int -> ReadS Nucleotides # readList :: ReadS [Nucleotides] # readPrec :: ReadPrec Nucleotides # readListPrec :: ReadPrec [Nucleotides] #
Show Nucleotides Source #
Methods showsPrec :: Int -> Nucleotides -> ShowS # show :: Nucleotides -> String # showList :: [Nucleotides] -> ShowS #
Ix Nucleotides Source #
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 Source #
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 Source #

Vector Vector Nucleotides Source #
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 Source #
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 Source #
data Vector Nucleotides = V_Nucleotides (Vector Word8)
data MVector s Nucleotides Source #
data MVector s Nucleotides = MV_Nucleotides (MVector s Word8)

newtype Qual Source #

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 Source #
Methods minBound :: Qual # maxBound :: Qual #
Eq Qual Source #
Methods (==) :: Qual -> Qual -> Bool # (/=) :: Qual -> Qual -> Bool #
Ord Qual Source #
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 Source #
Methods showsPrec :: Int -> Qual -> ShowS # show :: Qual -> String # showList :: [Qual] -> ShowS #
Storable Qual Source #
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 Source #

Vector Vector Qual Source #
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 Source #
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 Source #
data Vector Qual = V_Qual (Vector Word8)
data MVector s Qual Source #
data MVector s Qual = MV_Qual (MVector s Word8)

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

fromQual :: Qual -> Double Source #

fromQualRaised :: Double -> Qual -> Double Source #

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

newtype Prob' a Source #

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) Source #
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) Source #
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) Source #
Methods (==) :: Prob' a -> Prob' a -> Bool # (/=) :: Prob' a -> Prob' a -> Bool #
(Floating a, Fractional a, Ord a) => Fractional (Prob' a) Source #
Methods (/) :: Prob' a -> Prob' a -> Prob' a # recip :: Prob' a -> Prob' a # fromRational :: Rational -> Prob' a #
(Floating a, Ord a) => Num (Prob' a) Source #
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) Source #
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) Source #
Methods showsPrec :: Int -> Prob' a -> ShowS # show :: Prob' a -> String # showList :: [Prob' a] -> ShowS #
Storable a => Storable (Prob' a) Source #
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) Source #

data MVector s (Prob' a) Source #
data MVector s (Prob' a) = MV_Prob' (MVector s a)
data Vector (Prob' a) Source #
data Vector (Prob' a) = V_Prob' (Vector a)

type Prob = Prob' Double Source #

Common way of using Prob'.

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

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

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

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

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 #
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 #
Hashable Word8
Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Prim Word8
Methods sizeOf# :: Word8 -> Int# # alignment# :: Word8 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word8 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#) # writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s #
Unbox Word8

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 Source #

nucC :: Nucleotide Source #

nucG :: Nucleotide Source #

nucT :: Nucleotide Source #

nucsA :: Nucleotides Source #

nucsC :: Nucleotides Source #

nucsG :: Nucleotides Source #

nucsT :: Nucleotides Source #

nucsN :: Nucleotides Source #

gap :: Nucleotides Source #

toNucleotide :: Char -> Nucleotide Source #

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 Source #

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 Source #

showNucleotide :: Nucleotide -> Char Source #

showNucleotides :: Nucleotides -> Char Source #

isGap :: Nucleotides -> Bool Source #

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

isBase :: Nucleotides -> Bool Source #

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

isProperBase :: Nucleotides -> Bool Source #

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

properBases :: [Nucleotides] Source #

compl :: Nucleotide -> Nucleotide Source #

Complements a Nucleotides.

compls :: Nucleotides -> Nucleotides Source #

Complements a Nucleotides.

type Seqid = ByteString Source #

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

data Position Source #

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 Source #
Methods (==) :: Position -> Position -> Bool # (/=) :: Position -> Position -> Bool #
Ord Position Source #
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 Source #
Methods showsPrec :: Int -> Position -> ShowS # show :: Position -> String # showList :: [Position] -> ShowS #

shiftPosition :: Int -> Position -> Position Source #

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

p_is_reverse :: Position -> Bool Source #

data Range Source #

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 Source #
Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Ord Range Source #
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 Source #
Methods showsPrec :: Int -> Range -> ShowS # show :: Range -> String # showList :: [Range] -> ShowS #

shiftRange :: Int -> Range -> Range Source #

Moves a Range. This is just shiftPosition lifted.

reverseRange :: Range -> Range Source #

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

extendRange :: Int -> Range -> Range Source #

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

insideRange :: Range -> Range -> Range Source #

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 Source #

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 Source #

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