--- /dev/null
+#include <iostream>
+#include <unordered_map>
+
+enum class aa {unknown, A,R,N,D,C, Q,E,G,H,I, L,K,M,F,P, S,T,W,Y,V, B,Z,X, star, gap,};
+enum class nt {T,C,A,G};
+enum class codon {TTT,TTC,TTA,TTG, TCT,TCC,TCA,TCG, TAT,TAC,TAA,TAG, TGT,TGC,TGA,TGG,
+ CTT,CTC,CTA,CTG, CCT,CCC,CCA,CCG, CAT,CAC,CAA,CAG, CGT,CGC,CGA,CGG,
+ ATT,ATC,ATA,ATG, ACT,ACC,ACA,ACG, AAT,AAC,AAA,AAG, AGT,AGC,AGA,AGG,
+ GTT,GTC,GTA,GTG, GCT,GCC,GCA,GCG ,GAT,GAC,GAA,GAG, GGT,GGC,GGA,GGG};
+
+
+typedef std::unordered_map<char,int> str2int_map;
+typedef std::unordered_map<int,char> int2str_map;
+//typedef std::unordered_map<int,aa> int2aa_map;
+typedef std::unordered_map<codon,aa> codon2aa_map;
+typedef std::unordered_map<aa,char> aa2str_map;
+typedef std::unordered_map<char,aa> str2aa_map;
+typedef std::unordered_map<codon,std::string> codon2str_map;
+typedef std::unordered_map<std::string,codon> str2codon_map;
+
+namespace std {
+ template<> struct hash<aa> {
+ inline size_t operator()(const aa &x) const { return static_cast<int>(x); }
+ };
+ template<> struct hash<nt> {
+ inline size_t operator()(const nt &x) const { return static_cast<int>(x); }
+ };
+ template<> struct hash<codon> {
+ inline size_t operator()(const codon &x) const { return static_cast<int>(x); }
+ };
+}
+
+codon2aa_map codon2aa {
+ {codon::TTT, aa::F}, {codon::TTC, aa::F}, {codon::TTA, aa::L}, {codon::TTG, aa::L},
+ {codon::TCT, aa::S}, {codon::TCC, aa::S}, {codon::TCA, aa::S}, {codon::TCG, aa::S},
+ {codon::TAT, aa::Y}, {codon::TAC, aa::Y}, {codon::TAA, aa::star}, {codon::TAG, aa::star},
+ {codon::TGT, aa::C}, {codon::TGC, aa::C}, {codon::TGA, aa::star}, {codon::TGG, aa::W},
+ {codon::CTT, aa::L}, {codon::CTC, aa::L}, {codon::CTA, aa::L}, {codon::CTG, aa::L},
+ {codon::CCT, aa::P}, {codon::CCC, aa::P}, {codon::CCA, aa::P}, {codon::CCG, aa::P},
+ {codon::CAT, aa::H}, {codon::CAC, aa::H}, {codon::CAA, aa::Q}, {codon::CAG, aa::Q},
+ {codon::CGT, aa::R}, {codon::CGC, aa::R}, {codon::CGA, aa::R}, {codon::CGG, aa::R},
+ {codon::ATT, aa::I}, {codon::ATC, aa::I}, {codon::ATA, aa::I}, {codon::ATG, aa::M},
+ {codon::ACT, aa::T}, {codon::ACC, aa::T}, {codon::ACA, aa::T}, {codon::ACG, aa::T},
+ {codon::AAT, aa::N}, {codon::AAC, aa::N}, {codon::AAA, aa::K}, {codon::AAG, aa::K},
+ {codon::AGT, aa::S}, {codon::AGC, aa::S}, {codon::AGA, aa::R}, {codon::AGG, aa::R},
+ {codon::GTT, aa::V}, {codon::GTC, aa::V}, {codon::GTA, aa::V}, {codon::GTG, aa::V},
+ {codon::GCT, aa::A}, {codon::GCC, aa::A}, {codon::GCA, aa::A}, {codon::GCG, aa::A},
+ {codon::GAT, aa::D}, {codon::GAC, aa::D}, {codon::GAA, aa::E}, {codon::GAG, aa::E},
+ {codon::GGT, aa::G}, {codon::GGC, aa::G}, {codon::GGA, aa::G}, {codon::GGG, aa::G},
+};
+
+str2int_map aa2int {
+ {'A', 1}, {'R', 2}, {'N', 3}, {'D', 4}, {'C', 5},
+ {'Q', 6}, {'E', 7}, {'G', 8}, {'H', 9}, {'I', 10},
+ {'L', 11}, {'K', 12}, {'M', 13}, {'F', 14}, {'P', 15},
+ {'S', 16}, {'T', 17}, {'W', 18}, {'Y', 19}, {'V', 20},
+ {'B', 21}, {'Z', 22}, {'X', 23}, {'*', 24}, {'-', 25}, {'?', 0}
+};
+
+int2str_map int2aa = {
+ { 1, 'A'}, { 2, 'R'}, { 3, 'N'}, { 4, 'D'}, { 5, 'C'},
+ { 6, 'Q'}, { 7, 'E'}, { 8, 'G'}, { 9, 'H'}, {10, 'I'},
+ {11, 'L'}, {12, 'K'}, {13, 'M'}, {14, 'F'}, {15, 'P'},
+ {16, 'S'}, {17, 'T'}, {18, 'W'}, {19, 'Y'}, {20, 'V'},
+ {21, 'B'}, {22, 'Z'}, {23, 'X'}, {24, '*'}, {25, '-'}, {0, '?'}
+};
+
+aa2str_map aa2str = {
+ {aa::A,'A'}, {aa::R,'R'}, {aa::N,'N'}, {aa::D,'D'}, {aa::C,'C'},
+ {aa::Q,'Q'}, {aa::E,'E'}, {aa::G,'G'}, {aa::H,'H'}, {aa::I,'I'},
+ {aa::L,'L'}, {aa::K,'K'}, {aa::M,'M'}, {aa::F,'F'}, {aa::P,'P'},
+ {aa::S,'S'}, {aa::T,'T'}, {aa::W,'W'}, {aa::Y,'Y'}, {aa::V,'V'},
+ {aa::B,'B'}, {aa::Z,'Z'}, {aa::X,'X'}, {aa::star,'*'}, {aa::gap,'-'}, {aa::unknown,'?'}
+};
+
+str2aa_map str2aa = {
+ {'A',aa::A}, {'R',aa::R}, {'N',aa::N}, {'D',aa::D}, {'C',aa::C},
+ {'Q',aa::Q}, {'E',aa::E}, {'G',aa::G}, {'H',aa::H}, {'I',aa::I},
+ {'L',aa::L}, {'K',aa::K}, {'M',aa::M}, {'F',aa::F}, {'P',aa::P},
+ {'S',aa::S}, {'T',aa::T}, {'W',aa::W}, {'Y',aa::Y}, {'V',aa::V},
+ {'B',aa::B}, {'Z',aa::Z}, {'X',aa::X}, {'*',aa::star}, {'-',aa::gap}, {'?',aa::unknown}
+};
+
+codon2str_map codon2str = {
+ {codon::TTT, "TTT"}, {codon::TTC, "TTC"}, {codon::TTA, "TTA"}, {codon::TTG, "TTG"},
+ {codon::TCT, "TCT"}, {codon::TCC, "TCC"}, {codon::TCA, "TCA"}, {codon::TCG, "TCG"},
+ {codon::TAT, "TAT"}, {codon::TAC, "TAC"}, {codon::TAA, "TAA"}, {codon::TAG, "TAG"},
+ {codon::TGT, "TGT"}, {codon::TGC, "TGC"}, {codon::TGA, "TGA"}, {codon::TGG, "TGG"},
+ {codon::CTT, "CTT"}, {codon::CTC, "CTC"}, {codon::CTA, "CTA"}, {codon::CTG, "CTG"},
+ {codon::CCT, "CCT"}, {codon::CCC, "CCC"}, {codon::CCA, "CCA"}, {codon::CCG, "CCG"},
+ {codon::CAT, "CAT"}, {codon::CAC, "CAC"}, {codon::CAA, "CAA"}, {codon::CAG, "CAG"},
+ {codon::CGT, "CGT"}, {codon::CGC, "CGC"}, {codon::CGA, "CGA"}, {codon::CGG, "CGG"},
+ {codon::ATT, "ATT"}, {codon::ATC, "ATC"}, {codon::ATA, "ATA"}, {codon::ATG, "ATG"},
+ {codon::ACT, "ACT"}, {codon::ACC, "ACC"}, {codon::ACA, "ACA"}, {codon::ACG, "ACG"},
+ {codon::AAT, "AAT"}, {codon::AAC, "AAC"}, {codon::AAA, "AAA"}, {codon::AAG, "AAG"},
+ {codon::AGT, "AGT"}, {codon::AGC, "AGC"}, {codon::AGA, "AGA"}, {codon::AGG, "AGG"},
+ {codon::GTT, "GTT"}, {codon::GTC, "GTC"}, {codon::GTA, "GTA"}, {codon::GTG, "GTG"},
+ {codon::GCT, "GCT"}, {codon::GCC, "GCC"}, {codon::GCA, "GCA"}, {codon::GCG, "GCG"},
+ {codon::GAT, "GAT"}, {codon::GAC, "GAC"}, {codon::GAA, "GAA"}, {codon::GAG, "GAG"},
+ {codon::GGT, "GGT"}, {codon::GGC, "GGC"}, {codon::GGA, "GGA"}, {codon::GGG, "GGG"},
+};
+
+str2codon_map str2codon = {
+ {"TTT", codon::TTT}, {"TTC", codon::TTC}, {"TTA", codon::TTA}, {"TTG", codon::TTG},
+ {"TCT", codon::TCT}, {"TCC", codon::TCC}, {"TCA", codon::TCA}, {"TCG", codon::TCG},
+ {"TAT", codon::TAT}, {"TAC", codon::TAC}, {"TAA", codon::TAA}, {"TAG", codon::TAG},
+ {"TGT", codon::TGT}, {"TGC", codon::TGC}, {"TGA", codon::TGA}, {"TGG", codon::TGG},
+ {"CTT", codon::CTT}, {"CTC", codon::CTC}, {"CTA", codon::CTA}, {"CTG", codon::CTG},
+ {"CCT", codon::CCT}, {"CCC", codon::CCC}, {"CCA", codon::CCA}, {"CCG", codon::CCG},
+ {"CAT", codon::CAT}, {"CAC", codon::CAC}, {"CAA", codon::CAA}, {"CAG", codon::CAG},
+ {"CGT", codon::CGT}, {"CGC", codon::CGC}, {"CGA", codon::CGA}, {"CGG", codon::CGG},
+ {"ATT", codon::ATT}, {"ATC", codon::ATC}, {"ATA", codon::ATA}, {"ATG", codon::ATG},
+ {"ACT", codon::ACT}, {"ACC", codon::ACC}, {"ACA", codon::ACA}, {"ACG", codon::ACG},
+ {"AAT", codon::AAT}, {"AAC", codon::AAC}, {"AAA", codon::AAA}, {"AAG", codon::AAG},
+ {"AGT", codon::AGT}, {"AGC", codon::AGC}, {"AGA", codon::AGA}, {"AGG", codon::AGG},
+ {"GTT", codon::GTT}, {"GTC", codon::GTC}, {"GTA", codon::GTA}, {"GTG", codon::GTG},
+ {"GCT", codon::GCT}, {"GCC", codon::GCC}, {"GCA", codon::GCA}, {"GCG", codon::GCG},
+ {"GAT", codon::GAT}, {"GAC", codon::GAC}, {"GAA", codon::GAA}, {"GAG", codon::GAG},
+ {"GGT", codon::GGT}, {"GGC", codon::GGC}, {"GGA", codon::GGA}, {"GGG", codon::GGG},
+};
+
+/*
+template <typename from, typename to>
+to x2y(from x)
+{
+ switch (typeof(from)) {
+ case int:
+ switch (typeof(to)) {
+ case float:
+ return (float)(x);
+ break;
+ }
+ break;
+ }
+}
+*/
+template <typename from, typename to>
+to x2y(from x) {return static_cast<to>(x);}
+
+int main(int argc, char *argv[])
+{
+ std::cout << x2y<int,float>(5) << std::endl;
+ std::cout << (int)(codon2aa[codon::TTT]) << std::endl;
+ std::cout << static_cast<int>(codon2aa[codon::TTC]) << std::endl;
+ std::cout << aa2str[codon2aa[codon::TTC]] << std::endl;
+ //std::cout << aa2str[str2aa[int2aa[aa2int[codon2aa[str2codon["TTC"]]]]]] << std::endl;
+
+#if 0
+
+ for(charmap::iterator i = aa2int.begin(); i != aa2int.end(); ++i) {
+ std::cout << aa2int[i->first] << '\t' << i->second << std::endl;
+ }
+
+
+ for(intmap::iterator i = int2aa.begin(); i != int2aa.end(); ++i) {
+ std::cout << int2aa[i->first] << '\t' << i->second << std::endl;
+ }
+#endif
+
+ return 0;
+}
+
+
+/*
+aa2int = {
+ 'A': 1, 'R': 2, 'N': 3, 'D': 4, 'C': 5,
+ 'Q': 6, 'E': 7, 'G': 8, 'H': 9, 'I': 10,
+ 'L': 11, 'K': 12, 'M': 13, 'F': 14, 'P': 15,
+ 'S': 16, 'T': 17, 'W': 18, 'Y': 19, 'V': 20,
+ 'B': 21, 'Z': 22, 'X': 23, '*': 24, '-': 25, '?': 0
+}
+
+
+int2aa = {
+ 1 :'A', 2 :'R', 3 :'N', 4 :'D', 5 :'C',
+ 6 :'Q', 7 :'E', 8 :'G', 9 :'H', 10 :'I',
+ 11 :'L', 12 :'K', 13 :'M', 14 :'F', 15 :'P',
+ 16 :'S', 17 :'T', 18 :'W', 19 :'Y', 20 :'V',
+ 21 :'B', 22 :'Z', 23 :'X', 24 :'*', 25 :'-', 0 :'?'
+}
+
+
+def codon2aa(c):
+ """
+ Returns the amino acid character corresponding to the input codon.
+ """
+
+ # If all nucleotides are missing, return gap
+
+ if c[0]=='-' and c[1]=='-' and c[2]=='-':
+ return '-'
+
+ # If the first or second nucleotide is ambiguous, AA cannot be determined, return '*'
+
+ elif c[0] in ['W', 'S', 'M', 'K', 'R', 'Y', '-'] or c[1] in ['W', 'S', 'M', 'K', 'R', 'Y', '-']:
+ return '*'
+
+ # Else go to tree
+
+ elif c[0]=='T':
+ if c[1]=='T':
+ if c[2] in ['T', 'C', 'Y']: return 'F'
+ elif c[2] in ['A', 'G', 'R']: return 'L'
+ else: return '*'
+ elif c[1]=='C': return 'S'
+ elif c[1]=='A':
+ if c[2] in ['T', 'C', 'Y']: return 'Y'
+ elif c[2] in ['A', 'G', 'R']: return '*'
+ else: return '*'
+ elif c[1]=='G':
+ if c[2] in ['T', 'C', 'Y']: return 'C'
+ elif c[2]=='A': return '*'
+ elif c[2]=='G': return 'W'
+ else: return '*'
+ else: return '*'
+
+ elif c[0]=='C':
+ if c[1]=='T': return 'L'
+ elif c[1]=='C': return 'P'
+ elif c[1]=='A':
+ if c[2] in ['T', 'C', 'Y']: return 'H'
+ elif c[2] in ['A', 'G', 'R']: return 'Q'
+ else: return '*'
+ elif c[1]=='G': return 'R'
+ else: return '*'
+
+ elif c[0]=='A':
+ if c[1]=='T':
+ if c[2] in ['T', 'C', 'Y']: return 'I'
+ elif c[2] in ['A', 'M', 'W']: return 'I'
+ elif c[2]=='G': return 'M'
+ else: return '*'
+ elif c[1]=='C': return 'T'
+ elif c[1]=='A':
+ if c[2] in ['T', 'C', 'Y']: return 'N'
+ elif c[2] in ['A', 'G', 'R']: return 'K'
+ else: return '*'
+ elif c[1]=='G':
+ if c[2] in ['T', 'C', 'Y']: return 'S'
+ elif c[2] in ['A', 'G', 'R']: return 'R'
+ else: return '*'
+ else: return '*'
+
+ elif c[0]=='G':
+ if c[1]=='T': return 'V'
+ elif c[1]=='C': return 'A'
+ elif c[1]=='A':
+ if c[2] in ['T', 'C', 'Y']: return 'D'
+ elif c[2] in ['A', 'G', 'R']: return 'E'
+ else: return '*'
+ elif c[1]=='G': return 'G'
+ else: return '*'
+
+ else: return '*'
+*/
projects / VirEvoDyn.git / commitdiff