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

[GaryGaulin]

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?

[JackBean]

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?

[GaryGaulin]

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.

[GaryGaulin]

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:

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.

[GaryGaulin]

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: Select all

'==================================================================================================
'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: Select all

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: Select all

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: Select all

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: Select all

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: Select all

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: Select all

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: Select all

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.