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:

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.

[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 :'==================================================================================================
'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.

[Author]

Posts