Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
CodingUtils	29	51	20	0.00%	Show methods

Class CodingUtils

Class CodingUtils	Line # 29	Total Statements 51	Complexity 20	TOTAL Coverage 0.00%
encodeCodon(char[]) : int   encodeCodon(char[]) : int	4848	3.03	2.02	0.0 0.00%
encodeCodon(char) : int   encodeCodon(char) : int	6666	21.021	11.011	0.0 0.00%
decodeCodon(int) : char[]   decodeCodon(int) : char[]	101101	7.07	1.01	0.0 0.00%
decodeCodon2(int,char[]) : void   decodeCodon2(int,char[]) : void	112112	5.05	1.01	0.0 0.00%
decodeNucleotide(int) : char   decodeNucleotide(int) : char	127127	15.015	5.05	0.0 0.00%

 

Contributing tests

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.analysis;
22
23		/**
24		* A utility class to provide encoding/decoding schemes for data.
25		*
26		* @author gmcarstairs
27		*
28		*/
		0% Uncovered Elements: 58 (58) Complexity: 20 Complexity Density: 0.39
29		public class CodingUtils
30		{
31
32		/*
33		* Number of bits used when encoding codon characters. 2 is enough for ACGT.
34		* To accommodate more (e.g. ambiguity codes), simply increase this number
35		* (and adjust unit tests to match).
36		*/
37		private static final int CODON_ENCODING_BITSHIFT = 2;
38
39		/**
40		* Encode a codon from e.g. ['A', 'G', 'C'] to a number in the range 0 - 63.
41		* Converts lower to upper case, U to T, then assembles a binary value by
42		* encoding A/C/G/T as 00/01/10/11 respectively and shifting.
43		*
44		* @param codon
45		* @return the encoded codon, or a negative number if unexpected characters
46		* found
47		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
48	0	public static int encodeCodon(char[] codon)...
49		{
50	0	if (codon == null)
51		{
52	0	return -1;
53		}
54	0	return encodeCodon(codon[2])
55		+ (encodeCodon(codon[1]) << CODON_ENCODING_BITSHIFT)
56		+ (encodeCodon(codon[0]) << (2 * CODON_ENCODING_BITSHIFT));
57		}
58
59		/**
60		* Encodes aA/cC/gG/tTuU as 0/1/2/3 respectively. Returns Integer.MIN_VALUE (a
61		* large negative value) for any other character.
62		*
63		* @param c
64		* @return
65		*/
		0% Uncovered Elements: 21 (21) Complexity: 11 Complexity Density: 0.52
66	0	public static int encodeCodon(char c)...
67		{
68	0	int result = Integer.MIN_VALUE;
69	0	switch (c)
70		{
71	0	case 'A':
72	0	case 'a':
73	0	result = 0;
74	0	break;
75	0	case 'C':
76	0	case 'c':
77	0	result = 1;
78	0	break;
79	0	case 'G':
80	0	case 'g':
81	0	result = 2;
82	0	break;
83	0	case 'T':
84	0	case 't':
85	0	case 'U':
86	0	case 'u':
87	0	result = 3;
88	0	break;
89		}
90	0	return result;
91		}
92
93		/**
94		* Converts a binary encoded codon into an ['A', 'C', 'G'] (or 'T') triplet.
95		*
96		* The two low-order bits encode for A/C/G/T as 0/1/2/3, etc.
97		*
98		* @param encoded
99		* @return
100		*/
		0% Uncovered Elements: 7 (7) Complexity: 1 Complexity Density: 0.14
101	0	public static char[] decodeCodon(int encoded)...
102		{
103	0	char[] result = new char[3];
104	0	result[2] = decodeNucleotide(encoded & 3);
105	0	encoded = encoded >>> CODON_ENCODING_BITSHIFT;
106	0	result[1] = decodeNucleotide(encoded & 3);
107	0	encoded = encoded >>> CODON_ENCODING_BITSHIFT;
108	0	result[0] = decodeNucleotide(encoded & 3);
109	0	return result;
110		}
111
		0% Uncovered Elements: 5 (5) Complexity: 1 Complexity Density: 0.2
112	0	public static void decodeCodon2(int encoded, char[] result)...
113		{
114	0	result[2] = decodeNucleotide(encoded & 3);
115	0	encoded = encoded >>> CODON_ENCODING_BITSHIFT;
116	0	result[1] = decodeNucleotide(encoded & 3);
117	0	encoded = encoded >>> CODON_ENCODING_BITSHIFT;
118	0	result[0] = decodeNucleotide(encoded & 3);
119		}
120
121		/**
122		* Convert value 0/1/2/3 to 'A'/'C'/'G'/'T'
123		*
124		* @param i
125		* @return
126		*/
		0% Uncovered Elements: 15 (15) Complexity: 5 Complexity Density: 0.33
127	0	public static char decodeNucleotide(int i)...
128		{
129	0	char result = '0';
130	0	switch (i)
131		{
132	0	case 0:
133	0	result = 'A';
134	0	break;
135	0	case 1:
136	0	result = 'C';
137	0	break;
138	0	case 2:
139	0	result = 'G';
140	0	break;
141	0	case 3:
142	0	result = 'T';
143	0	break;
144		}
145	0	return result;
146		}
147
148		}