| 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
- newtype Nucleotide = N {}
- newtype Nucleotides = Ns {}
- newtype Qual = Q {}
- 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 = Pr {
- unPr :: a
- type Prob = Prob' Double
- 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
- data Pair a b = !a :!: !b
- data Word8
- nucA :: Nucleotide
- nucC :: Nucleotide
- nucG :: Nucleotide
- nucT :: Nucleotide
- nucsA :: Nucleotides
- nucsC :: Nucleotides
- nucsG :: Nucleotides
- nucsT :: Nucleotides
- nucsN :: Nucleotides
- gap :: Nucleotides
- toNucleotide :: Word8 -> Nucleotide
- toNucleotides :: Word8 -> Nucleotides
- nucToNucs :: Nucleotide -> Nucleotides
- showNucleotide :: Nucleotide -> Char
- showNucleotides :: Nucleotides -> Char
- isGap :: Nucleotides -> Bool
- isBase :: Nucleotides -> Bool
- isProperBase :: Nucleotides -> Bool
- properBases :: [Nucleotides]
- compl :: Nucleotide -> Nucleotide
- compls :: Nucleotides -> Nucleotides
- data Position = Pos {
- p_seq :: !ByteString
- p_start :: !Int
- shiftPosition :: Int -> Position -> Position
- p_is_reverse :: Position -> Bool
- data Range = Range {}
- shiftRange :: Int -> Range -> Range
- reverseRange :: Range -> Range
- extendRange :: Int -> Range -> Range
- insideRange :: Range -> Range -> Range
- wrapRange :: Int -> Range -> Range
Documentation
newtype Nucleotide Source #
A nucleotide base. We only represent A,C,G,T. The contained
Word8 ist guaranteed to be 0..3.
Instances
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.
Instances
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, which means lower error probability.
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.
Instances
| Eq a => Eq (Prob' a) Source # | |
| (Floating a, Fractional a, Ord a) => Fractional (Prob' a) Source # | |
| (Floating a, Ord a) => Num (Prob' a) Source # | |
| Ord a => Ord (Prob' a) Source # | |
| RealFloat a => Show (Prob' a) Source # | |
| Storable a => Storable (Prob' a) Source # | |
A strict pair.
Constructors
| !a :!: !b infixl 2 |
Instances
| (Bounded a, Bounded b) => Bounded (Pair a b) Source # | |
| (Eq a, Eq b) => Eq (Pair a b) Source # | |
| (Ord a, Ord b) => Ord (Pair a b) Source # | |
Defined in Bio.Base | |
| (Read a, Read b) => Read (Pair a b) Source # | |
| (Show a, Show b) => Show (Pair a b) Source # | |
| (Ix a, Ix b) => Ix (Pair a b) Source # | |
Defined in Bio.Base Methods range :: (Pair a b, Pair a b) -> [Pair a b] # index :: (Pair a b, Pair a b) -> Pair a b -> Int # unsafeIndex :: (Pair a b, Pair a b) -> Pair a b -> Int # inRange :: (Pair a b, Pair a b) -> Pair a b -> Bool # rangeSize :: (Pair a b, Pair a b) -> Int # unsafeRangeSize :: (Pair a b, Pair a b) -> Int # | |
8-bit unsigned integer type
Instances
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 :: Word8 -> Nucleotide Source #
Converts a character into a Nucleotide.
The codes for A,C,G understood, everything else is a T. (Error
detection is the caller's responsibility.
toNucleotides :: Word8 -> Nucleotides Source #
Converts a character into a Nucleotides.
The usual codes for A,C,G,T and U are understood along with the IUPAC
ambiguity codes, - 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.
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
| |
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 #
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).
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 interprets insideRange range2)range1 as a subrange of
range2 and computes its absolute coordinates. The sequence name of
range1 is ignored.