diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -2,6 +2,11 @@ ## [Unreleased] +## [0.1.2.0] - 2019-12-5 +### Added +- wrike-426952824 : added Ecoli and CHO codon tables +- forbidden sequences as parameter + ## [0.1.1.0] - 2019-11-13 ### Added - Codon optimization tool diff --git a/cobot-tools.cabal b/cobot-tools.cabal --- a/cobot-tools.cabal +++ b/cobot-tools.cabal @@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack -- --- hash: 1d89fad89173ca2b6e911afc77c4c881a041f3b7fee7a1da594289e32d6d1b22 +-- hash: ea5b0488b2bf324cf7921fa277e07d923d6a1eee5bb0f9e6a940db2753897610 name: cobot-tools -version: 0.1.1.0 +version: 0.1.2.0 synopsis: Biological data file formats and IO description: Please see the README on GitHub at category: Bio @@ -30,7 +30,8 @@ library exposed-modules: Bio.Tools.Sequence.CodonOptimization.Algo - Bio.Tools.Sequence.CodonOptimization.Type + Bio.Tools.Sequence.CodonOptimization.Constants + Bio.Tools.Sequence.CodonOptimization.Types Bio.Tools.Sequence.Primers.Constants Bio.Tools.Sequence.Primers.Optimization Bio.Tools.Sequence.Primers.Properties @@ -91,6 +92,7 @@ , lens >=4.16 && <5.0 , mtl >=2.2.1 && <2.3.0 , neat-interpolation >=0.3 + , random , regex-tdfa , text default-language: Haskell2010 diff --git a/src/Bio/Tools/Sequence/CodonOptimization/Algo.hs b/src/Bio/Tools/Sequence/CodonOptimization/Algo.hs --- a/src/Bio/Tools/Sequence/CodonOptimization/Algo.hs +++ b/src/Bio/Tools/Sequence/CodonOptimization/Algo.hs @@ -2,29 +2,31 @@ ( optimizeAA , optimizeDNA , score + , scoreSequence , scoreCmp ) where -import Bio.NucleicAcid.Nucleotide (symbol) -import Bio.NucleicAcid.Nucleotide.Type (DNA (..)) -import Bio.Protein.AminoAcid.Type (AA (..)) -import Bio.Tools.Sequence.CodonOptimization.Type (CodonConfig (..), CodonScoreConfig (..), - ak2Codon, - ak2MaxFrequCodon, - codon2ak, - codonFrequencies, - forbiddenRegexp, - standardTemperature) -import Bio.Tools.Sequence.ViennaRNA.Fold (fold) -import Data.List (maximumBy, take, foldl') -import Data.Map as Map (lookup) -import Data.Maybe (fromMaybe) -import Text.Regex.TDFA +import Bio.NucleicAcid.Nucleotide (symbol) +import Bio.NucleicAcid.Nucleotide.Type (DNA (..)) +import Bio.Protein.AminoAcid.Type (AA (..)) +import Bio.Tools.Sequence.CodonOptimization.Constants (ak2Codon, ak2MaxFrequCodon, + codon2ak, + codonFrequencies, motiveScoreWindow, defaultMotiveScore, + forbiddenMotiveScore) +import Bio.Tools.Sequence.CodonOptimization.Types (CodonScoreConfig (..), + standardTemperature) +import Bio.Tools.Sequence.ViennaRNA.Fold (fold) +import Data.List (foldl', + maximumBy, + take) +import Data.Map as Map (lookup) +import Data.Maybe (fromMaybe) +import Text.Regex.TDFA ((=~)) -- | 'optimizeDNA' function does translation from [DNA] to [AA] and then calls 'optimizeAA' -optimizeDNA :: CodonConfig -- ^ Config data object. Contains main parameters of codon-optimization and all parameters for scoring function - -> [DNA] -- ^ Initial, not optimized nucleotide sequence - -> [DNA] -- ^ Result, optimized nucleotide sequence +optimizeDNA :: CodonScoreConfig -- ^ Config data object. Contains main parameters of codon-optimization and all parameters for scoring function + -> [DNA] -- ^ Initial, not optimized nucleotide sequence + -> [DNA] -- ^ Result, optimized nucleotide sequence optimizeDNA cfg dna = optimizeAA cfg (translate dna) where translate :: [DNA] -> [AA] @@ -37,14 +39,15 @@ -- | 'optimizeAA' function does codon-optimisation for incoming amino-acid sequence. -- Incoming amino-acid sequence transformed to nucleotide sequence and optimized used the codon-optimization algorithm. -- Algorithm described here doi: 10.1007/s11693-010-9062-3 -optimizeAA :: CodonConfig -- ^ Config data object. Contains main parameters of codon-optimization and all parameters for scoring function - -> [AA] -- ^ Initial, not optimized amino-acid sequence - -> [DNA] -- ^ Result, optimized nucleotide sequence -optimizeAA cfg@(CodonConfig initLen winLen _) aa = foldl' concatByScore initial variants +optimizeAA :: CodonScoreConfig -- ^ Config data object. Contains main parameters of codon-optimization and all parameters for scoring function + -> [AA] -- ^ Initial, not optimized amino-acid sequence + -> [DNA] -- ^ Result, optimized nucleotide sequence +optimizeAA cfg@(CodonScoreConfig organism initLen winLen _ _ _ _ _ _ _ _ _ _) aa = foldl' concatByScore initial variants where lenAA = length aa variants = generateVariants (drop initLen aa) winLen - initial = concatMap (\ak -> maybe "" fst (Map.lookup ak ak2MaxFrequCodon)) (take initLen aa) + fequCodonsMap = ak2MaxFrequCodon organism + initial = concatMap (\ak -> maybe "" fst (Map.lookup ak fequCodonsMap)) (take initLen aa) -- | 'concatByScore' function gets maximum by score variable string and then concat it to result string concatByScore :: [DNA] -- ^ initial string @@ -80,14 +83,23 @@ getCodons :: AA -> [[DNA]] getCodons ak = fromMaybe [] (Map.lookup ak ak2Codon) +-- | 'scoreSequence' function calculates the average score for full sequence +scoreSequence :: CodonScoreConfig -> [DNA] -> Double +scoreSequence cnf@(CodonScoreConfig _ initLen winLen _ _ _ _ _ _ _ _ _ _) nkSequ = sum res / realToFrac (length res) + where + res = scr ((initLen + winLen + 1) * 3) [] + + scr :: Int -> [Double] -> [Double] + scr partLen acc | partLen > length nkSequ = acc + | otherwise = scr (partLen + winLen * 3) (score cnf (take partLen nkSequ) : acc) + -- | 'score' function gets scoring for incoming string. -- Scoring function is a composite function of several scoring. More about scoring algorithm see here doi: 10.1007/s11693-010-9062-3 -score :: CodonConfig -- ^ Config data object. Contains main parameters of codon-optimization and all parameters for scoring function - -> [DNA] -- ^ nucleotide sequence to score - -> Double -- ^ result score value -score (CodonConfig _ winLen - (CodonScoreConfig codonUsageWeight gcWeight gcFactor gcWindow rnaFoldingWeight - rnaFoldingFactor rnaFoldingWindow forbiddenDNAWeight gcContentDesired)) nkSequ = +score :: CodonScoreConfig -- ^ Config data object. Contains main parameters of codon-optimization and all parameters for scoring function + -> [DNA] -- ^ nucleotide sequence to score + -> Double -- ^ result score value +score (CodonScoreConfig organism _ winLen codonUsageWeight gcWeight gcFactor gcWindow rnaFoldingWeight + rnaFoldingFactor rnaFoldingWindow forbiddenDNAWeight gcContentDesired forbiddenRegexp) nkSequ = scoreCU + scoreGC - scoreMT - realToFrac scoreRNAFold where sequLen = length nkSequ @@ -123,17 +135,17 @@ countWeightMb :: [DNA] -> Maybe Double countWeightMb str = do let codon = take 3 str - codonFreq <- Map.lookup codon codonFrequencies + codonFreq <- Map.lookup codon (codonFrequencies organism) ak <- Map.lookup codon codon2ak - (_, codonMaxFreq) <- Map.lookup ak ak2MaxFrequCodon + (_, codonMaxFreq) <- Map.lookup ak (ak2MaxFrequCodon organism) return $ codonFreq / codonMaxFreq -- | 'motiveScore' counts score for the occurrence of desired and unwanted DNA motifs. motiveScore :: [DNA] -> Double motiveScore sequ = - if any (drop (length sequ - 100) (map symbol sequ) =~) forbiddenRegexp - then 50 - else 0 + if any (drop (length sequ - motiveScoreWindow) (map symbol sequ) =~) forbiddenRegexp + then forbiddenMotiveScore + else defaultMotiveScore -- | 'scoreRnaf' counts energy of RNA folding @@ -143,11 +155,8 @@ result = fst $ fold standardTemperature (drop (length sequ - rnaFoldingWindow) sequ) -- | 'scoreCmp' is compare function for two strings using 'score' function -scoreCmp :: CodonConfig -> [DNA] -> [DNA] -> [DNA] -> Ordering -scoreCmp cfg optimized str1 str2 - | score1 > score2 = GT - | score1 == score2 = EQ - | otherwise = LT +scoreCmp :: CodonScoreConfig -> [DNA] -> [DNA] -> [DNA] -> Ordering +scoreCmp cfg optimized str1 str2 = compare score1 score2 where score1 = score cfg (optimized ++ str1) score2 = score cfg (optimized ++ str2) diff --git a/src/Bio/Tools/Sequence/CodonOptimization/Constants.hs b/src/Bio/Tools/Sequence/CodonOptimization/Constants.hs new file mode 100644 --- /dev/null +++ b/src/Bio/Tools/Sequence/CodonOptimization/Constants.hs @@ -0,0 +1,393 @@ +module Bio.Tools.Sequence.CodonOptimization.Constants + ( ak2Codon + , codon2ak + , codonFrequencies + , ak2MaxFrequCodon + , motiveScoreWindow + , forbiddenMotiveScore + , defaultMotiveScore + ) where + +import Bio.NucleicAcid.Nucleotide.Type (DNA (..)) +import Bio.Protein.AminoAcid.Type (AA (..)) +import Bio.Tools.Sequence.CodonOptimization.Types (Organism (..)) +import Data.Map as Map (Map, + fromList) + +motiveScoreWindow :: Int +motiveScoreWindow = 100 + +forbiddenMotiveScore :: Double +forbiddenMotiveScore = 50 + +defaultMotiveScore :: Double +defaultMotiveScore = 0 + +ak2Codon :: Map AA [[DNA]] +ak2Codon = + fromList + [ (PHE, [[DT, DT, DT], [DT, DT, DC]]) + , (TYR, [[DT, DA, DT], [DT, DA, DC]]) + , (CYS, [[DT, DG, DT], [DT, DG, DC]]) + , (TRP, [[DT, DG, DG]]) + , (LEU, [[DT, DT, DA], [DT, DT, DG], [DC, DT, DT], [DC, DT, DC], [DC, DT, DA], [DC, DT, DG]]) + , (PRO, [[DC, DC, DT], [DC, DC, DC], [DC, DC, DA], [DC, DC, DG]]) + , (HIS, [[DC, DA, DT], [DC, DA, DC]]) + , (GLN, [[DC, DA, DA], [DC, DA, DG]]) + , (ILE, [[DA, DT, DT], [DA, DT, DC], [DA, DT, DA]]) + , (MET, [[DA, DT, DG]]) + , (THR, [[DA, DC, DT], [DA, DC, DC], [DA, DC, DA], [DA, DC, DG]]) + , (ASN, [[DA, DA, DT], [DA, DA, DC]]) + , (LYS, [[DA, DA, DA], [DA, DA, DG]]) + , (SER, [[DT, DC, DT], [DT, DC, DC], [DT, DC, DA], [DT, DC, DG], [DA, DG, DT], [DA, DG, DC]]) + , (ARG, [[DC, DG, DT], [DC, DG, DC], [DC, DG, DA], [DC, DG, DG], [DA, DG, DA], [DA, DG, DG]]) + , (VAL, [[DG, DT, DT], [DG, DT, DC], [DG, DT, DA], [DG, DT, DG]]) + , (ALA, [[DG, DC, DT], [DG, DC, DC], [DG, DC, DA], [DG, DC, DG]]) + , (ASP, [[DG, DA, DT], [DG, DA, DC]]) + , (GLU, [[DG, DA, DA], [DG, DA, DG]]) + , (GLY, [[DG, DG, DT], [DG, DG, DC], [DG, DG, DA], [DG, DG, DG]]) + ] + + +codon2ak :: Map [DNA] AA +codon2ak = + fromList + [ ([DT, DT, DT], PHE) + , ([DT, DT, DC], PHE) + , ([DT, DT, DA], LEU) + , ([DT, DT, DG], LEU) + , ([DT, DC, DT], SER) + , ([DT, DC, DC], SER) + , ([DT, DC, DA], SER) + , ([DT, DC, DG], SER) + , ([DT, DA, DT], TYR) + , ([DT, DA, DC], TYR) + , ([DT, DG, DT], CYS) + , ([DT, DG, DC], CYS) + , ([DT, DG, DG], TRP) + , ([DC, DT, DT], LEU) + , ([DC, DT, DC], LEU) + , ([DC, DT, DA], LEU) + , ([DC, DT, DG], LEU) + , ([DC, DC, DT], PRO) + , ([DC, DC, DC], PRO) + , ([DC, DC, DA], PRO) + , ([DC, DC, DG], PRO) + , ([DC, DA, DT], HIS) + , ([DC, DA, DC], HIS) + , ([DC, DA, DA], GLN) + , ([DC, DA, DG], GLN) + , ([DC, DG, DT], ARG) + , ([DC, DG, DC], ARG) + , ([DC, DG, DA], ARG) + , ([DC, DG, DG], ARG) + , ([DA, DT, DT], ILE) + , ([DA, DT, DC], ILE) + , ([DA, DT, DA], ILE) + , ([DA, DT, DG], MET) + , ([DA, DC, DT], THR) + , ([DA, DC, DC], THR) + , ([DA, DC, DA], THR) + , ([DA, DC, DG], THR) + , ([DA, DA, DT], ASN) + , ([DA, DA, DC], ASN) + , ([DA, DA, DA], LYS) + , ([DA, DA, DG], LYS) + , ([DA, DG, DT], SER) + , ([DA, DG, DC], SER) + , ([DA, DG, DA], ARG) + , ([DA, DG, DG], ARG) + , ([DG, DT, DT], VAL) + , ([DG, DT, DC], VAL) + , ([DG, DT, DA], VAL) + , ([DG, DT, DG], VAL) + , ([DG, DC, DT], ALA) + , ([DG, DC, DC], ALA) + , ([DG, DC, DA], ALA) + , ([DG, DC, DG], ALA) + , ([DG, DA, DT], ASP) + , ([DG, DA, DC], ASP) + , ([DG, DA, DA], GLU) + , ([DG, DA, DG], GLU) + , ([DG, DG, DT], GLY) + , ([DG, DG, DC], GLY) + , ([DG, DG, DA], GLY) + , ([DG, DG, DG], GLY) + ] + +ak2MaxFrequCodon :: Organism -> Map AA ([DNA], Double) +-- taken from https://github.com/Edinburgh-Genome-Foundry/codon-usage-tables/blob/master/codon_usage_data/tables/h_sapiens_9606.csv +ak2MaxFrequCodon Human = + fromList + [ (ALA, ([DG, DC, DC], 0.4)) + , (CYS, ([DT, DG, DC], 0.54)) + , (ASP, ([DG, DA, DC], 0.54)) + , (GLU, ([DG, DA, DG], 0.58)) + , (PHE, ([DT, DT, DC], 0.54)) + , (GLY, ([DG, DG, DC], 0.34)) + , (HIS, ([DC, DA, DC], 0.58)) + , (ILE, ([DA, DT, DC], 0.47)) + , (LYS, ([DA, DA, DG], 0.57)) + , (LEU, ([DC, DT, DG], 0.4)) + , (MET, ([DA, DT, DG], 1.0)) + , (ASN, ([DA, DA, DC], 0.53)) + , (PRO, ([DC, DC, DC], 0.32)) + , (GLN, ([DC, DA, DG], 0.73)) + , (ARG, ([DA, DG, DG], 0.21)) + , (SER, ([DA, DG, DC], 0.24)) + , (THR, ([DA, DC, DC], 0.36)) + , (VAL, ([DG, DT, DG], 0.46)) + , (TRP, ([DT, DG, DG], 1.0)) + , (TYR, ([DT, DA, DC], 0.56)) + ] +-- taken from https://github.com/Edinburgh-Genome-Foundry/codon-usage-tables/blob/master/codon_usage_data/tables/e_coli_316407.csv +ak2MaxFrequCodon EColi = + fromList + [ (ALA, ([DG, DC, DG], 0.36)) + , (CYS, ([DT, DG, DC], 0.56)) + , (ASP, ([DG, DA, DT], 0.63)) + , (GLU, ([DG, DA, DA], 0.68)) + , (PHE, ([DT, DT, DT], 0.58)) + , (GLY, ([DG, DG, DC], 0.41)) + , (HIS, ([DC, DA, DT], 0.57)) + , (ILE, ([DA, DT, DT], 0.51)) + , (LYS, ([DA, DA, DA], 0.76)) + , (LEU, ([DC, DT, DG], 0.50)) + , (MET, ([DA, DT, DG], 1.0)) + , (ASN, ([DA, DA, DC], 0.55)) + , (PRO, ([DC, DC, DG], 0.53)) + , (GLN, ([DC, DA, DG], 0.65)) + , (ARG, ([DC, DG, DC], 0.4)) + , (SER, ([DA, DG, DC], 0.28)) + , (THR, ([DA, DC, DC], 0.44)) + , (VAL, ([DG, DT, DG], 0.37)) + , (TRP, ([DT, DG, DG], 1.0)) + , (TYR, ([DT, DA, DT], 0.57)) + ] +-- taken from https://www.genscript.com/tools/codon-frequency-table +ak2MaxFrequCodon CHO = + fromList + [ (ALA, ([DG, DC, DC], 0.26)) + , (CYS, ([DT, DG, DC], 0.54)) + , (ASP, ([DG, DA, DT], 0.63)) + , (GLU, ([DG, DA, DA], 0.68)) + , (PHE, ([DT, DT, DT], 0.58)) + , (GLY, ([DG, DG, DC], 0.37)) + , (HIS, ([DC, DA, DT], 0.57)) + , (ILE, ([DA, DT, DT], 0.49)) + , (LYS, ([DA, DA, DA], 0.74)) + , (LEU, ([DC, DT, DG], 0.47)) + , (MET, ([DA, DT, DG], 1.0)) + , (ASN, ([DA, DA, DC], 0.51)) + , (PRO, ([DC, DC, DG], 0.49)) + , (GLN, ([DC, DA, DG], 0.66)) + , (ARG, ([DC, DG, DC], 0.36)) + , (SER, ([DA, DG, DC], 0.25)) + , (THR, ([DA, DC, DC], 0.4)) + , (VAL, ([DG, DT, DG], 0.35)) + , (TRP, ([DT, DG, DG], 1.0)) + , (TYR, ([DT, DA, DT], 0.59)) + ] + +codonFrequencies :: Organism -> Map [DNA] Double +-- taken from https://github.com/Edinburgh-Genome-Foundry/codon-usage-tables/blob/master/codon_usage_data/tables/h_sapiens_9606.csv +codonFrequencies Human = + fromList + [ ([DT, DA, DA], 0.30) + , ([DT, DA, DG], 0.24) + , ([DT, DG, DA], 0.47) + , ([DG, DC, DA], 0.23) + , ([DG, DC, DC], 0.40) + , ([DG, DC, DG], 0.11) + , ([DG, DC, DT], 0.27) + , ([DT, DG, DC], 0.54) + , ([DT, DG, DT], 0.46) + , ([DG, DA, DC], 0.54) + , ([DG, DA, DT], 0.46) + , ([DG, DA, DA], 0.42) + , ([DG, DA, DG], 0.58) + , ([DT, DT, DC], 0.54) + , ([DT, DT, DT], 0.46) + , ([DG, DG, DA], 0.25) + , ([DG, DG, DC], 0.34) + , ([DG, DG, DG], 0.25) + , ([DG, DG, DT], 0.16) + , ([DC, DA, DC], 0.58) + , ([DC, DA, DT], 0.42) + , ([DA, DT, DA], 0.17) + , ([DA, DT, DC], 0.47) + , ([DA, DT, DT], 0.36) + , ([DA, DA, DA], 0.43) + , ([DA, DA, DG], 0.57) + , ([DC, DT, DA], 0.07) + , ([DC, DT, DC], 0.20) + , ([DC, DT, DG], 0.40) + , ([DC, DT, DT], 0.13) + , ([DT, DT, DA], 0.08) + , ([DT, DT, DG], 0.13) + , ([DA, DT, DG], 1.00) + , ([DA, DA, DC], 0.53) + , ([DA, DA, DT], 0.47) + , ([DC, DC, DA], 0.28) + , ([DC, DC, DC], 0.32) + , ([DC, DC, DG], 0.11) + , ([DC, DC, DT], 0.29) + , ([DC, DA, DA], 0.27) + , ([DC, DA, DG], 0.73) + , ([DA, DG, DA], 0.21) + , ([DA, DG, DG], 0.21) + , ([DC, DG, DA], 0.11) + , ([DC, DG, DC], 0.18) + , ([DC, DG, DG], 0.20) + , ([DC, DG, DT], 0.08) + , ([DA, DG, DC], 0.24) + , ([DA, DG, DT], 0.15) + , ([DT, DC, DA], 0.15) + , ([DT, DC, DC], 0.22) + , ([DT, DC, DG], 0.05) + , ([DT, DC, DT], 0.19) + , ([DA, DC, DA], 0.28) + , ([DA, DC, DC], 0.36) + , ([DA, DC, DG], 0.11) + , ([DA, DC, DT], 0.25) + , ([DG, DT, DA], 0.12) + , ([DG, DT, DC], 0.24) + , ([DG, DT, DG], 0.46) + , ([DG, DT, DT], 0.18) + , ([DT, DG, DG], 1.00) + , ([DT, DA, DC], 0.56) + , ([DT, DA, DT], 0.44) + ] +-- taken from https://github.com/Edinburgh-Genome-Foundry/codon-usage-tables/blob/master/codon_usage_data/tables/e_coli_316407.csv +codonFrequencies EColi = + fromList + [ ([DG, DC, DA], 0.21) + , ([DG, DC, DC], 0.27) + , ([DG, DC, DG], 0.36) + , ([DG, DC, DT], 0.16) + , ([DT, DG, DC], 0.56) + , ([DT, DG, DT], 0.44) + , ([DG, DA, DC], 0.37) + , ([DG, DA, DT], 0.63) + , ([DG, DA, DA], 0.69) + , ([DG, DA, DG], 0.31) + , ([DT, DT, DC], 0.43) + , ([DT, DT, DT], 0.57) + , ([DG, DG, DA], 0.11) + , ([DG, DG, DC], 0.41) + , ([DG, DG, DG], 0.15) + , ([DG, DG, DT], 0.34) + , ([DC, DA, DC], 0.43) + , ([DC, DA, DT], 0.57) + , ([DA, DT, DA], 0.07) + , ([DA, DT, DC], 0.42) + , ([DA, DT, DT], 0.51) + , ([DA, DA, DA], 0.76) + , ([DA, DA, DG], 0.24) + , ([DC, DT, DA], 0.04) + , ([DC, DT, DC], 0.10) + , ([DC, DT, DG], 0.50) + , ([DC, DT, DT], 0.10) + , ([DT, DT, DA], 0.13) + , ([DT, DT, DG], 0.13) + , ([DA, DT, DG], 1.00) + , ([DA, DA, DC], 0.55) + , ([DA, DA, DT], 0.45) + , ([DC, DC, DA], 0.19) + , ([DC, DC, DC], 0.12) + , ([DC, DC, DG], 0.53) + , ([DC, DC, DT], 0.16) + , ([DC, DA, DA], 0.35) + , ([DC, DA, DG], 0.65) + , ([DA, DG, DA], 0.04) + , ([DA, DG, DG], 0.02) + , ([DC, DG, DA], 0.06) + , ([DC, DG, DC], 0.40) + , ([DC, DG, DG], 0.10) + , ([DC, DG, DT], 0.38) + , ([DA, DG, DC], 0.28) + , ([DA, DG, DT], 0.15) + , ([DT, DC, DA], 0.12) + , ([DT, DC, DC], 0.15) + , ([DT, DC, DG], 0.15) + , ([DT, DC, DT], 0.15) + , ([DA, DC, DA], 0.13) + , ([DA, DC, DC], 0.44) + , ([DA, DC, DG], 0.27) + , ([DA, DC, DT], 0.16) + , ([DG, DT, DA], 0.15) + , ([DG, DT, DC], 0.22) + , ([DG, DT, DG], 0.37) + , ([DG, DT, DT], 0.26) + , ([DT, DG, DG], 1.00) + , ([DT, DA, DC], 0.43) + , ([DT, DA, DT], 0.57) + ] +-- taken from https://www.genscript.com/tools/codon-frequency-table +codonFrequencies CHO = + fromList + [ ([DT, DT, DT], 0.47) + , ([DT, DT, DC], 0.53) + , ([DT, DT, DA], 0.07) + , ([DT, DT, DG], 0.14) + , ([DT, DC, DT], 0.22) + , ([DT, DC, DC], 0.22) + , ([DT, DC, DA], 0.14) + , ([DT, DC, DG], 0.05) + , ([DT, DA, DT], 0.44) + , ([DT, DA, DC], 0.56) + , ([DT, DA, DA], 0.26) + , ([DT, DA, DG], 0.22) + , ([DT, DG, DT], 0.47) + , ([DT, DG, DC], 0.53) + , ([DT, DG, DA], 0.53) + , ([DT, DG, DG], 1.00) + , ([DC, DT, DT], 0.13) + , ([DC, DT, DC], 0.19) + , ([DC, DT, DA], 0.08) + , ([DC, DT, DG], 0.39) + , ([DC, DC, DT], 0.31) + , ([DC, DC, DC], 0.32) + , ([DC, DC, DA], 0.29) + , ([DC, DC, DG], 0.08) + , ([DC, DA, DT], 0.44) + , ([DC, DA, DC], 0.56) + , ([DC, DA, DA], 0.24) + , ([DC, DA, DG], 0.76) + , ([DC, DG, DT], 0.11) + , ([DC, DG, DC], 0.18) + , ([DC, DG, DA], 0.14) + , ([DC, DG, DG], 0.19) + , ([DA, DT, DT], 0.35) + , ([DA, DT, DC], 0.51) + , ([DA, DT, DA], 0.14) + , ([DA, DT, DG], 1.00) + , ([DA, DC, DT], 0.26) + , ([DA, DC, DC], 0.37) + , ([DA, DC, DA], 0.29) + , ([DA, DC, DG], 0.08) + , ([DA, DA, DT], 0.45) + , ([DA, DA, DC], 0.55) + , ([DA, DA, DA], 0.39) + , ([DA, DA, DG], 0.61) + , ([DA, DG, DT], 0.15) + , ([DA, DG, DC], 0.22) + , ([DA, DG, DA], 0.19) + , ([DA, DG, DG], 0.19) + , ([DG, DT, DT], 0.18) + , ([DG, DT, DC], 0.24) + , ([DG, DT, DA], 0.12) + , ([DG, DT, DG], 0.46) + , ([DG, DC, DT], 0.32) + , ([DG, DC, DC], 0.37) + , ([DG, DC, DA], 0.23) + , ([DG, DC, DG], 0.07) + , ([DG, DA, DT], 0.47) + , ([DG, DA, DC], 0.53) + , ([DG, DA, DA], 0.41) + , ([DG, DA, DG], 0.59) + , ([DG, DG, DT], 0.20) + , ([DG, DG, DC], 0.34) + , ([DG, DG, DA], 0.25) + , ([DG, DG, DG], 0.21) + ] diff --git a/src/Bio/Tools/Sequence/CodonOptimization/Type.hs b/src/Bio/Tools/Sequence/CodonOptimization/Type.hs deleted file mode 100644 --- a/src/Bio/Tools/Sequence/CodonOptimization/Type.hs +++ /dev/null @@ -1,251 +0,0 @@ -module Bio.Tools.Sequence.CodonOptimization.Type - ( CodonConfig(..) - , CodonScoreConfig(..) - , ak2Codon - , codon2ak - , forbiddenRegexp - , codonFrequencies - , ak2MaxFrequCodon - , standardTemperature - ) where - -import Bio.NucleicAcid.Nucleotide.Type (DNA (..)) -import Bio.Protein.AminoAcid.Type (AA (..)) -import qualified Data.ByteString.Lazy as BSL (ByteString) -import Data.Default (Default (..), def) -import Data.Map as Map (Map, fromList) - -standardTemperature :: Double -standardTemperature = 37 - --- | all parameters for codon optimization -data CodonConfig = - CodonConfig - { initLen :: Int -- ^ number of first ak from initial sequence, which will optimised without scoring function - , windowLen :: Int -- ^ length of variation window - , scoreConf :: CodonScoreConfig -- ^ parameters for scoring function - } deriving (Show) - --- | all parameters for scoring function of codon optimization -data CodonScoreConfig = - CodonScoreConfig - { codonUsageWeight :: Double -- ^ Codon usage weight - , gcWeight :: Double -- ^ GC-content weight - , gcFactor :: Double -- ^ GC_score in the power of F_gc is used - , gcWindow :: Int -- ^ length of the window for GC-score calculation (bp) - , rnaFoldingWeight :: Float -- ^ Weight of the RNA folding score - , rnaFoldingFactor :: Float -- ^ RNA folding score in the power of F_rnaf is used - , rnaFoldingWindow :: Int -- ^ length of the window for RNA folding score calculation (bp) - , forbiddenDNAWeight :: Double -- ^ forbidden DNA motifs score weight - , gcContentDesired :: Int -- ^ desired gc content in percents - } deriving (Show) - -instance Default CodonScoreConfig where - def = CodonScoreConfig 1 0.5 1.4 40 0.001 2.6 100 1 43 - -instance Default CodonConfig where - def = CodonConfig 3 1 def - -forbiddenRegexp :: [BSL.ByteString] -forbiddenRegexp = - [ "ATTTA" - , "ATACTCCCCC" - , "CGATCG" - , "GGGGACTTTGCACTGGAACTTACAACACCCCAGCAAGGACGCG" - , "CCGGCGGGT" - , "TTTATAATTTCTTCTTCCAGAA" - , "CCGTGCTGGCGTCTG" - , "AATAAA.{10,30}CA{30,}(TCTG|TG.CT)" - , "(GGG|CCA)CGCCTATAAA(((C|T)(C|T)A.(T|A)(C|T)(C|T))|(TCA(G|T)T(T|C)))(A|G)G(A|T)(C|T)(G|A|C)" - , "CAGG" - , "(A|C)AGGT(A|G)AGT" - , "AATAAA" - , "GCC(A|G)CCATGG" - ] - -ak2Codon :: Map AA [[DNA]] -ak2Codon = - fromList - [ (PHE, [[DT, DT, DT], [DT, DT, DC]]) - , (TYR, [[DT, DA, DT], [DT, DA, DC]]) - , (CYS, [[DT, DG, DT], [DT, DG, DC]]) - , (TRP, [[DT, DG, DG]]) - , (LEU, [[DT, DT, DA], [DT, DT, DG], [DC, DT, DT], [DC, DT, DC], [DC, DT, DA], [DC, DT, DG]]) - , (PRO, [[DC, DC, DT], [DC, DC, DC], [DC, DC, DA], [DC, DC, DG]]) - , (HIS, [[DC, DA, DT], [DC, DA, DC]]) - , (GLN, [[DC, DA, DA], [DC, DA, DG]]) - , (ILE, [[DA, DT, DT], [DA, DT, DC], [DA, DT, DA]]) - , (MET, [[DA, DT, DG]]) - , (THR, [[DA, DC, DT], [DA, DC, DC], [DA, DC, DA], [DA, DC, DG]]) - , (ASN, [[DA, DA, DT], [DA, DA, DC]]) - , (LYS, [[DA, DA, DA], [DA, DA, DG]]) - , (SER, [[DT, DC, DT], [DT, DC, DC], [DT, DC, DA], [DT, DC, DG], [DA, DG, DT], [DA, DG, DC]]) - , (ARG, [[DC, DG, DT], [DC, DG, DC], [DC, DG, DA], [DC, DG, DG], [DA, DG, DA], [DA, DG, DG]]) - , (VAL, [[DG, DT, DT], [DG, DT, DC], [DG, DT, DA], [DG, DT, DG]]) - , (ALA, [[DG, DC, DT], [DG, DC, DC], [DG, DC, DA], [DG, DC, DG]]) - , (ASP, [[DG, DA, DT], [DG, DA, DC]]) - , (GLU, [[DG, DA, DA], [DG, DA, DG]]) - , (GLY, [[DG, DG, DT], [DG, DG, DC], [DG, DG, DA], [DG, DG, DG]]) - ] - - -ak2MaxFrequCodon :: Map AA ([DNA], Double) -ak2MaxFrequCodon = - fromList - [ (ALA, ([DG, DC, DC], 0.4)) - , (CYS, ([DT, DG, DC], 0.54)) - , (ASP, ([DG, DA, DC], 0.54)) - , (GLU, ([DG, DA, DG], 0.58)) - , (PHE, ([DT, DT, DC], 0.54)) - , (GLY, ([DG, DG, DC], 0.34)) - , (HIS, ([DC, DA, DC], 0.58)) - , (ILE, ([DA, DT, DC], 0.47)) - , (LYS, ([DA, DA, DG], 0.57)) - , (LEU, ([DC, DT, DG], 0.4)) - , (MET, ([DA, DT, DG], 1.0)) - , (ASN, ([DA, DA, DC], 0.53)) - , (PRO, ([DC, DC, DC], 0.32)) - , (GLN, ([DC, DA, DG], 0.73)) - , (ARG, ([DA, DG, DG], 0.21)) - , (SER, ([DA, DG, DC], 0.24)) - , (THR, ([DA, DC, DC], 0.36)) - , (VAL, ([DG, DT, DG], 0.46)) - , (TRP, ([DT, DG, DG], 1.0)) - , (TYR, ([DT, DA, DC], 0.56)) - ] - -codon2ak :: Map [DNA] AA -codon2ak = - fromList - [ ([DT, DT, DT], PHE) - , ([DT, DT, DC], PHE) - , ([DT, DT, DA], LEU) - , ([DT, DT, DG], LEU) - , ([DT, DC, DT], SER) - , ([DT, DC, DC], SER) - , ([DT, DC, DA], SER) - , ([DT, DC, DG], SER) - , ([DT, DA, DT], TYR) - , ([DT, DA, DC], TYR) - , ([DT, DG, DT], CYS) - , ([DT, DG, DC], CYS) - , ([DT, DG, DG], TRP) - , ([DC, DT, DT], LEU) - , ([DC, DT, DC], LEU) - , ([DC, DT, DA], LEU) - , ([DC, DT, DG], LEU) - , ([DC, DC, DT], PRO) - , ([DC, DC, DC], PRO) - , ([DC, DC, DA], PRO) - , ([DC, DC, DG], PRO) - , ([DC, DA, DT], HIS) - , ([DC, DA, DC], HIS) - , ([DC, DA, DA], GLN) - , ([DC, DA, DG], GLN) - , ([DC, DG, DT], ARG) - , ([DC, DG, DC], ARG) - , ([DC, DG, DA], ARG) - , ([DC, DG, DG], ARG) - , ([DA, DT, DT], ILE) - , ([DA, DT, DC], ILE) - , ([DA, DT, DA], ILE) - , ([DA, DT, DG], MET) - , ([DA, DC, DT], THR) - , ([DA, DC, DC], THR) - , ([DA, DC, DA], THR) - , ([DA, DC, DG], THR) - , ([DA, DA, DT], ASN) - , ([DA, DA, DC], ASN) - , ([DA, DA, DA], LYS) - , ([DA, DA, DG], LYS) - , ([DA, DG, DT], SER) - , ([DA, DG, DC], SER) - , ([DA, DG, DA], ARG) - , ([DA, DG, DG], ARG) - , ([DG, DT, DT], VAL) - , ([DG, DT, DC], VAL) - , ([DG, DT, DA], VAL) - , ([DG, DT, DG], VAL) - , ([DG, DC, DT], ALA) - , ([DG, DC, DC], ALA) - , ([DG, DC, DA], ALA) - , ([DG, DC, DG], ALA) - , ([DG, DA, DT], ASP) - , ([DG, DA, DC], ASP) - , ([DG, DA, DA], GLU) - , ([DG, DA, DG], GLU) - , ([DG, DG, DT], GLY) - , ([DG, DG, DC], GLY) - , ([DG, DG, DA], GLY) - , ([DG, DG, DG], GLY) - ] - --- | taken from https://github.com/Edinburgh-Genome-Foundry/codon-usage-tables/blob/master/codon_usage_data/tables/h_sapiens_9606.csv -codonFrequencies :: Map [DNA] Double -codonFrequencies = - fromList - [ ([DT, DA, DA], 0.30) - , ([DT, DA, DG], 0.24) - , ([DT, DG, DA], 0.47) - , ([DG, DC, DA], 0.23) - , ([DG, DC, DC], 0.40) - , ([DG, DC, DG], 0.11) - , ([DG, DC, DT], 0.27) - , ([DT, DG, DC], 0.54) - , ([DT, DG, DT], 0.46) - , ([DG, DA, DC], 0.54) - , ([DG, DA, DT], 0.46) - , ([DG, DA, DA], 0.42) - , ([DG, DA, DG], 0.58) - , ([DT, DT, DC], 0.54) - , ([DT, DT, DT], 0.46) - , ([DG, DG, DA], 0.25) - , ([DG, DG, DC], 0.34) - , ([DG, DG, DG], 0.25) - , ([DG, DG, DT], 0.16) - , ([DC, DA, DC], 0.58) - , ([DC, DA, DT], 0.42) - , ([DA, DT, DA], 0.17) - , ([DA, DT, DC], 0.47) - , ([DA, DT, DT], 0.36) - , ([DA, DA, DA], 0.43) - , ([DA, DA, DG], 0.57) - , ([DC, DT, DA], 0.07) - , ([DC, DT, DC], 0.20) - , ([DC, DT, DG], 0.40) - , ([DC, DT, DT], 0.13) - , ([DT, DT, DA], 0.08) - , ([DT, DT, DG], 0.13) - , ([DA, DT, DG], 1.00) - , ([DA, DA, DC], 0.53) - , ([DA, DA, DT], 0.47) - , ([DC, DC, DA], 0.28) - , ([DC, DC, DC], 0.32) - , ([DC, DC, DG], 0.11) - , ([DC, DC, DT], 0.29) - , ([DC, DA, DA], 0.27) - , ([DC, DA, DG], 0.73) - , ([DA, DG, DA], 0.21) - , ([DA, DG, DG], 0.21) - , ([DC, DG, DA], 0.11) - , ([DC, DG, DC], 0.18) - , ([DC, DG, DG], 0.20) - , ([DC, DG, DT], 0.08) - , ([DA, DG, DC], 0.24) - , ([DA, DG, DT], 0.15) - , ([DT, DC, DA], 0.15) - , ([DT, DC, DC], 0.22) - , ([DT, DC, DG], 0.05) - , ([DT, DC, DT], 0.19) - , ([DA, DC, DA], 0.28) - , ([DA, DC, DC], 0.36) - , ([DA, DC, DG], 0.11) - , ([DA, DC, DT], 0.25) - , ([DG, DT, DA], 0.12) - , ([DG, DT, DC], 0.24) - , ([DG, DT, DG], 0.46) - , ([DG, DT, DT], 0.18) - , ([DT, DG, DG], 1.00) - , ([DT, DA, DC], 0.56) - , ([DT, DA, DT], 0.44) - ] diff --git a/src/Bio/Tools/Sequence/CodonOptimization/Types.hs b/src/Bio/Tools/Sequence/CodonOptimization/Types.hs new file mode 100644 --- /dev/null +++ b/src/Bio/Tools/Sequence/CodonOptimization/Types.hs @@ -0,0 +1,55 @@ +module Bio.Tools.Sequence.CodonOptimization.Types + ( CodonScoreConfig(..) + , Organism(..) + , standardTemperature + , defaultForbiddenRegexp + ) where + +import qualified Data.ByteString.Lazy as BSL (ByteString) +import Data.Default (Default (..)) +import GHC.Generics (Generic) + +standardTemperature :: Double +standardTemperature = 37 + +data Organism = CHO | EColi | Human + deriving (Eq, Show, Generic) + +-- | all parameters for codon optimization +data CodonScoreConfig = + CodonScoreConfig + { organism :: Organism + , initLen :: Int -- ^ number of first ak from initial sequence, which will optimised without scoring function + , windowLen :: Int -- ^ length of variation window + , codonUsageWeight :: Double -- ^ Codon usage weight + , gcWeight :: Double -- ^ GC-content weight + , gcFactor :: Double -- ^ GC_score in the power of F_gc is used + , gcWindow :: Int -- ^ length of the window for GC-score calculation (bp) + , rnaFoldingWeight :: Float -- ^ Weight of the RNA folding score + , rnaFoldingFactor :: Float -- ^ RNA folding score in the power of F_rnaf is used + , rnaFoldingWindow :: Int -- ^ length of the window for RNA folding score calculation (bp) + , forbiddenDNAWeight :: Double -- ^ forbidden DNA motifs score weight + , gcContentDesired :: Int -- ^ desired gc content in percents + , forbiddenSequence :: [BSL.ByteString] -- ^ list of forbidden patterns + } + deriving (Eq, Show, Generic) + +instance Default CodonScoreConfig where + def = CodonScoreConfig CHO 3 1 1 0.5 1.4 40 0.001 2.6 100 1 43 defaultForbiddenRegexp + +defaultForbiddenRegexp :: [BSL.ByteString] +defaultForbiddenRegexp = + [ "ATTTA" + , "ATACTCCCCC" + , "CGATCG" -- PvuI + , "GGGGACTTTGCACTGGAACTTACAACACCCCAGCAAGGACGCG" + , "CCGGCGGGT" + , "TTTATAATTTCTTCTTCCAGAA" + , "CCGTGCTGGCGTCTG" + , "AATAAA.{10,30}CA{30,}(TCTG|TG.CT)" + , "(GGG|CCA)CGCCTATAAA(((C|T)(C|T)A.(T|A)(C|T)(C|T))|(TCA(G|T)T(T|C)))(A|G)G(A|T)(C|T)(G|A|C)" + , "CAGG" + , "(A|C)AGGT(A|G)AGT" + , "AATAAA" + , "GCC(A|G)CCATGG" + ] diff --git a/test/SpecCodonOptimization.hs b/test/SpecCodonOptimization.hs --- a/test/SpecCodonOptimization.hs +++ b/test/SpecCodonOptimization.hs @@ -2,26 +2,74 @@ module SpecCodonOptimization where -import Bio.Protein.AminoAcid () -import Bio.Tools.Sequence.CodonOptimization.Algo (optimizeAA, optimizeDNA, score, - scoreCmp) -import Bio.Tools.Sequence.CodonOptimization.Type (CodonConfig (..), CodonScoreConfig (..)) -import Data.Default (def) -import Data.List (maximumBy, - minimumBy) -import Test.Hspec (Spec, describe, it, - shouldBe) +import Bio.NucleicAcid.Nucleotide.Type (DNA) +import Bio.Protein.AminoAcid () +import Bio.Protein.AminoAcid.Type (AA) +import Bio.Tools.Sequence.CodonOptimization.Algo (optimizeAA, + optimizeDNA, + score, + scoreCmp, + scoreSequence) +import Bio.Tools.Sequence.CodonOptimization.Constants (ak2Codon) +import Bio.Tools.Sequence.CodonOptimization.Types (CodonScoreConfig(..), + Organism (..), + defaultForbiddenRegexp) +import Data.List (foldl', + maximumBy, + minimumBy) +import Data.Map as Map (lookup) +import Data.Maybe (fromMaybe) +import System.Random +import Test.Hspec (Expectation, + Spec, describe, + it, shouldBe, + shouldSatisfy) -scoreCfg :: CodonScoreConfig -scoreCfg = def +confHuman :: CodonScoreConfig +confHuman = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.001 2.6 100 1 60 defaultForbiddenRegexp -conf :: CodonConfig -conf = def +confEColi :: CodonScoreConfig +confEColi = CodonScoreConfig EColi 3 1 1 0.5 1.4 40 0.001 2.6 100 1 50 defaultForbiddenRegexp +confCHO :: CodonScoreConfig +confCHO = CodonScoreConfig CHO 3 1 1 0.5 1.4 40 0.001 2.6 100 1 43 defaultForbiddenRegexp + +scoreHuman :: [DNA] -> Double +scoreHuman = scoreSequence confHuman + +scoreCHO :: [DNA] -> Double +scoreCHO = scoreSequence confCHO + +scoreEColi :: [DNA] -> Double +scoreEColi = scoreSequence confEColi + +assertScoreBecomeBetter :: CodonScoreConfig -> [DNA] -> [DNA] -> Expectation +assertScoreBecomeBetter conf res initial = scoreSequence conf initial `shouldSatisfy` (< scoreSequence conf res) + +assertScoreByHumanBetterThan :: [DNA] -> [DNA] -> Expectation +assertScoreByHumanBetterThan res initial = scoreHuman initial `shouldSatisfy` (< scoreHuman res) + +assertScoreByCHOBetterThan :: [DNA] -> [DNA] -> Expectation +assertScoreByCHOBetterThan res initial = scoreCHO initial `shouldSatisfy` (< scoreCHO res) + +assertScoreByEColiBetterThan :: [DNA] -> [DNA] -> Expectation +assertScoreByEColiBetterThan res initial = scoreEColi initial `shouldSatisfy` (< scoreEColi res) + +toRandomNKSequ :: [AA] -> IO [DNA] +toRandomNKSequ initial = foldl' (++) [] <$> mapM toRandomCodon initial + +toRandomCodon :: AA -> IO [DNA] +toRandomCodon ak = do + let codons = fromMaybe [] (Map.lookup ak ak2Codon) + i <- randomRIO (0, length codons - 1) + return $ codons !! i + codonOptimizationSpec :: Spec codonOptimizationSpec = describe "Codon optimization spec" $ do optimizeSequence + optimizeSequenceForEColi + optimizeSequenceForCHO optimizeDNASequence optimizeShortSequence optimizeExtremelyShortSequence @@ -29,6 +77,7 @@ optimizeSequenceInit5 scoreComparing scoreFun + scoreFunEColi scoreFunDifferentCodonUsageWeight scoreFunDifferentGCWeight scoreFunDifferentGCFactor @@ -46,7 +95,7 @@ it "should correct compare by score" $ do let optimized = "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGC" let vars = ["AGTACTGGT","AGCACTGGT","TCGACAGGT","AGTACAGGT","AGCACAGGT","TCTACTGGC","TCCACTGGC","TCAACTGGC","TCGACTGGC","AGCACCGGC"] - let cfg = CodonConfig 3 3 (CodonScoreConfig 1 0.5 1.4 40 0.001 2.6 100 1 43) + let cfg = CodonScoreConfig Human 3 3 1 0.5 1.4 40 0.001 2.6 100 1 43 defaultForbiddenRegexp let resMin = maximumBy (scoreCmp cfg optimized) vars let resMax = minimumBy (scoreCmp cfg optimized) vars resMax `shouldBe` "TCGACAGGT" @@ -56,61 +105,114 @@ optimizeSequence = describe "optimizeSequence" $ it "should correct optimize sequence" $ do - let res = optimizeAA conf "ASTKGPSVFPLAPSSKSTSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTQTYICNVNHKPSNTKVDKKV" - res `shouldBe` "GCCAGCACCAAGGGCCCCAGCGTGTTTCCTCTGGCCCCTAGCAGCAAGAGCACCAGCGGCGGCACCGCCGCCCTGGGCTGCCTGGTGAAGGACTACTTCCCTGAGCCTGTGACCGTGAGCTGGAACAGCGGCGCCCTGACCAGCGGCGTGCACACCTTCCCTGCCGTGCTGCAGAGCAGCGGCCTGTACAGCCTGAGCAGCGTGGTGACCGTGCCTAGCAGCAGCCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCTAGCAACACCAAGGTGGACAAGAAGGTG" + let ak = "ASTKGPSVFPLAPSSKSTSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTQTYICNVNHKPSNTKVDKKV" + nk <- toRandomNKSequ ak + let res = optimizeAA confHuman ak + res `shouldBe` "GCCAGCACCAAGGGCCCCAGCGTGTTCCCTCTGGCCCCCAGCAGCAAGAGCACCAGCGGCGGCACCGCCGCCCTGGGCTGCCTGGTGAAGGACTACTTCCCCGAGCCCGTGACCGTGAGCTGGAACAGCGGCGCCCTGACCAGCGGCGTGCACACCTTCCCTGCCGTGCTGCAGAGCAGCGGCCTGTACAGCCTGAGCAGCGTGGTGACCGTGCCTAGCAGCAGCCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCCAGCAACACCAAGGTGGACAAGAAGGTG" + res `assertScoreByHumanBetterThan` nk +optimizeSequenceForCHO :: Spec +optimizeSequenceForCHO = + describe "optimizeSequenceForCHO" $ + it "should correct optimize sequence for CHO" $ do + let ak = "ASTKGPSVFPLAPSSKSTSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTQTYICNVNHKPSNTKVDKKV" + nk <- toRandomNKSequ ak + let res = optimizeAA confCHO ak + + res `shouldBe` "GCCAGCACCAAGGGCCCCAGCGTGTTTCCTCTGGCCCCTTCTTCTAAGTCTACCTCTGGCGGCACCGCCGCCCTGGGCTGTCTGGTGAAGGATTACTTTCCTGAGCCTGTGACCGTGTCTTGGAACTCTGGCGCCCTGACCTCTGGCGTGCACACCTTTCCTGCCGTGCTGCAGTCTTCTGGCCTGTACTCTCTGTCTTCTGTGGTGACCGTGCCTTCTTCTTCTCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCTTCTAACACCAAGGTGGACAAGAAGGTG" + res `assertScoreByCHOBetterThan` nk + +optimizeSequenceForEColi :: Spec +optimizeSequenceForEColi = + describe "optimizeSequenceForEColi" $ + it "should correct optimize sequence for Ecoli" $ do + let ak = "ASTKGPSVFPLAPSSKSTSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTQTYICNVNHKPSNTKVDKKV" + nk <- toRandomNKSequ ak + let res = optimizeAA confEColi ak + + res `shouldBe` "GCGAGCACCAAAGGCCCGAGCGTGTTTCCGCTGGCGCCGAGCAGCAAAAGCACCAGCGGCGGCACCGCGGCGCTGGGCTGCCTGGTGAAAGATTATTTTCCGGAACCGGTGACCGTGAGCTGGAACAGCGGCGCGCTGACCAGCGGCGTGCATACCTTTCCGGCGGTGCTGCAGAGCAGCGGCCTGTATAGCCTGAGCAGCGTGGTGACCGTGCCGAGCAGCAGCCTGGGCACCCAGACCTATATTTGCAACGTGAACCATAAACCGAGCAACACCAAAGTGGATAAAAAAGTG" + res `assertScoreByEColiBetterThan` nk + optimizeDNASequence :: Spec optimizeDNASequence = describe "optimizeDNASequence" $ it "should correct optimize amino-acid sequence" $ do - let res = optimizeDNA conf "GCTAGTACCAAGGGCCCCAGCGTGTTTCCTCTGGCCCCTAGCAGCAAGAGCACCAGCGGCGGCACCGCCGCCCTGGGCTGCCTGGTGAAGGACTACTTCCCTGAGCCTGTGACCGTGAGCTGGAACAGCGGCGCCCTGACCAGCGGCGTGCACACCTTCCCTGCCGTGCTGCAGAGCAGCGGCCTGTACAGCCTGAGCAGCGTGGTGACCGTGCCTAGCAGCAGCCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCTAGCAACACCAAGGTGGACAAGAAGGTG" - res `shouldBe` "GCCAGCACCAAGGGCCCCAGCGTGTTTCCTCTGGCCCCTAGCAGCAAGAGCACCAGCGGCGGCACCGCCGCCCTGGGCTGCCTGGTGAAGGACTACTTCCCTGAGCCTGTGACCGTGAGCTGGAACAGCGGCGCCCTGACCAGCGGCGTGCACACCTTCCCTGCCGTGCTGCAGAGCAGCGGCCTGTACAGCCTGAGCAGCGTGGTGACCGTGCCTAGCAGCAGCCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCTAGCAACACCAAGGTGGACAAGAAGGTG" + let nk = "GCTAGCACGAAAGGCCCTTCAGTATTCCCCCTCGCACCGTCGAGTAAGTCCACGTCGGGTGGGACGGCGGCTCTAGGATGCTTAGTTAAGGACTATTTTCCAGAGCCTGTCACAGTGTCGTGGAACAGTGGTGCTTTAACCAGCGGTGTCCACACCTTTCCTGCCGTTTTACAAAGTAGTGGTCTTTATTCCCTATCGAGCGTCGTTACGGTTCCCAGTTCGAGTTTGGGGACACAGACATACATTTGTAACGTAAACCACAAACCCTCTAACACGAAAGTCGATAAGAAAGTC" + let res = optimizeDNA confHuman nk + res `shouldBe` "GCCAGCACCAAGGGCCCCAGCGTGTTCCCTCTGGCCCCCAGCAGCAAGAGCACCAGCGGCGGCACCGCCGCCCTGGGCTGCCTGGTGAAGGACTACTTCCCCGAGCCCGTGACCGTGAGCTGGAACAGCGGCGCCCTGACCAGCGGCGTGCACACCTTCCCTGCCGTGCTGCAGAGCAGCGGCCTGTACAGCCTGAGCAGCGTGGTGACCGTGCCTAGCAGCAGCCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCCAGCAACACCAAGGTGGACAAGAAGGTG" + res `assertScoreByHumanBetterThan` nk + optimizeShortSequence :: Spec optimizeShortSequence = describe "optimizeShortSequence" $ it "should correct optimize short sequence" $ do - let res = optimizeAA conf "METDTLLLWVLLLWVPGSTG" - res `shouldBe` "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" + let ak = "METDTLLLWVLLLWVPGSTG" + nk <- toRandomNKSequ ak + let res = optimizeAA confHuman ak + res `shouldBe` "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCCGGCAGCACCGGC" + res `assertScoreByHumanBetterThan` nk + optimizeExtremelyShortSequence :: Spec optimizeExtremelyShortSequence = describe "optimizeExtremelyShortSequence" $ it "should correct optimize extremely short sequence" $ do - let res = optimizeAA conf "METDTLL" + let ak = "METDTLL" + nk <- toRandomNKSequ ak + let res = optimizeAA confHuman ak + res `shouldBe` "ATGGAGACCGACACCCTGCTG" + res `assertScoreByHumanBetterThan` nk optimizeSequenceWindow3 :: Spec optimizeSequenceWindow3 = describe "optimizeSequenceWindow3" $ it "should correct optimize sequence with window 3" $ do - let conf' = CodonConfig 3 3 scoreCfg - let res = optimizeAA conf' "METDTLLLWVLLLWVPGSTG" - res `shouldBe` "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCTCTACCGGC" + let conf' = CodonScoreConfig Human 3 3 1 0.5 1.4 40 0.001 2.6 100 1 60 defaultForbiddenRegexp + let ak = "METDTLLLWVLLLWVPGSTG" + nk <- toRandomNKSequ ak + let res = optimizeAA conf' ak + res `shouldBe` "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" + assertScoreBecomeBetter conf' res nk + optimizeSequenceInit5 :: Spec optimizeSequenceInit5 = describe "optimizeSequenceInit5" $ it "should correct optimize sequence with init param = 5" $ do - let conf' = CodonConfig 5 1 scoreCfg - let res = optimizeAA conf' "ASTKGPSVFPLAPSSKSTSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTQTYICNVNHKPSNTKVDKKV" - res `shouldBe` "GCCAGCACCAAGGGCCCCAGCGTGTTTCCTCTGGCCCCTAGCAGCAAGAGCACCAGCGGCGGCACCGCCGCCCTGGGCTGCCTGGTGAAGGACTACTTCCCTGAGCCTGTGACCGTGAGCTGGAACAGCGGCGCCCTGACCAGCGGCGTGCACACCTTCCCTGCCGTGCTGCAGAGCAGCGGCCTGTACAGCCTGAGCAGCGTGGTGACCGTGCCTAGCAGCAGCCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCTAGCAACACCAAGGTGGACAAGAAGGTG" + let conf' = CodonScoreConfig Human 5 1 1 0.5 1.4 40 0.001 2.6 100 1 60 defaultForbiddenRegexp + let ak = "ASTKGPSVFPLAPSSKSTSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTQTYICNVNHKPSNTKVDKKV" + nk <- toRandomNKSequ ak + let res = optimizeAA conf' ak + res `shouldBe` "GCCAGCACCAAGGGCCCCAGCGTGTTCCCTCTGGCCCCCAGCAGCAAGAGCACCAGCGGCGGCACCGCCGCCCTGGGCTGCCTGGTGAAGGACTACTTCCCCGAGCCCGTGACCGTGAGCTGGAACAGCGGCGCCCTGACCAGCGGCGTGCACACCTTCCCTGCCGTGCTGCAGAGCAGCGGCCTGTACAGCCTGAGCAGCGTGGTGACCGTGCCTAGCAGCAGCCTGGGCACCCAGACCTACATCTGCAACGTGAACCACAAGCCCAGCAACACCAAGGTGGACAAGAAGGTG" + assertScoreBecomeBetter conf' res nk + scoreFun :: Spec scoreFun = describe "scoreFun" $ it "should correct count score" $ do - score conf "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 40.88886033302965 - score conf "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 45.91010855311742 - score conf "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" - `shouldBe` 66.00968914282373 + score confHuman "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 80.83499151084192 + score confHuman "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 80.74362252733329 + score confHuman "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" + `shouldBe` 96.19662511761598 +scoreFunEColi :: Spec +scoreFunEColi = + describe "scoreFunEcoli" $ + it "should correct count score for Ecoli" $ do + score confEColi "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 58.913612822848826 + score confEColi "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 23.025024455733913 + score confEColi "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" + `shouldBe` 29.501417850070677 + scoreFunDifferentCodonUsageWeight :: Spec scoreFunDifferentCodonUsageWeight = describe "scoreFunDifferentCodonUsageWeight" $ it "should correct count score with g_cu=9" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 9 0.5 1.4 40 0.001 2.6 100 1 43) + let conf' = CodonScoreConfig Human 3 1 9 0.5 1.4 40 0.001 2.6 100 1 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 840.8888603330297 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 748.8141376168824 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" @@ -120,7 +222,7 @@ scoreFunDifferentGCWeight = describe "scoreFunDifferentGCWeight" $ it "should correct count score with g_gc=0.2" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.2 1.4 40 0.001 2.6 100 1 43) + let conf' = CodonScoreConfig Human 3 1 1 0.2 1.4 40 0.001 2.6 100 1 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 75.15554413321186 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 71.08184560102933 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" @@ -130,7 +232,7 @@ scoreFunDifferentGCFactor = describe "scoreFunDifferentGCFactor" $ it "should correct count score with f_gc=1.7" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.5 1.7 40 0.001 2.6 100 1 43) + let conf' = CodonScoreConfig Human 3 1 1 0.5 1.7 40 0.001 2.6 100 1 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` -59.640364905662636 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` -20.530452529069947 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" @@ -140,7 +242,7 @@ scoreFunDifferentGCWindow = describe "scoreFunDifferentGCWindow" $ it "should correct count score with w_gc=10" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.5 1.4 10 0.001 2.6 100 1 43) + let conf' = CodonScoreConfig Human 3 1 1 0.5 1.4 10 0.001 2.6 100 1 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 19.575380904184584 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 61.4633338693899 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" @@ -150,7 +252,7 @@ scoreFunDifferentFoldingWeight = describe "scoreFunDifferentFoldingWeight" $ it "should correct count score with weight of folding = 0.03" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.5 1.4 40 0.03 2.6 100 1 43) + let conf' = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.03 2.6 100 1 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` -45.11113966697035 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 43.91010855311742 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" @@ -160,7 +262,7 @@ scoreFunDifferentFoldingFactor = describe "scoreFunDifferentFoldingFactor" $ it "should correct count score with folding factor = 4.999" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.5 1.4 40 0.001 4.999 100 1 43) + let conf' = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.001 4.999 100 1 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` -4644.11113966697 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 42.91010855311742 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" @@ -170,7 +272,7 @@ scoreFunDifferentFoldingWindow = describe "scoreFunDifferentFoldingWindow" $ it "should correct count score with folding window = 23" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.5 1.4 40 0.001 2.6 23 1 43) + let conf' = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.001 2.6 23 1 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 42.88886033302965 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 45.91010855311742 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG" @@ -180,15 +282,22 @@ scoreFunWithForbiddenSeq = describe "scoreFunWithForbiddenSeq" $ it "should correct count score with forbidden sequence" $ do - score conf "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCATACTCCCCCGGC" `shouldBe` -3.4521030544284343 - score conf "GCCAGCGGCGACCGGCGGGTCAAGACCCACACCTGTCCT" `shouldBe` -17.346165749671798 - score conf "ACAGCCAGCGAATAAACCCCGAGGCCGCCGGCGGCCCTAGCGTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATGACTACAGCCAAG" `shouldBe` 3.4278532842107197 + let confWithoutForbidden = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.001 2.6 23 1 43 [] + score confWithoutForbidden "GACAACCGGAATACCCTGCTGCTGTAGATGCTACTGCTGTGGGTGCCTGGCAGCACCATACTCTCTCGT" `shouldBe` 28.517294972946885 + score confWithoutForbidden "GACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCATACTCCCCCGTAACCGGAAC" `shouldBe` 59.71421227843634 + score confWithoutForbidden "GCCAGCGGCGACCCAAGACCCACACCTGTCCTAGCGGGT" `shouldBe` -12.47745413521671 + let forbidden = ["AACCGGAAC", "(A|C)..GGG(C|T)"] + let confWithForbidden = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.001 2.6 23 1 43 forbidden + score confWithForbidden "GACAACCGGAATACCCTGCTGCTGTAGATGCTACTGCTGTGGGTGCCTGGCAGCACCATACTCTCTCGT" `shouldBe` 28.517294972946885 + score confWithForbidden "GACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCATACTCCCCCGTAACCGGAAC" `shouldBe` 9.714212278436342 + score confWithForbidden "GCCAGCGGCGACCCAAGACCCACACCTGTCCTAGCGGGT" `shouldBe` -62.47745413521671 + scoreFunDifferentForbiddenSeqWeight :: Spec scoreFunDifferentForbiddenSeqWeight = describe "scoreFunDifferentForbiddenSeqWeight" $ it "should correct count score with forbidden sequence weight = 4" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.5 1.4 40 0.001 2.6 100 4 43) + let conf' = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.001 2.6 100 4 43 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCATACTCCCCCGGC" `shouldBe` -153.45210305442845 score conf' "GCCAGCGGCGACCGGCGGGTCAAGACCCACACCTGTCCT" `shouldBe` -167.3461657496718 score conf' "ACAGCCAGCGAATAAACCCCGAGGCCGCCGGCGGCCCTAGCGTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATGACTACAGCCAAG" `shouldBe` -146.57214671578927 @@ -198,7 +307,7 @@ scoreFunDifferentGCDesired = describe "scoreFunDifferentGCDesired" $ it "should correct count score with gc desired = 60" $ do - let conf' = CodonConfig 3 1 (CodonScoreConfig 1 0.5 1.4 40 0.001 2.6 100 1 60) + let conf' = CodonScoreConfig Human 3 1 1 0.5 1.4 40 0.001 2.6 100 1 60 defaultForbiddenRegexp score conf' "ATGGAGACCGACACCCTGCTGCTGTGGGTGCTGCTGCTGTGGGTGCCTGGCAGCACCGGC" `shouldBe` 80.83499151084192 score conf' "GCCAGCGGCGACAAGACCCACACCTGTCCT" `shouldBe` 80.74362252733329 score conf' "CCCTGCCCCGCCCCCGAGGCCGCCGGCGGCCCTAGCGTGTTCCTGTTCCCTCCTAAGCCTAAGGACACCCTGATGATCAGCAGAACCCCCGAGGTGACCTGCGTGGTGGTGGACGTGAGCCACGAGGACCCTGAGGTGAAGTTCAATTGGTACGTGGACGGCGTGGAGGTGCACAACGCCAAGACCAAGCCTAGAGAGGAGCAGTACAACAGCACCTACAGAGTGGTGAGCGTGCTGACCGTGCTGCACCAAGACTGGCTGAACGGCAAGGAGTACAAGTGCAAGGTGAGCAACAAGGCCCTGCCCGCCCCTATCGAGAAGACCATCAGCAAGGCCAAG"