Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
AlignmentGenerator	50	84	28	0.7230769472.3%	Show methods

Class AlignmentGenerator

Class AlignmentGenerator	Line # 50	Total Statements 84	Complexity 28	TOTAL Coverage 0.7230769472.3%
main(String[]) : void   main(String[]) : void	8383	16.016	5.05	0.0 0.00%
usage() : void   usage() : void	120120	10.010	1.01	0.0 0.00%
AlignmentGenerator(boolean)   AlignmentGenerator(boolean)	143143	1.01	1.01	1.0 1.0100%
AlignmentGenerator(boolean,PrintStream)   AlignmentGenerator(boolean,PrintStream)	153153	2.02	2.02	1.0 1.0100%
generate(int,int,long,int,int) : AlignmentI   generate(int,int,long,int,int) : AlignmentI	169169	9.09	3.03	0.9230769 0.923076992.3%
generateSequence(int,int,int) : SequenceI   generateSequence(int,int,int) : SequenceI	197197	12.012	4.04	1.0 1.0100%
generateAnotherSequence(char[],int,int,int) : SequenceI   generateAnotherSequence(char[],int,int,int) : SequenceI	233233	27.027	9.09	0.9767442 0.976744297.7%
randomCharacter(char,int) : char   randomCharacter(char,int) : char	306306	7.07	3.03	1.0 1.0100%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.6230769	jalview.datamodel.HiddenColumnsTest.testHideColumnsjalview.datamodel.HiddenColumnsTest.testHideColumns	1PASS
	0.56153846	jalview.datamodel.AlignmentTest.testDeleteSequenceByIndexjalview.datamodel.AlignmentTest.testDeleteSequenceByIndex	1PASS
	0.56153846	jalview.datamodel.AlignmentTest.testDeleteSequenceBySeqjalview.datamodel.AlignmentTest.testDeleteSequenceBySeq	1PASS
	0.56153846	jalview.datamodel.AlignmentTest.testDeleteHiddenSequencejalview.datamodel.AlignmentTest.testDeleteHiddenSequence	1PASS
	0.56153846	jalview.analysis.DnaTest.testTranslateCdna_sequenceOrderIndependentjalview.analysis.DnaTest.testTranslateCdna_sequenceOrderIndependent	1PASS
	0.50769234	jalview.datamodel.AlignmentTest.testPropagateInsertionsjalview.datamodel.AlignmentTest.testPropagateInsertions	1PASS
	0.50769234	jalview.datamodel.AlignmentTest.testPropagateInsertionsOverlapjalview.datamodel.AlignmentTest.testPropagateInsertionsOverlap	1PASS

 

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		import java.util.Locale;
24
25		import jalview.datamodel.Alignment;
26		import jalview.datamodel.AlignmentI;
27		import jalview.datamodel.Sequence;
28		import jalview.datamodel.SequenceI;
29		import jalview.gui.JvOptionPane;
30		import jalview.io.FastaFile;
31
32		import java.io.File;
33		import java.io.FileNotFoundException;
34		import java.io.PrintStream;
35		import java.util.Arrays;
36		import java.util.Random;
37
38		import org.testng.annotations.BeforeClass;
39
40		/**
41		* Generates, and outputs in Fasta format, a random peptide or nucleotide
42		* alignment for given sequence length and count. Will regenerate the same
43		* alignment each time if the same random seed is used (so may be used for
44		* reproducible unit tests). Not guaranteed to reproduce the same results
45		* between versions, as the rules may get tweaked to produce more 'realistic'
46		* results.
47		*
48		* @author gmcarstairs
49		*/
		72.3% Uncovered Elements: 36 (130) Complexity: 28 Complexity Density: 0.33
50		public class AlignmentGenerator
51		{
52		private static final char GAP = '-';
53
54		private static final char ZERO = '0';
55
56		private static final char[] NUCS = "GTCA".toCharArray();
57
58		private static final char[] PEPS = "MILVFYWHKRDEQNTCGASNP".toCharArray();
59
60		private static char[] BASES;
61
62		private Random random;
63
64		private PrintStream ps;
65
66		/**
67		* Outputs a pseudo-randomly generated nucleotide or peptide alignment
68		* Arguments:
69		* <ul>
70		* <li>n (for nucleotide) or p (for peptide)</li>
71		* <li>length (number of bases in each sequence)</li>
72		* <li>height (number of sequences)</li>
73		* <li>a whole number random seed</li>
74		* <li>percentage of gaps to include (0-100)</li>
75		* <li>percentage chance of variation of each position (0-100)</li>
76		* <li>(optional) path to a file to write the alignment to</li>
77		* </ul>
78		*
79		*
80		* @param args
81		* @throws FileNotFoundException
82		*/
		0% Uncovered Elements: 22 (22) Complexity: 5 Complexity Density: 0.31
83	0	public static void main(String[] args) throws FileNotFoundException...
84		{
85	0	if (args.length != 6 && args.length != 7)
86		{
87	0	usage();
88	0	return;
89		}
90
91	0	PrintStream ps = System.out;
92	0	if (args.length == 7)
93		{
94	0	ps = new PrintStream(new File(args[6]));
95		}
96
97	0	boolean nucleotide = args[0].toLowerCase(Locale.ROOT).startsWith("n");
98	0	int width = Integer.parseInt(args[1]);
99	0	int height = Integer.parseInt(args[2]);
100	0	long randomSeed = Long.valueOf(args[3]);
101	0	int gapPercentage = Integer.valueOf(args[4]);
102	0	int changePercentage = Integer.valueOf(args[5]);
103
104	0	ps.println("; " + height + " sequences of " + width + " bases with "
105		+ gapPercentage + "% gaps and " + changePercentage
106		+ "% mutations (random seed = " + randomSeed + ")");
107
108	0	new AlignmentGenerator(nucleotide, ps).generate(width, height,
109		randomSeed, gapPercentage, changePercentage);
110
111	0	if (ps != System.out)
112		{
113	0	ps.close();
114		}
115		}
116
117		/**
118		* Prints parameter help
119		*/
		0% Uncovered Elements: 10 (10) Complexity: 1 Complexity Density: 0.1
120	0	private static void usage()...
121		{
122	0	System.out.println("Usage:");
123	0	System.out.println("arg0: n (for nucleotide) or p (for peptide)");
124	0	System.out.println("arg1: number of (non-gap) bases per sequence");
125	0	System.out.println("arg2: number of sequences");
126	0	System.out.println(
127		"arg3: an integer as random seed (same seed = same results)");
128	0	System.out.println("arg4: percentage of gaps to (randomly) generate");
129	0	System.out.println(
130		"arg5: percentage of 'mutations' to (randomly) generate");
131	0	System.out.println(
132		"arg6: (optional) path to output file (default is sysout)");
133	0	System.out.println("Example: AlignmentGenerator n 12 15 387 10 5");
134	0	System.out.println(
135		"- 15 nucleotide sequences of 12 bases each, approx 10% gaps and 5% mutations, random seed = 387");
136
137		}
138
139		/**
140		* Constructor that sets nucleotide or peptide symbol set, and also writes the
141		* generated alignment to sysout
142		*/
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
143	8	public AlignmentGenerator(boolean nuc)...
144		{
145	8	this(nuc, System.out);
146		}
147
148		/**
149		* Constructor that sets nucleotide or peptide symbol set, and also writes the
150		* generated alignment to the specified output stream (if not null). This can
151		* be used to write the alignment to a file or sysout.
152		*/
		100% Uncovered Elements: 0 (4) Complexity: 2 Complexity Density: 1
153	8	public AlignmentGenerator(boolean nucleotide, PrintStream printStream)...
154		{
155	8	BASES = nucleotide ? NUCS : PEPS;
156	8	ps = printStream;
157		}
158
159		/**
160		* Outputs an 'alignment' of given width and height, where each position is a
161		* random choice from the symbol alphabet, or - for gap
162		*
163		* @param width
164		* @param height
165		* @param randomSeed
166		* @param changePercentage
167		* @param gapPercentage
168		*/
		92.3% Uncovered Elements: 1 (13) Complexity: 3 Complexity Density: 0.33
169	9	public AlignmentI generate(int width, int height, long randomSeed,...
170		int gapPercentage, int changePercentage)
171		{
172	9	SequenceI[] seqs = new SequenceI[height];
173	9	random = new Random(randomSeed);
174	9	seqs[0] = generateSequence(1, width, gapPercentage);
175	125	for (int seqno = 1; seqno < height; seqno++)
176		{
177	116	seqs[seqno] = generateAnotherSequence(seqs[0].getSequence(),
178		seqno + 1, width, changePercentage);
179		}
180	9	AlignmentI al = new Alignment(seqs);
181
182	9	if (ps != null)
183		{
184	9	ps.println(new FastaFile().print(al.getSequencesArray(), true));
185		}
186
187	9	return al;
188		}
189
190		/**
191		* Outputs a DNA 'sequence' of given length, with some random gaps included.
192		*
193		* @param seqno
194		* @param length
195		* @param gapPercentage
196		*/
		100% Uncovered Elements: 0 (18) Complexity: 4 Complexity Density: 0.33
197	9	private SequenceI generateSequence(int seqno, int length,...
198		int gapPercentage)
199		{
200	9	StringBuilder seq = new StringBuilder(length);
201
202		/*
203		* Loop till we've added 'length' bases (excluding gaps)
204		*/
205	205	for (int count = 0; count < length;)
206		{
207	196	boolean addGap = random.nextInt(100) < gapPercentage;
208	196	char c = addGap ? GAP
209		: BASES[random.nextInt(Integer.MAX_VALUE) % BASES.length];
210	196	seq.append(c);
211	196	if (!addGap)
212		{
213	194	count++;
214		}
215		}
216	9	final String seqName = "SEQ" + seqno;
217	9	final String seqString = seq.toString();
218	9	SequenceI sq = new Sequence(seqName, seqString);
219	9	sq.createDatasetSequence();
220	9	return sq;
221		}
222
223		/**
224		* Generate a sequence approximately aligned to the first one.
225		*
226		* @param ds
227		* @param seqno
228		* @param width
229		* number of bases
230		* @param changePercentage
231		* @return
232		*/
		97.7% Uncovered Elements: 1 (43) Complexity: 9 Complexity Density: 0.33
233	116	private SequenceI generateAnotherSequence(char[] ds, int seqno, int width,...
234		int changePercentage)
235		{
236	116	int length = ds.length;
237	116	char[] seq = new char[length];
238	116	Arrays.fill(seq, ZERO);
239	116	int gapsWanted = length - width;
240	116	int gapsAdded = 0;
241
242		/*
243		* First 'randomly' mimic gaps in model sequence.
244		*/
245	3030	for (int pos = 0; pos < length; pos++)
246		{
247	2914	if (ds[pos] == GAP)
248		{
249		/*
250		* Add a gap at the same position with changePercentage likelihood
251		*/
252	48	seq[pos] = randomCharacter(GAP, changePercentage);
253	48	if (seq[pos] == GAP)
254		{
255	46	gapsAdded++;
256		}
257		}
258		}
259
260		/*
261		* Next scatter any remaining gaps (if any) at random. This gives an even
262		* distribution.
263		*/
264	118	while (gapsAdded < gapsWanted)
265		{
266	2	boolean added = false;
267	4	while (!added)
268		{
269	2	int pos = random.nextInt(length);
270	2	if (seq[pos] != GAP)
271		{
272	2	seq[pos] = GAP;
273	2	added = true;
274	2	gapsAdded++;
275		}
276		}
277		}
278
279		/*
280		* Finally fill in the rest with randomly mutated bases.
281		*/
282	3030	for (int pos = 0; pos < length; pos++)
283		{
284	2914	if (seq[pos] == ZERO)
285		{
286	2865	char c = randomCharacter(ds[pos], changePercentage);
287	2865	seq[pos] = c;
288		}
289		}
290	116	final String seqName = "SEQ" + seqno;
291	116	final String seqString = new String(seq);
292	116	SequenceI sq = new Sequence(seqName, seqString);
293	116	sq.createDatasetSequence();
294	116	return sq;
295		}
296
297		/**
298		* Returns a random character that is changePercentage% likely to match the
299		* given type (as base or gap).
300		*
301		* @param changePercentage
302		*
303		* @param c
304		* @return
305		*/
		100% Uncovered Elements: 0 (11) Complexity: 3 Complexity Density: 0.43
306	2913	private char randomCharacter(char c, int changePercentage)...
307		{
308	2913	final boolean mutation = random.nextInt(100) < changePercentage;
309
310	2913	if (!mutation)
311		{
312	2798	return c;
313		}
314
315	115	char newchar = c;
316	236	while (newchar == c)
317		{
318	121	newchar = BASES[random.nextInt(Integer.MAX_VALUE) % BASES.length];
319		}
320	115	return newchar;
321		}
322		}