Bio.Chain.Alignment

Alignment function

align :: forall algo m m'. (SequenceAlignment algo, Alignable m, Alignable m') => algo (IxValue m) (IxValue m') -> m -> m' -> AlignmentResult m m'

Align chains using specifed algorithm

Alignment algorithms

newtype EditDistance e1 e2

Constructors

EditDistance (e1 -> e2 -> Bool)

data GlobalAlignment a e1 e2

Constructors

GlobalAlignment (Scoring e1 e2) a

Instances

IsGap g => SequenceAlignment (GlobalAlignment g)

Defined in Bio.Chain.Alignment.Algorithms

Methods

semi :: GlobalAlignment g e1 e2 -> Bool

cond :: (Alignable m, Alignable m') => GlobalAlignment g (IxValue m) (IxValue m') -> Conditions m m'

traceStart :: (Alignable m, Alignable m') => GlobalAlignment g (IxValue m) (IxValue m') -> Matrix m m' -> m -> m' -> (Index m, Index m')

scoreMatrix :: (Alignable m, Alignable m') => GlobalAlignment g (IxValue m) (IxValue m') -> m -> m' -> Matrix m m'

data LocalAlignment a e1 e2

Constructors

LocalAlignment (Scoring e1 e2) a

Instances

IsGap g => SequenceAlignment (LocalAlignment g)

Defined in Bio.Chain.Alignment.Algorithms

Methods

semi :: LocalAlignment g e1 e2 -> Bool

cond :: (Alignable m, Alignable m') => LocalAlignment g (IxValue m) (IxValue m') -> Conditions m m'

traceStart :: (Alignable m, Alignable m') => LocalAlignment g (IxValue m) (IxValue m') -> Matrix m m' -> m -> m' -> (Index m, Index m')

scoreMatrix :: (Alignable m, Alignable m') => LocalAlignment g (IxValue m) (IxValue m') -> m -> m' -> Matrix m m'

data SemiglobalAlignment a e1 e2

Constructors

SemiglobalAlignment (Scoring e1 e2) a

Instances

IsGap g => SequenceAlignment (SemiglobalAlignment g)

Defined in Bio.Chain.Alignment.Algorithms

Methods

semi :: SemiglobalAlignment g e1 e2 -> Bool

cond :: (Alignable m, Alignable m') => SemiglobalAlignment g (IxValue m) (IxValue m') -> Conditions m m'

traceStart :: (Alignable m, Alignable m') => SemiglobalAlignment g (IxValue m) (IxValue m') -> Matrix m m' -> m -> m' -> (Index m, Index m')

scoreMatrix :: (Alignable m, Alignable m') => SemiglobalAlignment g (IxValue m) (IxValue m') -> m -> m' -> Matrix m m'

type SimpleGap = Int

Simple gap penalty

type SimpleGap2 = (SimpleGap, SimpleGap)

Gap penalty with different SimpleGap penalties for sequences.

First element of pair is penalty for first sequence passed to alignment algorithm, second element — penalty for second passed sequence.

data AffineGap

Affine gap penalty

Constructors

AffineGap

Fields

• gapOpen :: Int
• gapExtend :: Int

Instances

Eq AffineGap

Defined in Bio.Chain.Alignment.Type

Methods

(==) :: AffineGap -> AffineGap -> Bool

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

Show AffineGap

Defined in Bio.Chain.Alignment.Type

Methods

showsPrec :: Int -> AffineGap -> ShowS

show :: AffineGap -> String

showList :: [AffineGap] -> ShowS

Generic AffineGap

Defined in Bio.Chain.Alignment.Type

Associated Types

type Rep AffineGap :: Type -> Type

Methods

from :: AffineGap -> Rep AffineGap x

to :: Rep AffineGap x -> AffineGap

NFData AffineGap

Defined in Bio.Chain.Alignment.Type

Methods

rnf :: AffineGap -> ()

IsGap AffineGap2

Defined in Bio.Chain.Alignment.Type

Methods

insertCostOpen :: AffineGap2 -> Int

insertCostExtend :: AffineGap2 -> Int

deleteCostOpen :: AffineGap2 -> Int

deleteCostExtend :: AffineGap2 -> Int

isAffine :: AffineGap2 -> Bool

IsGap AffineGap

Defined in Bio.Chain.Alignment.Type

Methods

insertCostOpen :: AffineGap -> Int

insertCostExtend :: AffineGap -> Int

deleteCostOpen :: AffineGap -> Int

deleteCostExtend :: AffineGap -> Int

isAffine :: AffineGap -> Bool

type Rep AffineGap

Defined in Bio.Chain.Alignment.Type

type Rep AffineGap = D1 ('MetaData "AffineGap" "Bio.Chain.Alignment.Type" "cobot-0.1.1.7-1gG22cBgMSxAc2IJYQchnS" 'False) (C1 ('MetaCons "AffineGap" 'PrefixI 'True) (S1 ('MetaSel ('Just "gapOpen") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Just "gapExtend") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))

type AffineGap2 = (AffineGap, AffineGap)

Gap penalty with different AffineGap penalties for sequences.

First element of pair is penalty for first sequence passed to alignment algorithm, second element — penalty for second passed sequence.

class IsGap a where

Type class that describes possible gaps in alignments.

Minimal complete definition

insertCostOpen, insertCostExtend, deleteCostOpen, deleteCostExtend

Methods

insertCostOpen :: a -> Int

Insertions are gaps in the first argument of an alignment function.

insertCostExtend :: a -> Int

deleteCostOpen :: a -> Int

Deletions are gaps in the second argument of an alignment function.

deleteCostExtend :: a -> Int

isAffine :: a -> Bool

Instances

IsGap AffineGap2

Defined in Bio.Chain.Alignment.Type

Methods

insertCostOpen :: AffineGap2 -> Int

insertCostExtend :: AffineGap2 -> Int

deleteCostOpen :: AffineGap2 -> Int

deleteCostExtend :: AffineGap2 -> Int

isAffine :: AffineGap2 -> Bool

IsGap AffineGap

Defined in Bio.Chain.Alignment.Type

Methods

insertCostOpen :: AffineGap -> Int

insertCostExtend :: AffineGap -> Int

deleteCostOpen :: AffineGap -> Int

deleteCostExtend :: AffineGap -> Int

isAffine :: AffineGap -> Bool

IsGap SimpleGap2

Defined in Bio.Chain.Alignment.Type

Methods

insertCostOpen :: SimpleGap2 -> Int

insertCostExtend :: SimpleGap2 -> Int

deleteCostOpen :: SimpleGap2 -> Int

deleteCostExtend :: SimpleGap2 -> Int

isAffine :: SimpleGap2 -> Bool

IsGap SimpleGap

Defined in Bio.Chain.Alignment.Type

Methods

insertCostOpen :: SimpleGap -> Int

insertCostExtend :: SimpleGap -> Int

deleteCostOpen :: SimpleGap -> Int

deleteCostExtend :: SimpleGap -> Int

isAffine :: SimpleGap -> Bool

Alignment result types

data AlignmentResult m m'

Sequence Alignment result

Constructors

AlignmentResult

Fields

• score :: Int

  Resulting score of alignment

• alignment :: [Operation (Index m) (Index m')]

  Alignment structure

• sequence1 :: m

  First chain

• sequence2 :: m'

  Second chain

Instances

Generic (AlignmentResult m m')

Defined in Bio.Chain.Alignment.Type

Associated Types

type Rep (AlignmentResult m m') :: Type -> Type

Methods

from :: AlignmentResult m m' -> Rep (AlignmentResult m m') x

to :: Rep (AlignmentResult m m') x -> AlignmentResult m m'

(NFData a, NFData b, NFData (Index a), NFData (Index b)) => NFData (AlignmentResult a b)

Defined in Bio.Chain.Alignment.Type

Methods

rnf :: AlignmentResult a b -> ()

type Rep (AlignmentResult m m')

Defined in Bio.Chain.Alignment.Type

type Rep (AlignmentResult m m') = D1 ('MetaData "AlignmentResult" "Bio.Chain.Alignment.Type" "cobot-0.1.1.7-1gG22cBgMSxAc2IJYQchnS" 'False) (C1 ('MetaCons "AlignmentResult" 'PrefixI 'True) ((S1 ('MetaSel ('Just "score") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Just "alignment") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Operation (Index m) (Index m')])) :*: (S1 ('MetaSel ('Just "sequence1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 m) :*: S1 ('MetaSel ('Just "sequence2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 m'))))

data Operation i j

Operation that was performed on current step of alignment

Constructors

INSERT

Fields

• getJ :: j

DELETE

Fields

• getI :: i

MATCH

Fields

• getI :: i
• getJ :: j

Instances

(Eq j, Eq i) => Eq (Operation i j)

Defined in Bio.Chain.Alignment.Type

Methods

(==) :: Operation i j -> Operation i j -> Bool

(/=) :: Operation i j -> Operation i j -> Bool

(Ord j, Ord i) => Ord (Operation i j)

Defined in Bio.Chain.Alignment.Type

Methods

compare :: Operation i j -> Operation i j -> Ordering

(<) :: Operation i j -> Operation i j -> Bool

(<=) :: Operation i j -> Operation i j -> Bool

(>) :: Operation i j -> Operation i j -> Bool

(>=) :: Operation i j -> Operation i j -> Bool

max :: Operation i j -> Operation i j -> Operation i j

min :: Operation i j -> Operation i j -> Operation i j

(Show j, Show i) => Show (Operation i j)

Defined in Bio.Chain.Alignment.Type

Methods

showsPrec :: Int -> Operation i j -> ShowS

show :: Operation i j -> String

showList :: [Operation i j] -> ShowS

Generic (Operation i j)

Defined in Bio.Chain.Alignment.Type

Associated Types

type Rep (Operation i j) :: Type -> Type

Methods

from :: Operation i j -> Rep (Operation i j) x

to :: Rep (Operation i j) x -> Operation i j

(NFData j, NFData i) => NFData (Operation i j)

Defined in Bio.Chain.Alignment.Type

Methods

rnf :: Operation i j -> ()

type Rep (Operation i j)

Defined in Bio.Chain.Alignment.Type

type Rep (Operation i j) = D1 ('MetaData "Operation" "Bio.Chain.Alignment.Type" "cobot-0.1.1.7-1gG22cBgMSxAc2IJYQchnS" 'False) (C1 ('MetaCons "INSERT" 'PrefixI 'True) (S1 ('MetaSel ('Just "getJ") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 j)) :+: (C1 ('MetaCons "DELETE" 'PrefixI 'True) (S1 ('MetaSel ('Just "getI") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 i)) :+: C1 ('MetaCons "MATCH" 'PrefixI 'True) (S1 ('MetaSel ('Just "getI") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 i) :*: S1 ('MetaSel ('Just "getJ") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 j))))

Viewing alignment results

viewAlignment :: forall m m'. (Alignable m, Alignable m', Symbol (IxValue m), Symbol (IxValue m')) => AlignmentResult m m' -> (String, String)

View alignment results as simple strings with gaps.

prettyAlignmment

Arguments

:: forall m m'. (Alignable m, Alignable m', Symbol (IxValue m), Symbol (IxValue m'))

=> AlignmentResult m m'

Result of alignment to format

-> Int

Desired width of one alignment row

-> String

Format alignment result as pretty columns of symbols.

Example with width equal to 20:

 0 --------------------  0

 0 TTTTTTTTTTTTTTTTTTTT 19

 0 --GCCTGAATGGTGTGGTGT 17
     || |||||| |||| |||
20 TTGC-TGAATG-TGTG-TGT 36

18 TCGGCGGAGGGACCCAGCTA 37
    || |||||||||||||||
37 -CG-CGGAGGGACCCAGCT- 53

38 AAAAAAAAAA 47

53 ---------- 53

Similarity functions

These are generic variants of similarity and difference functions alongside with their specialised variants. Generic versions take the alignment algorithm used for sequence alignment, an equality function on elements of both sequences to calculate hamming distance on aligned sequences, and the sequences themselves.

Sample usage of generic functions:

>>> similarityGen (GlobalAlignment (\x y -> if x == ord y then 1 else 0) (AffineGap (-11) (-1))) (\x y -> x == ord y) [ord 'R'.. ord 'z'] ['a'..'z']
0.63414633

This one will calculate similarity between a list of Ints and a list of Chars. Generic scoring function used in alignment is \x y -> if x == ord y then 1 else 0. Generic equality function used in hamming distance is \x y -> x == ord y.

Specialised versions do not take the equality function as the sequences are already constrained to have Eq elements.

Sample usage of specialised function is the same as before:

>>> :{
seq1 :: String
seq1 = "EVQLLESGGGLVQPGGSLRLSCAASGFTFSSYAMSWVRQAPGKGLEWVSAISGSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAKVQLERYFDYWGQGTLVTVSS"

seq2 :: String
seq2 = "EVQLLESGGGLVQPGGSLRLSAAASGFTFSTFSMNWVRQAPGKGLEWVSYISRTSKTIYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYVARGRFFDYWGQGTLVTVS"

similarity (GlobalAlignment blosum62 (AffineGap (-11) (-1))) s1 s2
:}
0.8130081

Sometimes for biological reasons gaps appearing in one of two sequences, that are being aligned, are not physical. For that reason we might want to use different gap penalties when aligning these sequences.

Example of usage of different gaps when aligning two sequences is presented below:

>>> :{
seq1 :: String
seq1 = "AAAAAAGGGGGGGGGGGGTTTTTTTTT"

seq2 :: String
seq2 = "AAAAAATTTTTTTTT"

gapForSeq1 :: AffineGap
gapForSeq1 = AffineGap (-5) (-1)

gapForSeq2 :: AffineGap
gapForSeq2 = AffineGap (-1000) (-1000) -- basically, we forbid gaps on @seq2@

local = LocalAlignment nuc44 (gapForSeq1, gapForSeq2)

viewAlignment (align local seq1 seq2)
:}
("TTTTTTTTT", "TTTTTTTTT")

similarityGen' :: forall m m'. (Alignable m, Alignable m') => AlignmentResult m m' -> (IxValue m -> IxValue m' -> Bool) -> R

Calculate similarity by precomputed AlignmentResult.

similarityGen :: forall algo m m'. (SequenceAlignment algo, Alignable m, Alignable m') => algo (IxValue m) (IxValue m') -> (IxValue m -> IxValue m' -> Bool) -> m -> m' -> R

Calculate similarity and difference between two sequences, aligning them first using given algorithm.

differenceGen' :: forall m m'. (Alignable m, Alignable m') => AlignmentResult m m' -> (IxValue m -> IxValue m' -> Bool) -> R

differenceGen :: forall algo m m'. (SequenceAlignment algo, Alignable m, Alignable m') => algo (IxValue m) (IxValue m') -> (IxValue m -> IxValue m' -> Bool) -> m -> m' -> R

similarity' :: forall m m'. (Alignable m, Alignable m', IxValue m ~ IxValue m', Eq (IxValue m), Eq (IxValue m')) => AlignmentResult m m' -> R

similarity :: forall algo m m'. (SequenceAlignment algo, Alignable m, Alignable m', IxValue m ~ IxValue m', Eq (IxValue m), Eq (IxValue m')) => algo (IxValue m) (IxValue m') -> m -> m' -> R

difference' :: forall m m'. (Alignable m, Alignable m', IxValue m ~ IxValue m', Eq (IxValue m), Eq (IxValue m')) => AlignmentResult m m' -> R

difference :: forall algo m m'. (SequenceAlignment algo, Alignable m, Alignable m', IxValue m ~ IxValue m', Eq (IxValue m), Eq (IxValue m')) => algo (IxValue m) (IxValue m') -> m -> m' -> R