Codons are triplets, but what’s a Singlet, Doublet, etc?

Viewing 4 reply threads
  • Author
    Posts
    • #16953
      GaryGaulin
      Participant

      I’m working on a minimal-code program (a simple how-to for programmers and general public) that compares/displays chromosomes, using a technique I called "digital banding". Here is the illustration for Orangutan, Gorilla, Chimp, Human Chromosome 2.

      https://sites.google.com/site/digitalch … ness20.png

      And one with what I called "Brightness Adjust" that makes visible the bands of the least abundant reverse compliment triplets.

      https://sites.google.com/site/digitalch … dusted.png

      Inspiration came from "The Functional Anarchy Of Genomes" and "Genome Navigation (GA-sequences and their striking properties)" found here:
      http://www.basic.northwestern.edu/g-bue … genome.htm

      The next experiment I would like to try, is allow selecting how many code letters there are per [insert proper word here]. Only nagging problem, is that the closest word I know or could find is "Codon". But the way the word is defined it’s assumed to be a triplet. I still found indication that the word can be used that way, even though it’s not used in biology. I’m tempted to just use the word in the program for any number of letters per codon, but thought I had better ask here in case there is a word that more specifically covers singlets, doublets, triplets, quartets, etc..

      Any ideas?

    • #112764
      JackBean
      Participant

      What about ‘word’? That’s used in BLAST algorithm, so I think it could be understandable.

      Anyway, what’s the point of your pictures exactly?

    • #112768
      GaryGaulin
      Participant

      Thanks for the excellent keywords (BLAST algorithm) that worked great for finding ideas in the google search engine.

      I am familiar with the NCBI’s BLAST search engine and interface to their supercomputers, but until now the program has been more precisely looking for abundances (as opposed to similarity which introduces an added level of complexity) so I kept the code basic chemistry, and used terminology from the northwestern.edu link that describes two “groups” of 32 different “triplets” as well as a singlet “spectrum” that should get interesting when the band width is just the right width to see what Guenter is describing. In the cognitive computer model that I explain this corresponds with “addressing” while the genes are the “data”:

      http://www.planetsourcecode.com/vb/scri … 5&lngWId=1

      http://intelligencegenerator.blogspot.com/

      The DNA program I am currently writing more or less goes with the Intelligence Design Lab. It is to help visualize what should make it surprisingly easy to model “molecular intelligence” that I describe in the theory of you know what, that thankfully some in the Biology-Online forum(s) years ago knew about so I don’t feel out of place or obliged to all over again go into the scientific reasons why I had no choice but to call it this:

      http://theoryofid.blogspot.com/

      In my latest software project I started at the whole chromosome level, where it’s then just a matter of zooming in for more detail where eventually there should be individual letters showing this type of addressing structure:

      The main purpose of the new program is to help figure out how to accurately model not yet fully understood processes. At the chromosome level there are fusions, which the new program already helps show. I now need to see more.

      Since DNA is by itself only the lifeless memory core of a living system, a more complete computer model also relies on molecular networks like I described here to parallel programmers and GPU board manufacturers who all enjoy knowing what’s new in science that scientists next need to model:

      http://opencldev.com/forum/index.php?topic=242.0

      While the GPU technology is coming of age I’m working on the problems that do not require a supercomputer to solve. The chromosome banding program is one of them. It does not need to search for similarity like the BLAST algorithm does, this algorithm just has to most simply dissect and display the singlet, doublet, triplet, etc. contents of Fasta files with bitmap images that I then convert to png format. Even with Visual Basic 6 (that I still use because of its rapid development and easy to understand/code into other languages) it makes a complicated illustration in much less than a minute, which is fast enough where it only has to be properly compiled only once then it’s done.

      I’m now stuck on basic terminology, but your suggestion has already been helpful. I will try to use “word” in the code comments (where instructions and how it works are first explained) to see how well it fits in with all else that the program has to include for terminology. There is still something peculiar about the word “Codon” though. It is short and still infers that it is a code unit, which makes and an excellent word to use, as though it was originally intended for any codon size but since biology (at least mostly) uses triplets it has lost its meaning. For example it has been speculatively theorized that two letter coding led to the current three in which case it still seems to be a codon, but there is again the problem of what to call a two letter code element. Since it’s my program I can call it anything I want. But I do can’t go off on my own naming things. I need to find the most appropriate and would rather use a word that is precise but somehow losing its meaning, than one that right away causes confusion because of not being specific enough and suggests that two or 4+ letter codons cannot exist anywhere in the universe. It’s like my instincts are telling me that "codon" might still be the most specific word to use, even though biology textbooks and dictionaries assume three letters. The word "word" is now competing with it, and I hope that something will soon turn up that makes it easy to decide which of the two I need to use.

    • #112772
      GaryGaulin
      Participant

      Ah ha!
      Thinking it terms of words/letters sent Google Scholar straight for something in a 1982 paper that I did not know about, where in its Abstract it theorizes a two letter codon:

      quote :

      THE POSSIBLE ROLE OF ASSIGNMENT CATALYSTS IN THE ORIGIN OF THE GENETIC CODE

      VAHE BEDIAN * Department of Biophysical Sciences, State University of New York at Buffalo, Buffalo, New York, 14214, U.S.A.

      (Received 29 January, 1982; Accepted 5 April, 1982)

      Abstract.

      A model is presented for the emergence of a primitive genetic code through the selection of a family of proteins capable of executing the code and catalyzing their own formation from polynucleotide templates. These proteins are assignment catalysts capable of modulating the rate of incorporation of different amino acids at the position of different codons. The starting point of the model is a polynucleotide based polypeptide construction process which maintains colinearity between template and product, but may not maintain a coded relationship between amino acids and codons. Among the primitive proteins made are assumed to be assignment catalysts characterized by structural and functional parameters which are used to formulate the production kinetics of these catalysts from available templates. Application of the model to the simple case of two letter codon and amino acid alphabets has been analyzed in detail. As the structural, functional, and kinetic parameters are varied, the dynamics undergoes many bifurcations, allowing an initially ambiguous system of catalysts to evolve to a coded, self-reproductive system. The proposed selective pressure of this evolution is the efficiency of utilization of monomers and energy. The model also simulates the qualitative features of suppression, in which a deleterious mutation is partly corrected by the introduction of translational error.
      http://www.springerlink.com/content/r5vk622056mk8227/

      Since the program is for origin of life science like this, I think I found what definitively settles this dilemma!

      I’ll morph your idea with that then show you what it looks like on the screen. It has a "Chromotype" listbox to select organism assembly and other controls that (by their function in the program) establish and operationally define the scientific terminology that is then in turn required by the theory. Only words that are absolutely needed end up remaining, resulting in a streamlined vocabulary that helps make all this science easier to figure out and use.

    • #112795
      GaryGaulin
      Participant

      I finally have something for you!

      To make it as easy as possible for us to see all the variables and how they are formed I wrote a minimal code subroutine to save on disk (and in RAM) a list of 1 to 8 letter codons in Base4 or Base5. The lines of code to save to disk can later be removed, for use in the chromosome illustration program that currently only works for triplets and needs this added.

      The screen of this test program looks like:

      Here’s the program code:

      code :'==================================================================================================
      'Program to create diskfiles for Base4 (ACGT) and Base5 (ACGTN) Codons for checkbox selected Sizes.
      'The letter "N" represents an unknown ACTG letter, resulting in more codons of the same Codon Size.
      'By Gary S. Gaulin, 2012, as part of the Chromosome Illustrator project which will use this method.
      '==================================================================================================
      Option Explicit
      'Arrays for storing Codon string, its Complement and Reverse Complement strings.
      'This program does not need to save codons in RAM, it's included for other programs that do.
      Dim Codon() As String
      Dim CodonCompl() As String
      Dim CodonRevCompl() As String

      Private Sub Form_Load()
      'After clicking on the compiled .exe file the program starts here.
      'On reaching End the form stays on screen waiting for something to be click.
      End Sub

      'Program goes here after you Click the "Create Codon Files" Command button.
      Private Sub CreateCodonFilesCommand_Click()
      Dim CodonSizeNum As Long
      For CodonSizeNum = 1 To 8
      Dialog = "Codon Size Number " & CodonSizeNum: Dialog.Refresh
      If CodonSizeCheck(CodonSizeNum) = 1 Then
      'Create disk file for Base4 (ACGT) and Base5 (ACTGN) codons.
      Call CreateCodonFile(4, CodonSizeNum) 'Base4 file.
      DoEvents 'Allow Windows to process screen/mouse Events while waiting.
      Call CreateCodonFile(5, CodonSizeNum) 'Base5 file.
      DoEvents 'Allow Windows to process screen/mouse Events while waiting.
      End If
      Next CodonSizeNum
      Dialog = "Codon Files Successfully Created.": Dialog.Refresh
      End Sub

      'Create Codon disk file and array with Base4 (ACGT) or Base5 (ACTGN) codons.
      'On entry MathBase = 4 or 5, and CodonSize = 1 to 10 but 10LetterBase5=half gig file.
      Private Sub CreateCodonFile(MathBase As Long, CodonSize As Long)
      Dim MathBaseStr As String
      Dim MathBaseNumStr As String
      Dim Base10Str As String
      Dim FormatZeros As String 'String is for storing ascii characters.
      Dim TotalCodons As Long
      Dim CodonNum As Long
      Dim LetterNum As Long
      Dim DigitVal As Long
      Dim PowerOf4or5 As Long
      Dim DigitOnes As Double
      Dim Space1 As String
      Dim Space2 As String
      'Associative array for converting number to its associated letter.
      'Letters are in alphabetical order, sorted listboxes will retain same codon order.
      Dim ACGTN(4) As String
      ACGTN(0) = "A" 'Purine-base Adenine
      ACGTN(1) = "C" 'Pyrimidine-base Cytosine
      ACGTN(2) = "G" 'Purine-base Guanine
      ACGTN(3) = "T" 'Pyrimidine-base Thymine
      ACGTN(4) = "N" '"N" is the 5th base, for math Base 5 only.
      'Associative array for finding Compliment of each letter number 0-4.
      Dim Complement(4) As String
      Complement(0) = "T"
      Complement(1) = "G"
      Complement(2) = "C"
      Complement(3) = "A"
      Complement(4) = "N"
      'Resize the Codon string arrays and erase the elements.
      ReDim Codon((MathBase ^ CodonSize) - 1) As String
      ReDim CodonCompl((MathBase ^ CodonSize) - 1) As String
      ReDim CodonRevCompl((MathBase ^ CodonSize) - 1) As String
      'Make a string that says "Base4" or "Base5" to use for printing file headers.
      MathBaseStr = "Base" & Format(MathBase)
      'Open disk file to save output to.
      Open App.Path & "\" & Format(CodonSize) & "Letter" & MathBaseStr & "Codons.txt" For Output As #1
      'Print main file header showing Codon Size and name Singlet,Doublet,Triplet,etc., used for Check box Captions.
      Print #1, MathBaseStr & ", " & CodonSize & " letter Codon Size, " & CodonSizeCheck(CodonSize).Caption & "s."
      Print #1, "Number shown in math Base10 and " & MathBaseStr & " with"
      Print #1, "Codon, its Complement, Reverse Complement."
      Print #1, ""
      'Calculate Total number of Codons, for this Codon Size.
      TotalCodons = MathBase ^ CodonSize
      'Make a text Format string with as many zeros as there are base 10 digits in Codon Number.
      FormatZeros = String(Len(Format(TotalCodons - 1)), "0")
      'Make a text string to properly space the data lines to be saved to disk file.
      Space1 = String(9 - Len(FormatZeros), " ")
      Space2 = String(11 - CodonSize, " ")
      'Print the labels that appear directly above the list of codons.
      Print #1, "---------------------------------------------------------------"
      Print #1, "Base10 " & MathBaseStr & " Codon Compl RevCo"
      Print #1, "---------------------------------------------------------------"
      'Count from 0 to number of codons-1. Triplets have 64 Total Codons, count is then 0 to 63.
      For CodonNum = 0 To TotalCodons - 1
      'Format (all the same size) Base10 String with leading Zeros (000,001,002,) for showing Codon Number in disk file.
      Base10Str = Format(CodonNum, FormatZeros)
      'Clear string for forming Base4 or Base5 String, for showing Codon Number in disk file.
      MathBaseNumStr = ""
      'Loop for each of the Codon Letters in this Codon Size, numbering starts a 0.
      For LetterNum = 0 To CodonSize - 1
      'Power Of 4 counts 1, 4, 16, 64, etc., Power Of 5 counts 1, 5, 25, 125, etc..
      PowerOf4or5 = MathBase ^ LetterNum
      'Get associated Base4 or 5 Digit into Ones place of DigitOnes variable. Fix removes now fractional lower digits.
      DigitOnes = Fix(CodonNum / PowerOf4or5)
      'Remove remaing digit place by subtracting what does not divide out over 4.
      DigitVal = DigitOnes - (Fix(DigitOnes / MathBase) * MathBase)
      'Codon string is formed by adding A-T letter character to Left side of Codon string.
      Codon(CodonNum) = ACGTN(DigitVal) & Codon(CodonNum)
      'Codon Complement string is found by adding T-A letter character to Left side of Codon string.
      CodonCompl(CodonNum) = Complement(DigitVal) & CodonCompl(CodonNum)
      'Codon Reverse Complement is found by subtracting 3 while adding T-A letter to Right side of string.
      CodonRevCompl(CodonNum) = CodonRevCompl(CodonNum) & Complement(DigitVal)
      'Add the Digit Value (0-3 or 0-4) to string that will show the Codon Number in math Base 4 or 5.
      MathBaseNumStr = Format(DigitVal) & MathBaseNumStr
      'Loop back up for Next Letter Number.
      Next LetterNum
      'Add the information line for this Codon to the disk file.
      Print #1, Base10Str & Space1 & MathBaseNumStr & Space2 & Codon(CodonNum) & Space2 & CodonCompl(CodonNum) & Space2 & CodonRevCompl(CodonNum)
      'Loop back up for Next Codon Number.
      Next CodonNum
      'Close the disk file.
      Close #1
      'End to return from this subroutine back to the CreateCodonFilesCommand_Click subroutine.
      End Sub

      And program code with no comments, just code lines:

      code :Dim Codon() As String
      Dim CodonCompl() As String
      Dim CodonRevCompl() As String

      Private Sub CreateCodonFilesCommand_Click()
      Dim CodonSizeNum As Long
      For CodonSizeNum = 1 To 8
      Dialog = "Codon Size Number " & CodonSizeNum: Dialog.Refresh
      If CodonSizeCheck(CodonSizeNum) = 1 Then
      Call CreateCodonFile(4, CodonSizeNum)
      DoEvents
      Call CreateCodonFile(5, CodonSizeNum)
      DoEvents
      End If
      Next CodonSizeNum
      Dialog = "Codon Files Successfully Created.": Dialog.Refresh
      End Sub

      Private Sub CreateCodonFile(MathBase As Long, CodonSize As Long)
      Dim MathBaseStr As String
      Dim MathBaseNumStr As String
      Dim Base10Str As String
      Dim FormatZeros As String
      Dim TotalCodons As Long
      Dim CodonNum As Long
      Dim LetterNum As Long
      Dim DigitVal As Long
      Dim PowerOf4or5 As Long
      Dim DigitOnes As Double
      Dim Space1 As String
      Dim Space2 As String

      Dim ACGTN(4) As String
      ACGTN(0) = "A"
      ACGTN(1) = "C"
      ACGTN(2) = "G"
      ACGTN(3) = "T"
      ACGTN(4) = "N"

      Dim Complement(4) As String
      Complement(0) = "T"
      Complement(1) = "G"
      Complement(2) = "C"
      Complement(3) = "A"
      Complement(4) = "N"

      ReDim Codon((MathBase ^ CodonSize) - 1) As String
      ReDim CodonCompl((MathBase ^ CodonSize) - 1) As String
      ReDim CodonRevCompl((MathBase ^ CodonSize) - 1) As String

      MathBaseStr = "Base" & Format(MathBase)
      Open App.Path & "\" & Format(CodonSize) & "Letter" & MathBaseStr & "Codons.txt" For Output As #1
      Print #1, MathBaseStr & ", " & CodonSize & " letter Codon Size, " & CodonSizeCheck(CodonSize).Caption & "s."
      Print #1, "Number shown in math Base10 and " & MathBaseStr & " with"
      Print #1, "Codon, its Complement, Reverse Complement."
      Print #1, ""
      TotalCodons = MathBase ^ CodonSize
      FormatZeros = String(Len(Format(TotalCodons - 1)), "0")
      Space1 = String(9 - Len(FormatZeros), " ")
      Space2 = String(11 - CodonSize, " ")
      Print #1, "---------------------------------------------------------------"
      Print #1, "Base10 " & MathBaseStr & " Codon Compl RevCo"
      Print #1, "---------------------------------------------------------------"
      For CodonNum = 0 To TotalCodons - 1
      Base10Str = Format(CodonNum, FormatZeros)
      MathBaseNumStr = ""
      For LetterNum = 0 To CodonSize - 1
      PowerOf4or5 = MathBase ^ LetterNum
      DigitOnes = Fix(CodonNum / PowerOf4or5)
      DigitVal = DigitOnes - (Fix(DigitOnes / MathBase) * MathBase)
      Codon(CodonNum) = ACGTN(DigitVal) & Codon(CodonNum)
      CodonCompl(CodonNum) = Complement(DigitVal) & CodonCompl(CodonNum)
      CodonRevCompl(CodonNum) = CodonRevCompl(CodonNum) & Complement(DigitVal)
      MathBaseNumStr = Format(DigitVal) & MathBaseNumStr
      Next LetterNum
      Print #1, Base10Str & Space1 & MathBaseNumStr & Space2 & Codon(CodonNum) & Space2 & CodonCompl(CodonNum) & Space2 & CodonRevCompl(CodonNum)
      Next CodonNum
      Close #1
      End Sub

      File examples, up to 3 letter codon size:

      code :Base4, 1 letter Codon Size, Singlets.
      Number shown in math Base10 and Base4 with
      Codon, its Complement, Reverse Complement.

      ---------------------------------------------------------------
      Base10 Base4 Codon Compl RevCo
      ---------------------------------------------------------------
      0 0 A T T
      1 1 C G G
      2 2 G C C
      3 3 T A A

      code :Base5, 1 letter Codon Size, Singlets.
      Number shown in math Base10 and Base5 with
      Codon, its Complement, Reverse Complement.

      ---------------------------------------------------------------
      Base10 Base5 Codon Compl RevCo
      ---------------------------------------------------------------
      0 0 A T T
      1 1 C G G
      2 2 G C C
      3 3 T A A
      4 4 N N N

      code :Base4, 2 letter Codon Size, Doublets.
      Number shown in math Base10 and Base4 with
      Codon, its Complement, Reverse Complement.

      ---------------------------------------------------------------
      Base10 Base4 Codon Compl RevCo
      ---------------------------------------------------------------
      00 00 AA TT TT
      01 01 AC TG GT
      02 02 AG TC CT
      03 03 AT TA AT
      04 10 CA GT TG
      05 11 CC GG GG
      06 12 CG GC CG
      07 13 CT GA AG
      08 20 GA CT TC
      09 21 GC CG GC
      10 22 GG CC CC
      11 23 GT CA AC
      12 30 TA AT TA
      13 31 TC AG GA
      14 32 TG AC CA
      15 33 TT AA AA

      code :Base5, 2 letter Codon Size, Doublets.
      Number shown in math Base10 and Base5 with
      Codon, its Complement, Reverse Complement.

      ---------------------------------------------------------------
      Base10 Base5 Codon Compl RevCo
      ---------------------------------------------------------------
      00 00 AA TT TT
      01 01 AC TG GT
      02 02 AG TC CT
      03 03 AT TA AT
      04 04 AN TN NT
      05 10 CA GT TG
      06 11 CC GG GG
      07 12 CG GC CG
      08 13 CT GA AG
      09 14 CN GN NG
      10 20 GA CT TC
      11 21 GC CG GC
      12 22 GG CC CC
      13 23 GT CA AC
      14 24 GN CN NC
      15 30 TA AT TA
      16 31 TC AG GA
      17 32 TG AC CA
      18 33 TT AA AA
      19 34 TN AN NA
      20 40 NA NT TN
      21 41 NC NG GN
      22 42 NG NC CN
      23 43 NT NA AN
      24 44 NN NN NN

      code :Base4, 3 letter Codon Size, Triplets.
      Number shown in math Base10 and Base4 with
      Codon, its Complement, Reverse Complement.

      ---------------------------------------------------------------
      Base10 Base4 Codon Compl RevCo
      ---------------------------------------------------------------
      00 000 AAA TTT TTT
      01 001 AAC TTG GTT
      02 002 AAG TTC CTT
      03 003 AAT TTA ATT
      04 010 ACA TGT TGT
      05 011 ACC TGG GGT
      06 012 ACG TGC CGT
      07 013 ACT TGA AGT
      08 020 AGA TCT TCT
      09 021 AGC TCG GCT
      10 022 AGG TCC CCT
      11 023 AGT TCA ACT
      12 030 ATA TAT TAT
      13 031 ATC TAG GAT
      14 032 ATG TAC CAT
      15 033 ATT TAA AAT
      16 100 CAA GTT TTG
      17 101 CAC GTG GTG
      18 102 CAG GTC CTG
      19 103 CAT GTA ATG
      20 110 CCA GGT TGG
      21 111 CCC GGG GGG
      22 112 CCG GGC CGG
      23 113 CCT GGA AGG
      24 120 CGA GCT TCG
      25 121 CGC GCG GCG
      26 122 CGG GCC CCG
      27 123 CGT GCA ACG
      28 130 CTA GAT TAG
      29 131 CTC GAG GAG
      30 132 CTG GAC CAG
      31 133 CTT GAA AAG
      32 200 GAA CTT TTC
      33 201 GAC CTG GTC
      34 202 GAG CTC CTC
      35 203 GAT CTA ATC
      36 210 GCA CGT TGC
      37 211 GCC CGG GGC
      38 212 GCG CGC CGC
      39 213 GCT CGA AGC
      40 220 GGA CCT TCC
      41 221 GGC CCG GCC
      42 222 GGG CCC CCC
      43 223 GGT CCA ACC
      44 230 GTA CAT TAC
      45 231 GTC CAG GAC
      46 232 GTG CAC CAC
      47 233 GTT CAA AAC
      48 300 TAA ATT TTA
      49 301 TAC ATG GTA
      50 302 TAG ATC CTA
      51 303 TAT ATA ATA
      52 310 TCA AGT TGA
      53 311 TCC AGG GGA
      54 312 TCG AGC CGA
      55 313 TCT AGA AGA
      56 320 TGA ACT TCA
      57 321 TGC ACG GCA
      58 322 TGG ACC CCA
      59 323 TGT ACA ACA
      60 330 TTA AAT TAA
      61 331 TTC AAG GAA
      62 332 TTG AAC CAA
      63 333 TTT AAA AAA

      code :Base5, 3 letter Codon Size, Triplets.
      Number shown in math Base10 and Base5 with
      Codon, its Complement, Reverse Complement.

      ---------------------------------------------------------------
      Base10 Base5 Codon Compl RevCo
      ---------------------------------------------------------------
      000 000 AAA TTT TTT
      001 001 AAC TTG GTT
      002 002 AAG TTC CTT
      003 003 AAT TTA ATT
      004 004 AAN TTN NTT
      005 010 ACA TGT TGT
      006 011 ACC TGG GGT
      007 012 ACG TGC CGT
      008 013 ACT TGA AGT
      009 014 ACN TGN NGT
      010 020 AGA TCT TCT
      011 021 AGC TCG GCT
      012 022 AGG TCC CCT
      013 023 AGT TCA ACT
      014 024 AGN TCN NCT
      015 030 ATA TAT TAT
      016 031 ATC TAG GAT
      017 032 ATG TAC CAT
      018 033 ATT TAA AAT
      019 034 ATN TAN NAT
      020 040 ANA TNT TNT
      021 041 ANC TNG GNT
      022 042 ANG TNC CNT
      023 043 ANT TNA ANT
      024 044 ANN TNN NNT
      025 100 CAA GTT TTG
      026 101 CAC GTG GTG
      027 102 CAG GTC CTG
      028 103 CAT GTA ATG
      029 104 CAN GTN NTG
      030 110 CCA GGT TGG
      031 111 CCC GGG GGG
      032 112 CCG GGC CGG
      033 113 CCT GGA AGG
      034 114 CCN GGN NGG
      035 120 CGA GCT TCG
      036 121 CGC GCG GCG
      037 122 CGG GCC CCG
      038 123 CGT GCA ACG
      039 124 CGN GCN NCG
      040 130 CTA GAT TAG
      041 131 CTC GAG GAG
      042 132 CTG GAC CAG
      043 133 CTT GAA AAG
      044 134 CTN GAN NAG
      045 140 CNA GNT TNG
      046 141 CNC GNG GNG
      047 142 CNG GNC CNG
      048 143 CNT GNA ANG
      049 144 CNN GNN NNG
      050 200 GAA CTT TTC
      051 201 GAC CTG GTC
      052 202 GAG CTC CTC
      053 203 GAT CTA ATC
      054 204 GAN CTN NTC
      055 210 GCA CGT TGC
      056 211 GCC CGG GGC
      057 212 GCG CGC CGC
      058 213 GCT CGA AGC
      059 214 GCN CGN NGC
      060 220 GGA CCT TCC
      061 221 GGC CCG GCC
      062 222 GGG CCC CCC
      063 223 GGT CCA ACC
      064 224 GGN CCN NCC
      065 230 GTA CAT TAC
      066 231 GTC CAG GAC
      067 232 GTG CAC CAC
      068 233 GTT CAA AAC
      069 234 GTN CAN NAC
      070 240 GNA CNT TNC
      071 241 GNC CNG GNC
      072 242 GNG CNC CNC
      073 243 GNT CNA ANC
      074 244 GNN CNN NNC
      075 300 TAA ATT TTA
      076 301 TAC ATG GTA
      077 302 TAG ATC CTA
      078 303 TAT ATA ATA
      079 304 TAN ATN NTA
      080 310 TCA AGT TGA
      081 311 TCC AGG GGA
      082 312 TCG AGC CGA
      083 313 TCT AGA AGA
      084 314 TCN AGN NGA
      085 320 TGA ACT TCA
      086 321 TGC ACG GCA
      087 322 TGG ACC CCA
      088 323 TGT ACA ACA
      089 324 TGN ACN NCA
      090 330 TTA AAT TAA
      091 331 TTC AAG GAA
      092 332 TTG AAC CAA
      093 333 TTT AAA AAA
      094 334 TTN AAN NAA
      095 340 TNA ANT TNA
      096 341 TNC ANG GNA
      097 342 TNG ANC CNA
      098 343 TNT ANA ANA
      099 344 TNN ANN NNA
      100 400 NAA NTT TTN
      101 401 NAC NTG GTN
      102 402 NAG NTC CTN
      103 403 NAT NTA ATN
      104 404 NAN NTN NTN
      105 410 NCA NGT TGN
      106 411 NCC NGG GGN
      107 412 NCG NGC CGN
      108 413 NCT NGA AGN
      109 414 NCN NGN NGN
      110 420 NGA NCT TCN
      111 421 NGC NCG GCN
      112 422 NGG NCC CCN
      113 423 NGT NCA ACN
      114 424 NGN NCN NCN
      115 430 NTA NAT TAN
      116 431 NTC NAG GAN
      117 432 NTG NAC CAN
      118 433 NTT NAA AAN
      119 434 NTN NAN NAN
      120 440 NNA NNT TNN
      121 441 NNC NNG GNN
      122 442 NNG NNC CNN
      123 443 NNT NNA ANN
      124 444 NNN NNN NNN

      I have the source code, compiled exe to run on Windows, with codon files it generates here:

      https://sites.google.com/site/digitalch … Codons.zip

      I’m now looking for anything out of place in variable names, terminology and how things are explained. So if you noticed something that does not seem quite right then please let me know.

Viewing 4 reply threads
  • You must be logged in to reply to this topic.